{"version":3,"file":"static/module-apollo.cc95d7dd.js","mappings":"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","sources":["webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/core/cache.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/core/types/common.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/inmemory/helpers.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/inmemory/entityStore.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/inmemory/readFromStore.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/inmemory/key-extractor.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/inmemory/policies.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/inmemory/writeToStore.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/inmemory/inMemoryCache.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/inmemory/object-canon.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/cache/inmemory/reactiveVars.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/core/execute.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/HttpLink.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/observables/asyncMap.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/errorHandling.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/observables/iteration.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/observables/subclassing.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/observables/Concast.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/core/equalByQuery.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/core/ObservableQuery.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/core/LocalState.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/core/QueryInfo.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/core/QueryManager.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/core/ApolloClient.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/core/networkStatus.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/dev/loadDevMessages.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/dev/loadErrorMessageHandler.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/dev/loadErrorMessages.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/errors/index.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/invariantErrorCodes.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/context/index.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/utils/createOperation.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/utils/transformOperation.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/utils/validateOperation.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/core/ApolloLink.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/core/from.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/core/split.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/error/index.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/serializeFetchParameter.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/selectURI.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/iterators/async.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/iterators/nodeStream.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/iterators/promise.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/iterators/reader.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/responseIterator.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/utils/throwServerError.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/checkFetcher.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/selectHttpOptionsAndBody.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/rewriteURIForGET.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/utils/fromError.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/utils/filterOperationVariables.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/http/createHttpLink.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/retry/delayFunction.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/retry/retryFunction.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/retry/retryLink.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/link/subscriptions/index.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/context/ApolloContext.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/context/ApolloProvider.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/useApolloClient.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/useLazyQuery.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/useMutation.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/useSyncExternalStore.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/useQuery.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/useSubscription.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/promises/decoration.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/internal/__use.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/internal/useDeepMemo.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/cache/QueryReference.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/cache/SuspenseCache.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/cache/getSuspenseCache.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/constants.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/hooks/useSuspenseQuery.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/react/parser/index.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/arrays.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/canUse.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/cloneDeep.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/compact.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/incrementalResult.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/makeUniqueId.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/maybeDeepFreeze.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/mergeDeep.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/mergeOptions.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/objects.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/common/stringifyForDisplay.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/globals/global.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/globals/index.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/globals/invariantWrappers.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/globals/maybe.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/graphql/DocumentTransform.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/graphql/directives.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/graphql/fragments.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/graphql/getFromAST.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/graphql/print.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/graphql/storeUtils.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/utilities/graphql/transform.js","webpack://@spotify-confidence/app/../../node_modules/@apollo/client/version.js"],"sourcesContent":["import { __assign, __rest } from \"tslib\";\nimport { wrap } from \"optimism\";\nimport { getFragmentQueryDocument } from \"../../utilities/index.js\";\nvar ApolloCache = /** @class */ (function () {\n    function ApolloCache() {\n        this.assumeImmutableResults = false;\n        // Make sure we compute the same (===) fragment query document every\n        // time we receive the same fragment in readFragment.\n        this.getFragmentDoc = wrap(getFragmentQueryDocument);\n    }\n    // Transactional API\n    // The batch method is intended to replace/subsume both performTransaction\n    // and recordOptimisticTransaction, but performTransaction came first, so we\n    // provide a default batch implementation that's just another way of calling\n    // performTransaction. Subclasses of ApolloCache (such as InMemoryCache) can\n    // override the batch method to do more interesting things with its options.\n    ApolloCache.prototype.batch = function (options) {\n        var _this = this;\n        var optimisticId = typeof options.optimistic === \"string\" ? options.optimistic\n            : options.optimistic === false ? null\n                : void 0;\n        var updateResult;\n        this.performTransaction(function () { return (updateResult = options.update(_this)); }, optimisticId);\n        return updateResult;\n    };\n    ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {\n        this.performTransaction(transaction, optimisticId);\n    };\n    // Optional API\n    // Called once per input document, allowing the cache to make static changes\n    // to the query, such as adding __typename fields.\n    ApolloCache.prototype.transformDocument = function (document) {\n        return document;\n    };\n    // Called before each ApolloLink request, allowing the cache to make dynamic\n    // changes to the query, such as filling in missing fragment definitions.\n    ApolloCache.prototype.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.identify = function (object) {\n        return;\n    };\n    ApolloCache.prototype.gc = function () {\n        return [];\n    };\n    ApolloCache.prototype.modify = function (options) {\n        return false;\n    };\n    // DataProxy API\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read(__assign(__assign({}, options), { rootId: options.id || \"ROOT_QUERY\", optimistic: optimistic }));\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read(__assign(__assign({}, options), { query: this.getFragmentDoc(options.fragment, options.fragmentName), rootId: options.id, optimistic: optimistic }));\n    };\n    ApolloCache.prototype.writeQuery = function (_a) {\n        var id = _a.id, data = _a.data, options = __rest(_a, [\"id\", \"data\"]);\n        return this.write(Object.assign(options, {\n            dataId: id || \"ROOT_QUERY\",\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.writeFragment = function (_a) {\n        var id = _a.id, data = _a.data, fragment = _a.fragment, fragmentName = _a.fragmentName, options = __rest(_a, [\"id\", \"data\", \"fragment\", \"fragmentName\"]);\n        return this.write(Object.assign(options, {\n            query: this.getFragmentDoc(fragment, fragmentName),\n            dataId: id,\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.updateQuery = function (options, update) {\n        return this.batch({\n            update: function (cache) {\n                var value = cache.readQuery(options);\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeQuery(__assign(__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    ApolloCache.prototype.updateFragment = function (options, update) {\n        return this.batch({\n            update: function (cache) {\n                var value = cache.readFragment(options);\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeFragment(__assign(__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    return ApolloCache;\n}());\nexport { ApolloCache };\n//# sourceMappingURL=cache.js.map","import { __extends } from \"tslib\";\nvar MissingFieldError = /** @class */ (function (_super) {\n    __extends(MissingFieldError, _super);\n    function MissingFieldError(message, path, query, variables) {\n        var _a;\n        // 'Error' breaks prototype chain here\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.path = path;\n        _this.query = query;\n        _this.variables = variables;\n        if (Array.isArray(_this.path)) {\n            _this.missing = _this.message;\n            for (var i = _this.path.length - 1; i >= 0; --i) {\n                _this.missing = (_a = {}, _a[_this.path[i]] = _this.missing, _a);\n            }\n        }\n        else {\n            _this.missing = _this.path;\n        }\n        // We're not using `Object.setPrototypeOf` here as it isn't fully supported\n        // on Android (see issue #3236).\n        _this.__proto__ = MissingFieldError.prototype;\n        return _this;\n    }\n    return MissingFieldError;\n}(Error));\nexport { MissingFieldError };\n//# sourceMappingURL=common.js.map","import { isReference, isField, DeepMerger, resultKeyNameFromField, shouldInclude, isNonNullObject, compact, createFragmentMap, getFragmentDefinitions, isArray, } from \"../../utilities/index.js\";\nexport var hasOwn = Object.prototype.hasOwnProperty;\nexport function isNullish(value) {\n    return value === null || value === void 0;\n}\nexport { isArray };\nexport function defaultDataIdFromObject(_a, context) {\n    var __typename = _a.__typename, id = _a.id, _id = _a._id;\n    if (typeof __typename === \"string\") {\n        if (context) {\n            context.keyObject =\n                !isNullish(id) ? { id: id }\n                    : !isNullish(_id) ? { _id: _id }\n                        : void 0;\n        }\n        // If there is no object.id, fall back to object._id.\n        if (isNullish(id) && !isNullish(_id)) {\n            id = _id;\n        }\n        if (!isNullish(id)) {\n            return \"\".concat(__typename, \":\").concat(typeof id === \"number\" || typeof id === \"string\" ?\n                id\n                : JSON.stringify(id));\n        }\n    }\n}\nvar defaultConfig = {\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    // Thanks to the shouldCanonizeResults helper, this should be the only line\n    // you have to change to reenable canonization by default in the future.\n    canonizeResults: false,\n};\nexport function normalizeConfig(config) {\n    return compact(defaultConfig, config);\n}\nexport function shouldCanonizeResults(config) {\n    var value = config.canonizeResults;\n    return value === void 0 ? defaultConfig.canonizeResults : value;\n}\nexport function getTypenameFromStoreObject(store, objectOrReference) {\n    return isReference(objectOrReference) ?\n        store.get(objectOrReference.__ref, \"__typename\")\n        : objectOrReference && objectOrReference.__typename;\n}\nexport var TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;\nexport function fieldNameFromStoreName(storeFieldName) {\n    var match = storeFieldName.match(TypeOrFieldNameRegExp);\n    return match ? match[0] : storeFieldName;\n}\nexport function selectionSetMatchesResult(selectionSet, result, variables) {\n    if (isNonNullObject(result)) {\n        return isArray(result) ?\n            result.every(function (item) {\n                return selectionSetMatchesResult(selectionSet, item, variables);\n            })\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                // If the selection has been skipped with @skip(true) or\n                // @include(false), it should not count against the matching. If\n                // the selection is not a field, it must be a fragment (inline or\n                // named). We will determine if selectionSetMatchesResult for that\n                // fragment when we get to it, so for now we return true.\n                return true;\n            });\n    }\n    return false;\n}\nexport function storeValueIsStoreObject(value) {\n    return isNonNullObject(value) && !isReference(value) && !isArray(value);\n}\nexport function makeProcessedFieldsMerger() {\n    return new DeepMerger();\n}\nexport function extractFragmentContext(document, fragments) {\n    // FragmentMap consisting only of fragments defined directly in document, not\n    // including other fragments registered in the FragmentRegistry.\n    var fragmentMap = createFragmentMap(getFragmentDefinitions(document));\n    return {\n        fragmentMap: fragmentMap,\n        lookupFragment: function (name) {\n            var def = fragmentMap[name];\n            if (!def && fragments) {\n                def = fragments.lookup(name);\n            }\n            return def || null;\n        },\n    };\n}\n//# sourceMappingURL=helpers.js.map","import { __assign, __extends, __rest } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { dep } from \"optimism\";\nimport { equal } from \"@wry/equality\";\nimport { Trie } from \"@wry/trie\";\nimport { isReference, makeReference, DeepMerger, maybeDeepFreeze, canUseWeakMap, isNonNullObject, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName } from \"./helpers.js\";\nvar DELETE = Object.create(null);\nvar delModifier = function () { return DELETE; };\nvar INVALIDATE = Object.create(null);\nvar EntityStore = /** @class */ (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        // Maps root entity IDs to the number of times they have been retained, minus\n        // the number of times they have been released. Retained entities keep other\n        // entities they reference (even indirectly) from being garbage collected.\n        this.rootIds = Object.create(null);\n        // Lazily tracks { __ref: <dataId> } strings contained by this.data[dataId].\n        this.refs = Object.create(null);\n        // Bound function that can be passed around to provide easy access to fields\n        // of Reference objects as well as ordinary objects.\n        this.getFieldValue = function (objectOrReference, storeFieldName) {\n            return maybeDeepFreeze(isReference(objectOrReference) ?\n                _this.get(objectOrReference.__ref, storeFieldName)\n                : objectOrReference && objectOrReference[storeFieldName]);\n        };\n        // Returns true for non-normalized StoreObjects and non-dangling\n        // References, indicating that readField(name, objOrRef) has a chance of\n        // working. Useful for filtering out dangling references from lists.\n        this.canRead = function (objOrRef) {\n            return isReference(objOrRef) ?\n                _this.has(objOrRef.__ref)\n                : typeof objOrRef === \"object\";\n        };\n        // Bound function that converts an id or an object with a __typename and\n        // primary key fields to a Reference object. If called with a Reference object,\n        // that same Reference object is returned. Pass true for mergeIntoStore to persist\n        // an object into the store.\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    // Although the EntityStore class is abstract, it contains concrete\n    // implementations of the various NormalizedCache interface methods that\n    // are inherited by the Root and Layer subclasses.\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        // The has method (above) calls lookup with dependOnExistence = true, so\n        // that it can later be invalidated when we add or remove a StoreObject for\n        // this dataId. Any consumer who cares about the contents of the StoreObject\n        // should not rely on this dependency, since the contents could change\n        // without the object being added or removed.\n        if (dependOnExistence)\n            this.group.depend(dataId, \"__exists\");\n        if (hasOwn.call(this.data, dataId)) {\n            return this.data[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.lookup(dataId, dependOnExistence);\n        }\n        if (this.policies.rootTypenamesById[dataId]) {\n            return Object.create(null);\n        }\n    };\n    EntityStore.prototype.merge = function (older, newer) {\n        var _this = this;\n        var dataId;\n        // Convert unexpected references to ID strings.\n        if (isReference(older))\n            older = older.__ref;\n        if (isReference(newer))\n            newer = newer.__ref;\n        var existing = typeof older === \"string\" ? this.lookup((dataId = older)) : older;\n        var incoming = typeof newer === \"string\" ? this.lookup((dataId = newer)) : newer;\n        // If newer was a string ID, but that ID was not defined in this store,\n        // then there are no fields to be merged, so we're done.\n        if (!incoming)\n            return;\n        invariant(typeof dataId === \"string\", 1);\n        var merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);\n        // Even if merged === existing, existing may have come from a lower\n        // layer, so we always need to set this.data[dataId] on this level.\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 we added a new StoreObject where there was previously none, dirty\n                // anything that depended on the existence of this dataId, such as the\n                // EntityStore#has method.\n                if (!existing)\n                    fieldsToDirty_1.__exists = 1;\n                // Now invalidate dependents who called getFieldValue for any fields\n                // that are changing as a result of this merge.\n                Object.keys(incoming).forEach(function (storeFieldName) {\n                    if (!existing ||\n                        existing[storeFieldName] !== merged[storeFieldName]) {\n                        // Always dirty the full storeFieldName, which may include\n                        // serialized arguments following the fieldName prefix.\n                        fieldsToDirty_1[storeFieldName] = 1;\n                        // Also dirty fieldNameFromStoreName(storeFieldName) if it's\n                        // different from storeFieldName and this field does not have\n                        // keyArgs configured, because that means the cache can't make\n                        // any assumptions about how field values with the same field\n                        // name but different arguments might be interrelated, so it\n                        // must err on the side of invalidating all field values that\n                        // share the same short fieldName, regardless of arguments.\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] has become undefined, and this is the\n                        // Root layer, actually delete the property from the merged object,\n                        // which is guaranteed to have been created fresh in this method.\n                        if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {\n                            delete merged[storeFieldName];\n                        }\n                    }\n                });\n                if (fieldsToDirty_1.__typename &&\n                    !(existing && existing.__typename) &&\n                    // Since we return default root __typename strings\n                    // automatically from store.get, we don't need to dirty the\n                    // ROOT_QUERY.__typename field if merged.__typename is equal\n                    // to the default string (usually \"Query\").\n                    this.policies.rootTypenamesById[dataId] === merged.__typename) {\n                    delete fieldsToDirty_1.__typename;\n                }\n                Object.keys(fieldsToDirty_1).forEach(function (fieldName) {\n                    return _this.group.dirty(dataId, fieldName);\n                });\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) {\n                    return _this.policies.readField(typeof fieldNameOrOptions === \"string\" ?\n                        {\n                            fieldName: fieldNameOrOptions,\n                            from: from || makeReference(dataId),\n                        }\n                        : fieldNameOrOptions, { store: _this });\n                },\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\" ? fields : (fields[storeFieldName] || fields[fieldName]);\n                if (modify) {\n                    var newValue = modify === delModifier ? DELETE : (modify(maybeDeepFreeze(fieldValue), __assign(__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) })));\n                    if (newValue === INVALIDATE) {\n                        _this.group.dirty(dataId, storeFieldName);\n                    }\n                    else {\n                        if (newValue === DELETE)\n                            newValue = void 0;\n                        if (newValue !== fieldValue) {\n                            changedFields_1[storeFieldName] = newValue;\n                            needToMerge_1 = true;\n                            fieldValue = newValue;\n                            if (globalThis.__DEV__ !== false) {\n                                var checkReference = function (ref) {\n                                    if (_this.lookup(ref.__ref) === undefined) {\n                                        globalThis.__DEV__ !== false && invariant.warn(2, ref);\n                                        return true;\n                                    }\n                                };\n                                if (isReference(newValue)) {\n                                    checkReference(newValue);\n                                }\n                                else if (Array.isArray(newValue)) {\n                                    // Warn about writing \"mixed\" arrays of Reference and non-Reference objects\n                                    var seenReference = false;\n                                    var someNonReference = void 0;\n                                    for (var _i = 0, newValue_1 = newValue; _i < newValue_1.length; _i++) {\n                                        var value = newValue_1[_i];\n                                        if (isReference(value)) {\n                                            seenReference = true;\n                                            if (checkReference(value))\n                                                break;\n                                        }\n                                        else {\n                                            // Do not warn on primitive values, since those could never be represented\n                                            // by a reference. This is a valid (albeit uncommon) use case.\n                                            if (typeof value === \"object\" && !!value) {\n                                                var id = _this.policies.identify(value)[0];\n                                                // check if object could even be referenced, otherwise we are not interested in it for this warning\n                                                if (id) {\n                                                    someNonReference = value;\n                                                }\n                                            }\n                                        }\n                                        if (seenReference && someNonReference !== undefined) {\n                                            globalThis.__DEV__ !== false && invariant.warn(3, someNonReference);\n                                            break;\n                                        }\n                                    }\n                                }\n                            }\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    // If called with only one argument, removes the entire entity\n    // identified by dataId. If called with a fieldName as well, removes all\n    // fields of that entity whose names match fieldName according to the\n    // fieldNameFromStoreName helper function. If called with a fieldName\n    // and variables, removes all fields of that entity whose names match fieldName\n    // and whose arguments when cached exactly match the variables passed.\n    EntityStore.prototype.delete = function (dataId, fieldName, args) {\n        var _a;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var typename = this.getFieldValue(storeObject, \"__typename\");\n            var storeFieldName = fieldName && args ?\n                this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })\n                : fieldName;\n            return this.modify(dataId, storeFieldName ? (_a = {},\n                _a[storeFieldName] = delModifier,\n                _a) : delModifier);\n        }\n        return false;\n    };\n    EntityStore.prototype.evict = function (options, limit) {\n        var evicted = false;\n        if (options.id) {\n            if (hasOwn.call(this.data, options.id)) {\n                evicted = this.delete(options.id, options.fieldName, options.args);\n            }\n            if (this instanceof Layer && this !== limit) {\n                evicted = this.parent.evict(options, limit) || evicted;\n            }\n            // Always invalidate the field to trigger rereading of watched\n            // queries, even if no cache data was modified by the eviction,\n            // because queries may depend on computed fields with custom read\n            // functions, whose values are not stored in the EntityStore.\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    // Return a Set<string> of all the ID strings that have been retained by\n    // this layer/root *and* any layers/roots beneath it.\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            // Official singleton IDs like ROOT_QUERY and ROOT_MUTATION are\n            // always considered roots for garbage collection, regardless of\n            // their retainment counts in this.rootIds.\n            Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);\n        }\n        return ids;\n    };\n    // The goal of garbage collection is to remove IDs from the Root layer of the\n    // store that are no longer reachable starting from any IDs that have been\n    // explicitly retained (see retain and release, above). Returns an array of\n    // dataId strings that were removed from the store.\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                // Because we are iterating over an ECMAScript Set, the IDs we add here\n                // will be visited in later iterations of the forEach loop only if they\n                // were not previously contained by the Set.\n                Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);\n                // By removing IDs from the snapshot object here, we protect them from\n                // getting removed from the root store layer below.\n                delete snapshot[id];\n            }\n        });\n        var idsToRemove = Object.keys(snapshot);\n        if (idsToRemove.length) {\n            var root_1 = this;\n            while (root_1 instanceof Layer)\n                root_1 = root_1.parent;\n            idsToRemove.forEach(function (id) { return root_1.delete(id); });\n        }\n        return idsToRemove;\n    };\n    EntityStore.prototype.findChildRefIds = function (dataId) {\n        if (!hasOwn.call(this.refs, dataId)) {\n            var found_1 = (this.refs[dataId] = Object.create(null));\n            var root = this.data[dataId];\n            if (!root)\n                return found_1;\n            var workSet_1 = new Set([root]);\n            // Within the store, only arrays and objects can contain child entity\n            // references, so we can prune the traversal using this predicate:\n            workSet_1.forEach(function (obj) {\n                if (isReference(obj)) {\n                    found_1[obj.__ref] = true;\n                    // In rare cases, a { __ref } Reference object may have other fields.\n                    // This often indicates a mismerging of References with StoreObjects,\n                    // but garbage collection should not be fooled by a stray __ref\n                    // property in a StoreObject (ignoring all the other fields just\n                    // because the StoreObject looks like a Reference). To avoid this\n                    // premature termination of findChildRefIds recursion, we fall through\n                    // to the code below, which will handle any other properties of obj.\n                }\n                if (isNonNullObject(obj)) {\n                    Object.keys(obj).forEach(function (key) {\n                        var child = obj[key];\n                        // No need to add primitive values to the workSet, since they cannot\n                        // contain reference objects.\n                        if (isNonNullObject(child)) {\n                            workSet_1.add(child);\n                        }\n                    });\n                }\n            });\n        }\n        return this.refs[dataId];\n    };\n    EntityStore.prototype.makeCacheKey = function () {\n        return this.group.keyMaker.lookupArray(arguments);\n    };\n    return EntityStore;\n}());\nexport { EntityStore };\n// A single CacheGroup represents a set of one or more EntityStore objects,\n// typically the Root store in a CacheGroup by itself, and all active Layer\n// stores in a group together. A single EntityStore object belongs to only\n// one CacheGroup, store.group. The CacheGroup is responsible for tracking\n// dependencies, so store.group is helpful for generating unique keys for\n// cached results that need to be invalidated when/if those dependencies\n// change. If we used the EntityStore objects themselves as cache keys (that\n// is, store rather than store.group), the cache would become unnecessarily\n// fragmented by all the different Layer objects. Instead, the CacheGroup\n// approach allows all optimistic Layer objects in the same linked list to\n// belong to one CacheGroup, with the non-optimistic Root object belonging\n// to another CacheGroup, allowing resultCaching dependencies to be tracked\n// separately for optimistic and non-optimistic entity data.\nvar CacheGroup = /** @class */ (function () {\n    function CacheGroup(caching, parent) {\n        if (parent === void 0) { parent = null; }\n        this.caching = caching;\n        this.parent = parent;\n        this.d = null;\n        this.resetCaching();\n    }\n    CacheGroup.prototype.resetCaching = function () {\n        this.d = this.caching ? dep() : null;\n        this.keyMaker = new Trie(canUseWeakMap);\n    };\n    CacheGroup.prototype.depend = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d(makeDepKey(dataId, storeFieldName));\n            var fieldName = fieldNameFromStoreName(storeFieldName);\n            if (fieldName !== storeFieldName) {\n                // Fields with arguments that contribute extra identifying\n                // information to the fieldName (thus forming the storeFieldName)\n                // depend not only on the full storeFieldName but also on the\n                // short fieldName, so the field can be invalidated using either\n                // level of specificity.\n                this.d(makeDepKey(dataId, fieldName));\n            }\n            if (this.parent) {\n                this.parent.depend(dataId, storeFieldName);\n            }\n        }\n    };\n    CacheGroup.prototype.dirty = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d.dirty(makeDepKey(dataId, storeFieldName), \n            // When storeFieldName === \"__exists\", that means the entity identified\n            // by dataId has either disappeared from the cache or was newly added,\n            // so the result caching system would do well to \"forget everything it\n            // knows\" about that object. To achieve that kind of invalidation, we\n            // not only dirty the associated result cache entry, but also remove it\n            // completely from the dependency graph. For the optimism implementation\n            // details, see https://github.com/benjamn/optimism/pull/195.\n            storeFieldName === \"__exists\" ? \"forget\" : \"setDirty\");\n        }\n    };\n    return CacheGroup;\n}());\nfunction makeDepKey(dataId, storeFieldName) {\n    // Since field names cannot have '#' characters in them, this method\n    // of joining the field name and the ID should be unambiguous, and much\n    // cheaper than JSON.stringify([dataId, fieldName]).\n    return storeFieldName + \"#\" + dataId;\n}\nexport function maybeDependOnExistenceOfEntity(store, entityId) {\n    if (supportsResultCaching(store)) {\n        // We use this pseudo-field __exists elsewhere in the EntityStore code to\n        // represent changes in the existence of the entity object identified by\n        // entityId. This dependency gets reliably dirtied whenever an object with\n        // this ID is deleted (or newly created) within this group, so any result\n        // cache entries (for example, StoreReader#executeSelectionSet results) that\n        // depend on __exists for this entityId will get dirtied as well, leading to\n        // the eventual recomputation (instead of reuse) of those result objects the\n        // next time someone reads them from the cache.\n        store.group.depend(entityId, \"__exists\");\n    }\n}\n(function (EntityStore) {\n    // Refer to this class as EntityStore.Root outside this namespace.\n    var Root = /** @class */ (function (_super) {\n        __extends(Root, _super);\n        function Root(_a) {\n            var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;\n            var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;\n            _this.stump = new Stump(_this);\n            _this.storageTrie = new Trie(canUseWeakMap);\n            if (seed)\n                _this.replace(seed);\n            return _this;\n        }\n        Root.prototype.addLayer = function (layerId, replay) {\n            // Adding an optimistic Layer on top of the Root actually adds the Layer\n            // on top of the Stump, so the Stump always comes between the Root and\n            // any Layer objects that we've added.\n            return this.stump.addLayer(layerId, replay);\n        };\n        Root.prototype.removeLayer = function () {\n            // Never remove the root layer.\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 = {}));\n// Not exported, since all Layer instances are created by the addLayer method\n// of the EntityStore.Root class.\nvar Layer = /** @class */ (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        // Remove all instances of the given id, not just the first one.\n        var parent = this.parent.removeLayer(layerId);\n        if (layerId === this.id) {\n            if (this.group.caching) {\n                // Dirty every ID we're removing. Technically we might be able to avoid\n                // dirtying fields that have values in higher layers, but we don't have\n                // easy access to higher layers here, and we're about to recreate those\n                // layers anyway (see parent.addLayer below).\n                Object.keys(this.data).forEach(function (dataId) {\n                    var ownStoreObject = _this.data[dataId];\n                    var parentStoreObject = parent[\"lookup\"](dataId);\n                    if (!parentStoreObject) {\n                        // The StoreObject identified by dataId was defined in this layer\n                        // but will be undefined in the parent layer, so we can delete the\n                        // whole entity using this.delete(dataId). Since we're about to\n                        // throw this layer away, the only goal of this deletion is to dirty\n                        // the removed fields.\n                        _this.delete(dataId);\n                    }\n                    else if (!ownStoreObject) {\n                        // This layer had an entry for dataId but it was undefined, which\n                        // means the entity was deleted in this layer, and it's about to\n                        // become undeleted when we remove this layer, so we need to dirty\n                        // all fields that are about to be reexposed.\n                        _this.group.dirty(dataId, \"__exists\");\n                        Object.keys(parentStoreObject).forEach(function (storeFieldName) {\n                            _this.group.dirty(dataId, storeFieldName);\n                        });\n                    }\n                    else if (ownStoreObject !== parentStoreObject) {\n                        // If ownStoreObject is not exactly the same as parentStoreObject,\n                        // dirty any fields whose values will change as a result of this\n                        // removal.\n                        Object.keys(ownStoreObject).forEach(function (storeFieldName) {\n                            if (!equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {\n                                _this.group.dirty(dataId, storeFieldName);\n                            }\n                        });\n                    }\n                });\n            }\n            return parent;\n        }\n        // No changes are necessary if the parent chain remains identical.\n        if (parent === this.parent)\n            return this;\n        // Recreate this layer on top of the new parent.\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, \n        // @ts-expect-error\n        arguments);\n    };\n    return Layer;\n}(EntityStore));\n// Represents a Layer permanently installed just above the Root, which allows\n// reading optimistically (and registering optimistic dependencies) even when\n// no optimistic layers are currently active. The stump.group CacheGroup object\n// is shared by any/all Layer objects added on top of the Stump.\nvar Stump = /** @class */ (function (_super) {\n    __extends(Stump, _super);\n    function Stump(root) {\n        return _super.call(this, \"EntityStore.Stump\", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;\n    }\n    Stump.prototype.removeLayer = function () {\n        // Never remove the Stump layer.\n        return this;\n    };\n    Stump.prototype.merge = function (older, newer) {\n        // We never want to write any data into the Stump, so we forward any merge\n        // calls to the Root instead. Another option here would be to throw an\n        // exception, but the toReference(object, true) function can sometimes\n        // trigger Stump writes (which used to be Root writes, before the Stump\n        // concept was introduced).\n        return this.parent.merge(older, newer);\n    };\n    return Stump;\n}(Layer));\nfunction storeObjectReconciler(existingObject, incomingObject, property) {\n    var existingValue = existingObject[property];\n    var incomingValue = incomingObject[property];\n    // Wherever there is a key collision, prefer the incoming value, unless\n    // it is deeply equal to the existing value. It's worth checking deep\n    // equality here (even though blindly returning incoming would be\n    // logically correct) because preserving the referential identity of\n    // existing data can prevent needless rereading and rerendering.\n    return equal(existingValue, incomingValue) ? existingValue : incomingValue;\n}\nexport function supportsResultCaching(store) {\n    // When result caching is disabled, store.depend will be null.\n    return !!(store instanceof EntityStore && store.group.caching);\n}\n//# sourceMappingURL=entityStore.js.map","import { __assign } from \"tslib\";\nimport { invariant, newInvariantError } from \"../../utilities/globals/index.js\";\nimport { Kind } from \"graphql\";\nimport { wrap } from \"optimism\";\nimport { isField, resultKeyNameFromField, isReference, makeReference, shouldInclude, addTypenameToDocument, getDefaultValues, getMainDefinition, getQueryDefinition, getFragmentFromSelection, maybeDeepFreeze, mergeDeepArray, DeepMerger, isNonNullObject, canUseWeakMap, compact, } from \"../../utilities/index.js\";\nimport { maybeDependOnExistenceOfEntity, supportsResultCaching, } from \"./entityStore.js\";\nimport { isArray, extractFragmentContext, getTypenameFromStoreObject, shouldCanonizeResults, } from \"./helpers.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\nimport { canonicalStringify, ObjectCanon } from \"./object-canon.js\";\nfunction execSelectionSetKeyArgs(options) {\n    return [\n        options.selectionSet,\n        options.objectOrReference,\n        options.context,\n        // We split out this property so we can pass different values\n        // independently without modifying options.context itself.\n        options.context.canonizeResults,\n    ];\n}\nvar StoreReader = /** @class */ (function () {\n    function StoreReader(config) {\n        var _this = this;\n        this.knownResults = new (canUseWeakMap ? WeakMap : Map)();\n        this.config = compact(config, {\n            addTypename: config.addTypename !== false,\n            canonizeResults: shouldCanonizeResults(config),\n        });\n        this.canon = config.canon || new ObjectCanon();\n        this.executeSelectionSet = wrap(function (options) {\n            var _a;\n            var canonizeResults = options.context.canonizeResults;\n            var peekArgs = execSelectionSetKeyArgs(options);\n            // Negate this boolean option so we can find out if we've already read\n            // this result using the other boolean value.\n            peekArgs[3] = !canonizeResults;\n            var other = (_a = _this.executeSelectionSet).peek.apply(_a, peekArgs);\n            if (other) {\n                if (canonizeResults) {\n                    return __assign(__assign({}, other), { \n                        // If we previously read this result without canonizing it, we can\n                        // reuse that result simply by canonizing it now.\n                        result: _this.canon.admit(other.result) });\n                }\n                // If we previously read this result with canonization enabled, we can\n                // return that canonized result as-is.\n                return other;\n            }\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            // Finally, if we didn't find any useful previous results, run the real\n            // execSelectionSetImpl method with the given options.\n            return _this.execSelectionSetImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize,\n            keyArgs: execSelectionSetKeyArgs,\n            // Note that the parameters of makeCacheKey are determined by the\n            // array returned by keyArgs.\n            makeCacheKey: function (selectionSet, parent, context, canonizeResults) {\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(selectionSet, isReference(parent) ? parent.__ref : parent, context.varString, canonizeResults);\n                }\n            },\n        });\n        this.executeSubSelectedArray = wrap(function (options) {\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            return _this.execSubSelectedArrayImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize,\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, context = _a.context;\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(field, array, context.varString);\n                }\n            },\n        });\n    }\n    StoreReader.prototype.resetCanon = function () {\n        this.canon = new ObjectCanon();\n    };\n    /**\n     * Given a store and a query, return as much of the result as possible and\n     * identify if any data was missing from the store.\n     */\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, _b = _a.rootId, rootId = _b === void 0 ? \"ROOT_QUERY\" : _b, variables = _a.variables, _c = _a.returnPartialData, returnPartialData = _c === void 0 ? true : _c, _d = _a.canonizeResults, canonizeResults = _d === void 0 ? this.config.canonizeResults : _d;\n        var policies = this.config.cache.policies;\n        variables = __assign(__assign({}, getDefaultValues(getQueryDefinition(query))), variables);\n        var rootRef = makeReference(rootId);\n        var execResult = this.executeSelectionSet({\n            selectionSet: getMainDefinition(query).selectionSet,\n            objectOrReference: rootRef,\n            enclosingRef: rootRef,\n            context: __assign({ store: store, query: query, policies: policies, variables: variables, varString: canonicalStringify(variables), canonizeResults: canonizeResults }, extractFragmentContext(query, this.config.fragments)),\n        });\n        var missing;\n        if (execResult.missing) {\n            // For backwards compatibility we still report an array of\n            // MissingFieldError objects, even though there will only ever be at most\n            // one of them, now that all missing field error messages are grouped\n            // together in the execResult.missing tree.\n            missing = [\n                new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables),\n            ];\n            if (!returnPartialData) {\n                throw missing[0];\n            }\n        }\n        return {\n            result: execResult.result,\n            complete: !missing,\n            missing: missing,\n        };\n    };\n    StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {\n        if (supportsResultCaching(context.store) &&\n            this.knownResults.get(result) === selectionSet) {\n            var latest = this.executeSelectionSet.peek(selectionSet, parent, context, \n            // If result is canonical, then it could only have been previously\n            // cached by the canonizing version of executeSelectionSet, so we can\n            // avoid checking both possibilities here.\n            this.canon.isKnown(result));\n            if (latest && result === latest.result) {\n                return true;\n            }\n        }\n        return false;\n    };\n    // Uncached version of executeSelectionSet.\n    StoreReader.prototype.execSelectionSetImpl = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, objectOrReference = _a.objectOrReference, enclosingRef = _a.enclosingRef, context = _a.context;\n        if (isReference(objectOrReference) &&\n            !context.policies.rootTypenamesById[objectOrReference.__ref] &&\n            !context.store.has(objectOrReference.__ref)) {\n            return {\n                result: this.canon.empty,\n                missing: \"Dangling reference to missing \".concat(objectOrReference.__ref, \" object\"),\n            };\n        }\n        var variables = context.variables, policies = context.policies, store = context.store;\n        var typename = store.getFieldValue(objectOrReference, \"__typename\");\n        var objectsToMerge = [];\n        var missing;\n        var missingMerger = new DeepMerger();\n        if (this.config.addTypename &&\n            typeof typename === \"string\" &&\n            !policies.rootIdsByTypename[typename]) {\n            // Ensure we always include a default value for the __typename\n            // field, if we have one, and this.config.addTypename is true. Note\n            // that this field can be overridden by other merged objects.\n            objectsToMerge.push({ __typename: typename });\n        }\n        function handleMissing(result, resultName) {\n            var _a;\n            if (result.missing) {\n                missing = missingMerger.merge(missing, (_a = {},\n                    _a[resultName] = result.missing,\n                    _a));\n            }\n            return result.result;\n        }\n        var workSet = new Set(selectionSet.selections);\n        workSet.forEach(function (selection) {\n            var _a, _b;\n            // Omit fields with directives @skip(if: <truthy value>) or\n            // @include(if: <falsy value>).\n            if (!shouldInclude(selection, variables))\n                return;\n            if (isField(selection)) {\n                var fieldValue = policies.readField({\n                    fieldName: selection.name.value,\n                    field: selection,\n                    variables: context.variables,\n                    from: objectOrReference,\n                }, context);\n                var resultName = resultKeyNameFromField(selection);\n                if (fieldValue === void 0) {\n                    if (!addTypenameToDocument.added(selection)) {\n                        missing = missingMerger.merge(missing, (_a = {},\n                            _a[resultName] = \"Can't find field '\".concat(selection.name.value, \"' on \").concat(isReference(objectOrReference) ?\n                                objectOrReference.__ref + \" object\"\n                                : \"object \" + JSON.stringify(objectOrReference, null, 2)),\n                            _a));\n                    }\n                }\n                else if (isArray(fieldValue)) {\n                    fieldValue = handleMissing(_this.executeSubSelectedArray({\n                        field: selection,\n                        array: fieldValue,\n                        enclosingRef: enclosingRef,\n                        context: context,\n                    }), resultName);\n                }\n                else if (!selection.selectionSet) {\n                    // If the field does not have a selection set, then we handle it\n                    // as a scalar value. To keep this.canon from canonicalizing\n                    // this value, we use this.canon.pass to wrap fieldValue in a\n                    // Pass object that this.canon.admit will later unwrap as-is.\n                    if (context.canonizeResults) {\n                        fieldValue = _this.canon.pass(fieldValue);\n                    }\n                }\n                else if (fieldValue != null) {\n                    // In this case, because we know the field has a selection set,\n                    // it must be trying to query a GraphQLObjectType, which is why\n                    // fieldValue must be != null.\n                    fieldValue = handleMissing(_this.executeSelectionSet({\n                        selectionSet: selection.selectionSet,\n                        objectOrReference: fieldValue,\n                        enclosingRef: isReference(fieldValue) ? fieldValue : enclosingRef,\n                        context: context,\n                    }), resultName);\n                }\n                if (fieldValue !== void 0) {\n                    objectsToMerge.push((_b = {}, _b[resultName] = fieldValue, _b));\n                }\n            }\n            else {\n                var fragment = getFragmentFromSelection(selection, context.lookupFragment);\n                if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {\n                    throw newInvariantError(9, selection.name.value);\n                }\n                if (fragment && policies.fragmentMatches(fragment, typename)) {\n                    fragment.selectionSet.selections.forEach(workSet.add, workSet);\n                }\n            }\n        });\n        var result = mergeDeepArray(objectsToMerge);\n        var finalResult = { result: result, missing: missing };\n        var frozen = context.canonizeResults ?\n            this.canon.admit(finalResult)\n            // Since this.canon is normally responsible for freezing results (only in\n            // development), freeze them manually if canonization is disabled.\n            : maybeDeepFreeze(finalResult);\n        // Store this result with its selection set so that we can quickly\n        // recognize it again in the StoreReader#isFresh method.\n        if (frozen.result) {\n            this.knownResults.set(frozen.result, selectionSet);\n        }\n        return frozen;\n    };\n    // Uncached version of executeSubSelectedArray.\n    StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;\n        var missing;\n        var missingMerger = new DeepMerger();\n        function handleMissing(childResult, i) {\n            var _a;\n            if (childResult.missing) {\n                missing = missingMerger.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));\n            }\n            return childResult.result;\n        }\n        if (field.selectionSet) {\n            array = array.filter(context.store.canRead);\n        }\n        array = array.map(function (item, i) {\n            // null value in array\n            if (item === null) {\n                return null;\n            }\n            // This is a nested array, recurse\n            if (isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    enclosingRef: enclosingRef,\n                    context: context,\n                }), i);\n            }\n            // This is an object, run the selection set on it\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    objectOrReference: item,\n                    enclosingRef: isReference(item) ? item : enclosingRef,\n                    context: context,\n                }), i);\n            }\n            if (globalThis.__DEV__ !== false) {\n                assertSelectionSetForIdValue(context.store, field, item);\n            }\n            return item;\n        });\n        return {\n            result: context.canonizeResults ? this.canon.admit(array) : array,\n            missing: missing,\n        };\n    };\n    return StoreReader;\n}());\nexport { StoreReader };\nfunction firstMissing(tree) {\n    try {\n        JSON.stringify(tree, function (_, value) {\n            if (typeof value === \"string\")\n                throw value;\n            return value;\n        });\n    }\n    catch (result) {\n        return result;\n    }\n}\nfunction assertSelectionSetForIdValue(store, field, fieldValue) {\n    if (!field.selectionSet) {\n        var workSet_1 = new Set([fieldValue]);\n        workSet_1.forEach(function (value) {\n            if (isNonNullObject(value)) {\n                invariant(\n                    !isReference(value),\n                    10,\n                    getTypenameFromStoreObject(store, value),\n                    field.name.value\n                );\n                Object.values(value).forEach(workSet_1.add, workSet_1);\n            }\n        });\n    }\n}\n//# sourceMappingURL=readFromStore.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport { argumentsObjectFromField, DeepMerger, isNonEmptyArray, isNonNullObject, } from \"../../utilities/index.js\";\nimport { hasOwn, isArray } from \"./helpers.js\";\n// Mapping from JSON-encoded KeySpecifier strings to associated information.\nvar specifierInfoCache = Object.create(null);\nfunction lookupSpecifierInfo(spec) {\n    // It's safe to encode KeySpecifier arrays with JSON.stringify, since they're\n    // just arrays of strings or nested KeySpecifier arrays, and the order of the\n    // array elements is important (and suitably preserved by JSON.stringify).\n    var cacheKey = JSON.stringify(spec);\n    return (specifierInfoCache[cacheKey] ||\n        (specifierInfoCache[cacheKey] = Object.create(null)));\n}\nexport function keyFieldsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return (info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {\n            var extract = function (from, key) {\n                return context.readField(key, from);\n            };\n            var keyObject = (context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {\n                var extracted = extractKeyPath(context.storeObject, schemaKeyPath, \n                // Using context.readField to extract paths from context.storeObject\n                // allows the extraction to see through Reference objects and respect\n                // custom read functions.\n                extract);\n                if (extracted === void 0 &&\n                    object !== context.storeObject &&\n                    hasOwn.call(object, schemaKeyPath[0])) {\n                    // If context.storeObject fails to provide a value for the requested\n                    // path, fall back to the raw result object, if it has a top-level key\n                    // matching the first key in the path (schemaKeyPath[0]). This allows\n                    // key fields included in the written data to be saved in the cache\n                    // even if they are not selected explicitly in context.selectionSet.\n                    // Not being mentioned by context.selectionSet is convenient here,\n                    // since it means these extra fields cannot be affected by field\n                    // aliasing, which is why we can use extractKey instead of\n                    // context.readField for this extraction.\n                    extracted = extractKeyPath(object, schemaKeyPath, extractKey);\n                }\n                invariant(extracted !== void 0, 4, schemaKeyPath.join(\".\"), object);\n                return extracted;\n            }));\n            return \"\".concat(context.typename, \":\").concat(JSON.stringify(keyObject));\n        }));\n}\n// The keyArgs extraction process is roughly analogous to keyFields extraction,\n// but there are no aliases involved, missing fields are tolerated (by merely\n// omitting them from the key), and drawing from field.directives or variables\n// is allowed (in addition to drawing from the field's arguments object).\n// Concretely, these differences mean passing a different key path extractor\n// function to collectSpecifierPaths, reusing the shared extractKeyPath helper\n// wherever possible.\nexport function keyArgsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return (info.keyArgsFn ||\n        (info.keyArgsFn = function (args, _a) {\n            var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;\n            var collected = collectSpecifierPaths(specifier, function (keyPath) {\n                var firstKey = keyPath[0];\n                var firstChar = firstKey.charAt(0);\n                if (firstChar === \"@\") {\n                    if (field && isNonEmptyArray(field.directives)) {\n                        var directiveName_1 = firstKey.slice(1);\n                        // If the directive appears multiple times, only the first\n                        // occurrence's arguments will be used. TODO Allow repetition?\n                        // TODO Cache this work somehow, a la aliasMap?\n                        var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });\n                        // Fortunately argumentsObjectFromField works for DirectiveNode!\n                        var directiveArgs = d && argumentsObjectFromField(d, variables);\n                        // For directives without arguments (d defined, but directiveArgs ===\n                        // null), the presence or absence of the directive still counts as\n                        // part of the field key, so we return null in those cases. If no\n                        // directive with this name was found for this field (d undefined and\n                        // thus directiveArgs undefined), we return undefined, which causes\n                        // this value to be omitted from the key object returned by\n                        // collectSpecifierPaths.\n                        return (directiveArgs &&\n                            extractKeyPath(directiveArgs, \n                            // If keyPath.length === 1, this code calls extractKeyPath with an\n                            // empty path, which works because it uses directiveArgs as the\n                            // extracted value.\n                            keyPath.slice(1)));\n                    }\n                    // If the key started with @ but there was no corresponding directive,\n                    // we want to omit this value from the key object, not fall through to\n                    // treating @whatever as a normal argument name.\n                    return;\n                }\n                if (firstChar === \"$\") {\n                    var variableName = firstKey.slice(1);\n                    if (variables && hasOwn.call(variables, variableName)) {\n                        var varKeyPath = keyPath.slice(0);\n                        varKeyPath[0] = variableName;\n                        return extractKeyPath(variables, varKeyPath);\n                    }\n                    // If the key started with $ but there was no corresponding variable, we\n                    // want to omit this value from the key object, not fall through to\n                    // treating $whatever as a normal argument name.\n                    return;\n                }\n                if (args) {\n                    return extractKeyPath(args, keyPath);\n                }\n            });\n            var suffix = JSON.stringify(collected);\n            // If no arguments were passed to this field, and it didn't have any other\n            // field key contributions from directives or variables, hide the empty\n            // :{} suffix from the field key. However, a field passed no arguments can\n            // still end up with a non-empty :{...} suffix if its key configuration\n            // refers to directives or variables.\n            if (args || suffix !== \"{}\") {\n                fieldName += \":\" + suffix;\n            }\n            return fieldName;\n        }));\n}\nexport function collectSpecifierPaths(specifier, extractor) {\n    // For each path specified by specifier, invoke the extractor, and repeatedly\n    // merge the results together, with appropriate ancestor context.\n    var merger = new DeepMerger();\n    return getSpecifierPaths(specifier).reduce(function (collected, path) {\n        var _a;\n        var toMerge = extractor(path);\n        if (toMerge !== void 0) {\n            // This path is not expected to contain array indexes, so the toMerge\n            // reconstruction will not contain arrays. TODO Fix this?\n            for (var i = path.length - 1; i >= 0; --i) {\n                toMerge = (_a = {}, _a[path[i]] = toMerge, _a);\n            }\n            collected = merger.merge(collected, toMerge);\n        }\n        return collected;\n    }, Object.create(null));\n}\nexport function getSpecifierPaths(spec) {\n    var info = lookupSpecifierInfo(spec);\n    if (!info.paths) {\n        var paths_1 = (info.paths = []);\n        var currentPath_1 = [];\n        spec.forEach(function (s, i) {\n            if (isArray(s)) {\n                getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });\n                currentPath_1.length = 0;\n            }\n            else {\n                currentPath_1.push(s);\n                if (!isArray(spec[i + 1])) {\n                    paths_1.push(currentPath_1.slice(0));\n                    currentPath_1.length = 0;\n                }\n            }\n        });\n    }\n    return info.paths;\n}\nfunction extractKey(object, key) {\n    return object[key];\n}\nexport function extractKeyPath(object, path, extract) {\n    // For each key in path, extract the corresponding child property from obj,\n    // flattening arrays if encountered (uncommon for keyFields and keyArgs, but\n    // possible). The final result of path.reduce is normalized so unexpected leaf\n    // objects have their keys safely sorted. That final result is difficult to\n    // type as anything other than any. You're welcome to try to improve the\n    // return type, but keep in mind extractKeyPath is not a public function\n    // (exported only for testing), so the effort may not be worthwhile unless the\n    // limited set of actual callers (see above) pass arguments that TypeScript\n    // can statically type. If we know only that path is some array of strings\n    // (and not, say, a specific tuple of statically known strings), any (or\n    // possibly unknown) is the honest answer.\n    extract = extract || extractKey;\n    return normalize(path.reduce(function reducer(obj, key) {\n        return isArray(obj) ?\n            obj.map(function (child) { return reducer(child, key); })\n            : obj && extract(obj, key);\n    }, object));\n}\nfunction normalize(value) {\n    // Usually the extracted value will be a scalar value, since most primary\n    // key fields are scalar, but just in case we get an object or an array, we\n    // need to do some normalization of the order of (nested) keys.\n    if (isNonNullObject(value)) {\n        if (isArray(value)) {\n            return value.map(normalize);\n        }\n        return collectSpecifierPaths(Object.keys(value).sort(), function (path) {\n            return extractKeyPath(value, path);\n        });\n    }\n    return value;\n}\n//# sourceMappingURL=key-extractor.js.map","import { __assign, __rest } from \"tslib\";\nimport { invariant, newInvariantError } from \"../../utilities/globals/index.js\";\nimport { storeKeyNameFromField, argumentsObjectFromField, isReference, getStoreKeyName, isNonNullObject, stringifyForDisplay, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName, storeValueIsStoreObject, selectionSetMatchesResult, TypeOrFieldNameRegExp, defaultDataIdFromObject, isArray, } from \"./helpers.js\";\nimport { cacheSlot } from \"./reactiveVars.js\";\n// Upgrade to a faster version of the default stable JSON.stringify function\n// used by getStoreKeyName. This function is used when computing storeFieldName\n// strings (when no keyArgs has been configured for a field).\nimport { canonicalStringify } from \"./object-canon.js\";\nimport { keyArgsFnFromSpecifier, keyFieldsFnFromSpecifier, } from \"./key-extractor.js\";\ngetStoreKeyName.setStringify(canonicalStringify);\nfunction argsFromFieldSpecifier(spec) {\n    return (spec.args !== void 0 ? spec.args\n        : spec.field ? argumentsObjectFromField(spec.field, spec.variables)\n            : null);\n}\nvar nullKeyFieldsFn = function () { return void 0; };\nvar simpleKeyArgsFn = function (_args, context) { return context.fieldName; };\n// These merge functions can be selected by specifying merge:true or\n// merge:false in a field policy.\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 = /** @class */ (function () {\n    function Policies(config) {\n        this.config = config;\n        this.typePolicies = Object.create(null);\n        this.toBeAdded = Object.create(null);\n        // Map from subtype names to sets of supertype names. Note that this\n        // representation inverts the structure of possibleTypes (whose keys are\n        // supertypes and whose values are arrays of subtypes) because it tends\n        // to be much more efficient to search upwards than downwards.\n        this.supertypeMap = new Map();\n        // Any fuzzy subtypes specified by possibleTypes will be converted to\n        // RegExp objects and recorded here. Every key of this map can also be\n        // found in supertypeMap. In many cases this Map will be empty, which\n        // means no fuzzy subtype checking will happen in fragmentMatches.\n        this.fuzzySubtypes = new Map();\n        this.rootIdsByTypename = Object.create(null);\n        this.rootTypenamesById = Object.create(null);\n        this.usingPossibleTypes = false;\n        this.config = __assign({ dataIdFromObject: defaultDataIdFromObject }, config);\n        this.cache = this.config.cache;\n        this.setRootTypename(\"Query\");\n        this.setRootTypename(\"Mutation\");\n        this.setRootTypename(\"Subscription\");\n        if (config.possibleTypes) {\n            this.addPossibleTypes(config.possibleTypes);\n        }\n        if (config.typePolicies) {\n            this.addTypePolicies(config.typePolicies);\n        }\n    }\n    Policies.prototype.identify = function (object, partialContext) {\n        var _a;\n        var policies = this;\n        var typename = (partialContext &&\n            (partialContext.typename || ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename))) ||\n            object.__typename;\n        // It should be possible to write root Query fields with writeFragment,\n        // using { __typename: \"Query\", ... } as the data, but it does not make\n        // sense to allow the same identification behavior for the Mutation and\n        // Subscription types, since application code should never be writing\n        // directly to (or reading directly from) those root objects.\n        if (typename === this.rootTypenamesById.ROOT_QUERY) {\n            return [\"ROOT_QUERY\"];\n        }\n        // Default context.storeObject to object if not otherwise provided.\n        var storeObject = (partialContext && partialContext.storeObject) || object;\n        var context = __assign(__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: (partialContext && partialContext.readField) ||\n                function () {\n                    var options = normalizeReadFieldOptions(arguments, storeObject);\n                    return policies.readField(options, {\n                        store: policies.cache[\"data\"],\n                        variables: options.variables,\n                    });\n                } });\n        var id;\n        var policy = typename && this.getTypePolicy(typename);\n        var keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;\n        while (keyFn) {\n            var specifierOrId = keyFn(__assign(__assign({}, object), storeObject), context);\n            if (isArray(specifierOrId)) {\n                keyFn = keyFieldsFnFromSpecifier(specifierOrId);\n            }\n            else {\n                id = specifierOrId;\n                break;\n            }\n        }\n        id = id ? String(id) : void 0;\n        return context.keyObject ? [id, context.keyObject] : [id];\n    };\n    Policies.prototype.addTypePolicies = function (typePolicies) {\n        var _this = this;\n        Object.keys(typePolicies).forEach(function (typename) {\n            var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = __rest(_a, [\"queryType\", \"mutationType\", \"subscriptionType\"]);\n            // Though {query,mutation,subscription}Type configurations are rare,\n            // it's important to call setRootTypename as early as possible,\n            // since these configurations should apply consistently for the\n            // entire lifetime of the cache. Also, since only one __typename can\n            // qualify as one of these root types, these three properties cannot\n            // be inherited, unlike the rest of the incoming properties. That\n            // restriction is convenient, because the purpose of this.toBeAdded\n            // is to delay the processing of type/field policies until the first\n            // time they're used, allowing policies to be added in any order as\n            // long as all relevant policies (including policies for supertypes)\n            // have been added by the time a given policy is used for the first\n            // time. In other words, since inheritance doesn't matter for these\n            // properties, there's also no need to delay their processing using\n            // the this.toBeAdded queue.\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                    // Pass merge:true as a shorthand for a merge implementation\n                    // that returns options.mergeObjects(existing, incoming).\n                    : merge === true ? mergeTrueFn\n                        // Pass merge:false to make incoming always replace existing\n                        // without any warnings about data clobbering.\n                        : merge === false ? mergeFalseFn\n                            : existing.merge;\n        }\n        // Type policies can define merge functions, as an alternative to\n        // using field policies to merge child objects.\n        setMerge(existing, incoming.merge);\n        existing.keyFn =\n            // Pass false to disable normalization for this typename.\n            keyFields === false ? nullKeyFieldsFn\n                // Pass an array of strings to use those fields to compute a\n                // composite ID for objects of this typename.\n                : isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields)\n                    // Pass a function to take full control over identification.\n                    : typeof keyFields === \"function\" ? keyFields\n                        // Leave existing.keyFn unchanged if above cases fail.\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                        // Pass false to disable argument-based differentiation of\n                        // field identities.\n                        keyArgs === false ? simpleKeyArgsFn\n                            // Pass an array of strings to use named arguments to\n                            // compute a composite identity for the field.\n                            : isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs)\n                                // Pass a function to take full control over field identity.\n                                : typeof keyArgs === \"function\" ? keyArgs\n                                    // Leave existing.keyFn unchanged if above cases fail.\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                    // If we have both a read and a merge function, assume\n                    // keyArgs:false, because read and merge together can take\n                    // responsibility for interpreting arguments in and out. This\n                    // default assumption can always be overridden by specifying\n                    // keyArgs explicitly in the FieldPolicy.\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            invariant(!old || old === which, 5, which);\n            // First, delete any old __typename associated with this rootId from\n            // rootIdsByTypename.\n            if (old)\n                delete this.rootIdsByTypename[old];\n            // Now make this the only __typename that maps to this rootId.\n            this.rootIdsByTypename[typename] = rootId;\n            // Finally, update the __typename associated with this 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            // Make sure all types have an entry in this.supertypeMap, even if\n            // their supertype set is empty, so we can return false immediately\n            // from policies.fragmentMatches for unknown supertypes.\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                    // TODO Don't interpret just any invalid typename as a RegExp.\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            // When the TypePolicy for typename is first accessed, instead of\n            // starting with an empty policy object, inherit any properties or\n            // fields from the type policies of the supertypes of typename.\n            //\n            // Any properties or fields defined explicitly within the TypePolicy\n            // for typename will take precedence, and if there are multiple\n            // supertypes, the properties of policies whose types were added\n            // later via addPossibleTypes will take precedence over those of\n            // earlier supertypes. TODO Perhaps we should warn about these\n            // conflicts in development, and recommend defining the property\n            // explicitly in the subtype policy?\n            //\n            // Field policy inheritance is atomic/shallow: you can't inherit a\n            // field policy and then override just its read function, since read\n            // and merge functions often need to cooperate, so changing only one\n            // of them would be a recipe for inconsistency.\n            //\n            // Once the TypePolicy for typename has been accessed, its properties can\n            // still be updated directly using addTypePolicies, but future changes to\n            // inherited supertype policies will not be reflected in this subtype\n            // policy, because this code runs at most once per typename.\n            var supertypes_1 = this.supertypeMap.get(typename);\n            if (!supertypes_1 && this.fuzzySubtypes.size) {\n                // To make the inheritance logic work for unknown typename strings that\n                // may have fuzzy supertypes, we give this typename an empty supertype\n                // set and then populate it with any fuzzy supertypes that match.\n                supertypes_1 = this.getSupertypeSet(typename, true);\n                // This only works for typenames that are directly matched by a fuzzy\n                // supertype. What if there is an intermediate chain of supertypes?\n                // While possible, that situation can only be solved effectively by\n                // specifying the intermediate relationships via possibleTypes, manually\n                // and in a non-fuzzy way.\n                this.fuzzySubtypes.forEach(function (regExp, fuzzy) {\n                    if (regExp.test(typename)) {\n                        // The fuzzy parameter is just the original string version of regExp\n                        // (not a valid __typename string), but we can look up the\n                        // associated supertype(s) in this.supertypeMap.\n                        var fuzzySupertypes = _this.supertypeMap.get(fuzzy);\n                        if (fuzzySupertypes) {\n                            fuzzySupertypes.forEach(function (supertype) {\n                                return supertypes_1.add(supertype);\n                            });\n                        }\n                    }\n                });\n            }\n            if (supertypes_1 && supertypes_1.size) {\n                supertypes_1.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            // Merge the pending policies into this.typePolicies, in the order they\n            // were originally passed to addTypePolicy.\n            inbox.splice(0).forEach(function (policy) {\n                _this.updateTypePolicy(typename, policy);\n            });\n        }\n        return this.typePolicies[typename];\n    };\n    Policies.prototype.getFieldPolicy = function (typename, fieldName, createIfMissing) {\n        if (typename) {\n            var fieldPolicies = this.getTypePolicy(typename).fields;\n            return (fieldPolicies[fieldName] ||\n                (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 the fragment has a type condition but the object we're matching\n        // against does not have a __typename, the fragment cannot match.\n        if (!typename)\n            return false;\n        var supertype = fragment.typeCondition.name.value;\n        // Common case: fragment type condition and __typename are the same.\n        if (typename === supertype)\n            return true;\n        if (this.usingPossibleTypes && 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            // We need to check fuzzy subtypes only if we encountered fuzzy\n            // subtype strings in addPossibleTypes, and only while writing to\n            // the cache, since that's when selectionSetMatchesResult gives a\n            // strong signal of fragment matching. The StoreReader class calls\n            // policies.fragmentMatches without passing a result object, so\n            // needToCheckFuzzySubtypes is always false while reading.\n            var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);\n            var checkingFuzzySubtypes = false;\n            // It's important to keep evaluating workQueue.length each time through\n            // the loop, because the queue can grow while we're iterating over it.\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                            globalThis.__DEV__ !== false && invariant.warn(6, typename, supertype);\n                        }\n                        // Record positive results for faster future lookup.\n                        // Unfortunately, we cannot safely cache negative results,\n                        // because new possibleTypes data could always be added to the\n                        // Policies class.\n                        typenameSupertypeSet.add(supertype);\n                    }\n                    return true;\n                }\n                supertypeSet.forEach(maybeEnqueue_1);\n                if (needToCheckFuzzySubtypes &&\n                    // Start checking fuzzy subtypes only after exhausting all\n                    // non-fuzzy subtypes (after the final iteration of the loop).\n                    i === workQueue_1.length - 1 &&\n                    // We could wait to compare fragment.selectionSet to result\n                    // after we verify the supertype, but this check is often less\n                    // expensive than that search, and we will have to do the\n                    // comparison anyway whenever we find a potential match.\n                    selectionSetMatchesResult(fragment.selectionSet, result, variables)) {\n                    // We don't always need to check fuzzy subtypes (if no result\n                    // was provided, or !this.fuzzySubtypes.size), but, when we do,\n                    // we only want to check them once.\n                    needToCheckFuzzySubtypes = false;\n                    checkingFuzzySubtypes = true;\n                    // If we find any fuzzy subtypes that match typename, extend the\n                    // workQueue to search through the supertypes of those fuzzy\n                    // subtypes. Otherwise the for-loop will terminate and we'll\n                    // return false below.\n                    this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {\n                        var match = typename.match(regExp);\n                        if (match && match[0] === typename) {\n                            maybeEnqueue_1(fuzzyString);\n                        }\n                    });\n                }\n            }\n        }\n        return false;\n    };\n    Policies.prototype.hasKeyArgs = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        return !!(policy && policy.keyFn);\n    };\n    Policies.prototype.getStoreFieldName = function (fieldSpec) {\n        var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        var storeFieldName;\n        var keyFn = policy && policy.keyFn;\n        if (keyFn && typename) {\n            var context = {\n                typename: typename,\n                fieldName: fieldName,\n                field: fieldSpec.field || null,\n                variables: fieldSpec.variables,\n            };\n            var args = argsFromFieldSpecifier(fieldSpec);\n            while (keyFn) {\n                var specifierOrString = keyFn(args, context);\n                if (isArray(specifierOrString)) {\n                    keyFn = keyArgsFnFromSpecifier(specifierOrString);\n                }\n                else {\n                    // If the custom keyFn returns a falsy value, fall back to\n                    // fieldName instead.\n                    storeFieldName = specifierOrString || fieldName;\n                    break;\n                }\n            }\n        }\n        if (storeFieldName === void 0) {\n            storeFieldName =\n                fieldSpec.field ?\n                    storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)\n                    : getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));\n        }\n        // Returning false from a keyArgs function is like configuring\n        // keyArgs: false, but more dynamic.\n        if (storeFieldName === false) {\n            return fieldName;\n        }\n        // Make sure custom field names start with the actual field.name.value\n        // of the field, so we can always figure out which properties of a\n        // StoreObject correspond to which original field names.\n        return fieldName === fieldNameFromStoreName(storeFieldName) ? 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            // Call read(existing, readOptions) with cacheSlot holding this.cache.\n            return cacheSlot.withValue(this.cache, read, [\n                existing,\n                readOptions,\n            ]);\n        }\n        return existing;\n    };\n    Policies.prototype.getReadFunction = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        return policy && policy.read;\n    };\n    Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {\n        var policy = this.getFieldPolicy(parentTypename, fieldName, false);\n        var merge = policy && policy.merge;\n        if (!merge && childTypename) {\n            policy = this.getTypePolicy(childTypename);\n            merge = policy && policy.merge;\n        }\n        return merge;\n    };\n    Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {\n        var field = _a.field, typename = _a.typename, merge = _a.merge;\n        if (merge === mergeTrueFn) {\n            // Instead of going to the trouble of creating a full\n            // FieldFunctionOptions object and calling mergeTrueFn, we can\n            // simply call mergeObjects, as mergeTrueFn would.\n            return makeMergeObjectsFunction(context.store)(existing, incoming);\n        }\n        if (merge === mergeFalseFn) {\n            // Likewise for mergeFalseFn, whose implementation is even simpler.\n            return incoming;\n        }\n        // If cache.writeQuery or cache.writeFragment was called with\n        // options.overwrite set to true, we still call merge functions, but\n        // the existing data is always undefined, so the merge function will\n        // not attempt to combine the incoming data with the existing data.\n        if (context.overwrite) {\n            existing = void 0;\n        }\n        return merge(existing, incoming, makeFieldFunctionOptions(this, \n        // Unlike options.readField for read functions, we do not fall\n        // back to the current object if no foreignObjOrRef is provided,\n        // because it's not clear what the current object should be for\n        // merge functions: the (possibly undefined) existing object, or\n        // the incoming object? If you think your merge function needs\n        // to read sibling fields in order to produce a new value for\n        // the current field, you might want to rethink your strategy,\n        // because that's a recipe for making merge behavior sensitive\n        // to the order in which fields are written into the cache.\n        // However, readField(name, ref) is useful for merge functions\n        // that need to deduplicate child objects and references.\n        void 0, {\n            typename: typename,\n            fieldName: field.name.value,\n            field: field,\n            variables: context.variables,\n        }, context, storage || Object.create(null)));\n    };\n    return Policies;\n}());\nexport { Policies };\nfunction makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {\n    var storeFieldName = policies.getStoreFieldName(fieldSpec);\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var variables = fieldSpec.variables || context.variables;\n    var _a = context.store, toReference = _a.toReference, canRead = _a.canRead;\n    return {\n        args: argsFromFieldSpecifier(fieldSpec),\n        field: fieldSpec.field || null,\n        fieldName: fieldName,\n        storeFieldName: storeFieldName,\n        variables: variables,\n        isReference: isReference,\n        toReference: toReference,\n        storage: storage,\n        cache: policies.cache,\n        canRead: canRead,\n        readField: function () {\n            return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, variables), context);\n        },\n        mergeObjects: makeMergeObjectsFunction(context.store),\n    };\n}\nexport function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {\n    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;\n    var options;\n    if (typeof fieldNameOrOptions === \"string\") {\n        options = {\n            fieldName: fieldNameOrOptions,\n            // Default to objectOrReference only when no second argument was\n            // passed for the from parameter, not when undefined is explicitly\n            // passed as the second argument.\n            from: argc > 1 ? from : objectOrReference,\n        };\n    }\n    else {\n        options = __assign({}, fieldNameOrOptions);\n        // Default to objectOrReference only when fieldNameOrOptions.from is\n        // actually omitted, rather than just undefined.\n        if (!hasOwn.call(options, \"from\")) {\n            options.from = objectOrReference;\n        }\n    }\n    if (globalThis.__DEV__ !== false && options.from === void 0) {\n        globalThis.__DEV__ !== false && invariant.warn(7, stringifyForDisplay(Array.from(readFieldArgs)));\n    }\n    if (void 0 === options.variables) {\n        options.variables = variables;\n    }\n    return options;\n}\nfunction makeMergeObjectsFunction(store) {\n    return function mergeObjects(existing, incoming) {\n        if (isArray(existing) || isArray(incoming)) {\n            throw newInvariantError(8);\n        }\n        // These dynamic checks are necessary because the parameters of a\n        // custom merge function can easily have the any type, so the type\n        // system cannot always enforce the StoreObject | Reference parameter\n        // types of options.mergeObjects.\n        if (isNonNullObject(existing) && isNonNullObject(incoming)) {\n            var eType = store.getFieldValue(existing, \"__typename\");\n            var iType = store.getFieldValue(incoming, \"__typename\");\n            var typesDiffer = eType && iType && eType !== iType;\n            if (typesDiffer) {\n                return incoming;\n            }\n            if (isReference(existing) && storeValueIsStoreObject(incoming)) {\n                // Update the normalized EntityStore for the entity identified by\n                // existing.__ref, preferring/overwriting any fields contributed by the\n                // newer incoming StoreObject.\n                store.merge(existing.__ref, incoming);\n                return existing;\n            }\n            if (storeValueIsStoreObject(existing) && isReference(incoming)) {\n                // Update the normalized EntityStore for the entity identified by\n                // incoming.__ref, taking fields from the older existing object only if\n                // those fields are not already present in the newer StoreObject\n                // identified by incoming.__ref.\n                store.merge(existing, incoming.__ref);\n                return incoming;\n            }\n            if (storeValueIsStoreObject(existing) &&\n                storeValueIsStoreObject(incoming)) {\n                return __assign(__assign({}, existing), incoming);\n            }\n        }\n        return incoming;\n    };\n}\n//# sourceMappingURL=policies.js.map","import { __assign } from \"tslib\";\nimport { invariant, newInvariantError } from \"../../utilities/globals/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { Trie } from \"@wry/trie\";\nimport { Kind } from \"graphql\";\nimport { getFragmentFromSelection, getDefaultValues, getOperationDefinition, getTypenameFromResult, makeReference, isField, resultKeyNameFromField, isReference, shouldInclude, cloneDeep, addTypenameToDocument, isNonEmptyArray, argumentsObjectFromField, } from \"../../utilities/index.js\";\nimport { isArray, makeProcessedFieldsMerger, fieldNameFromStoreName, storeValueIsStoreObject, extractFragmentContext, } from \"./helpers.js\";\nimport { canonicalStringify } from \"./object-canon.js\";\nimport { normalizeReadFieldOptions } from \"./policies.js\";\n// Since there are only four possible combinations of context.clientOnly and\n// context.deferred values, we should need at most four \"flavors\" of any given\n// WriteContext. To avoid creating multiple copies of the same context, we cache\n// the contexts in the context.flavors Map (shared by all flavors) according to\n// their clientOnly and deferred values (always in that order).\nfunction getContextFlavor(context, clientOnly, deferred) {\n    var key = \"\".concat(clientOnly).concat(deferred);\n    var flavored = context.flavors.get(key);\n    if (!flavored) {\n        context.flavors.set(key, (flavored =\n            context.clientOnly === clientOnly && context.deferred === deferred ?\n                context\n                : __assign(__assign({}, context), { clientOnly: clientOnly, deferred: deferred })));\n    }\n    return flavored;\n}\nvar StoreWriter = /** @class */ (function () {\n    function StoreWriter(cache, reader, fragments) {\n        this.cache = cache;\n        this.reader = reader;\n        this.fragments = fragments;\n    }\n    StoreWriter.prototype.writeToStore = function (store, _a) {\n        var _this = this;\n        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;\n        var operationDefinition = getOperationDefinition(query);\n        var merger = makeProcessedFieldsMerger();\n        variables = __assign(__assign({}, getDefaultValues(operationDefinition)), variables);\n        var context = __assign(__assign({ store: store, written: Object.create(null), merge: function (existing, incoming) {\n                return merger.merge(existing, incoming);\n            }, variables: variables, varString: canonicalStringify(variables) }, extractFragmentContext(query, this.fragments)), { overwrite: !!overwrite, incomingById: new Map(), clientOnly: false, deferred: false, flavors: new Map() });\n        var ref = this.processSelectionSet({\n            result: result || Object.create(null),\n            dataId: dataId,\n            selectionSet: operationDefinition.selectionSet,\n            mergeTree: { map: new Map() },\n            context: context,\n        });\n        if (!isReference(ref)) {\n            throw newInvariantError(11, result);\n        }\n        // So far, the store has not been modified, so now it's time to process\n        // context.incomingById and merge those incoming fields into context.store.\n        context.incomingById.forEach(function (_a, dataId) {\n            var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;\n            var entityRef = makeReference(dataId);\n            if (mergeTree && mergeTree.map.size) {\n                var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);\n                if (isReference(applied)) {\n                    // Assume References returned by applyMerges have already been merged\n                    // into the store. See makeMergeObjectsFunction in policies.ts for an\n                    // example of how this can happen.\n                    return;\n                }\n                // Otherwise, applyMerges returned a StoreObject, whose fields we should\n                // merge into the store (see store.merge statement below).\n                storeObject = applied;\n            }\n            if (globalThis.__DEV__ !== false && !context.overwrite) {\n                var fieldsWithSelectionSets_1 = Object.create(null);\n                fieldNodeSet.forEach(function (field) {\n                    if (field.selectionSet) {\n                        fieldsWithSelectionSets_1[field.name.value] = true;\n                    }\n                });\n                var hasSelectionSet_1 = function (storeFieldName) {\n                    return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] ===\n                        true;\n                };\n                var hasMergeFunction_1 = function (storeFieldName) {\n                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);\n                    return Boolean(childTree && childTree.info && childTree.info.merge);\n                };\n                Object.keys(storeObject).forEach(function (storeFieldName) {\n                    // If a merge function was defined for this field, trust that it\n                    // did the right thing about (not) clobbering data. If the field\n                    // has no selection set, it's a scalar field, so it doesn't need\n                    // a merge function (even if it's an object, like JSON data).\n                    if (hasSelectionSet_1(storeFieldName) &&\n                        !hasMergeFunction_1(storeFieldName)) {\n                        warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);\n                    }\n                });\n            }\n            store.merge(dataId, storeObject);\n        });\n        // Any IDs written explicitly to the cache will be retained as\n        // reachable root IDs for garbage collection purposes. Although this\n        // logic includes root IDs like ROOT_QUERY and ROOT_MUTATION, their\n        // retainment counts are effectively ignored because cache.gc() always\n        // includes them in its root ID set.\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, \n        // This object allows processSelectionSet to report useful information\n        // to its callers without explicitly returning that information.\n        mergeTree = _a.mergeTree;\n        var policies = this.cache.policies;\n        // This variable will be repeatedly updated using context.merge to\n        // accumulate all fields that need to be written into the store.\n        var incoming = Object.create(null);\n        // If typename was not passed in, infer it. Note that typename is\n        // always passed in for tricky-to-infer cases such as \"Query\" for\n        // ROOT_QUERY.\n        var typename = (dataId && policies.rootTypenamesById[dataId]) ||\n            getTypenameFromResult(result, selectionSet, context.fragmentMap) ||\n            (dataId && context.store.get(dataId, \"__typename\"));\n        if (\"string\" === typeof typename) {\n            incoming.__typename = typename;\n        }\n        // This readField function will be passed as context.readField in the\n        // KeyFieldsContext object created within policies.identify (called below).\n        // In addition to reading from the existing context.store (thanks to the\n        // policies.readField(options, context) line at the very bottom), this\n        // version of readField can read from Reference objects that are currently\n        // pending in context.incomingById, which is important whenever keyFields\n        // need to be extracted from a child object that processSelectionSet has\n        // turned into a Reference.\n        var readField = function () {\n            var options = normalizeReadFieldOptions(arguments, incoming, context.variables);\n            if (isReference(options.from)) {\n                var info = context.incomingById.get(options.from.__ref);\n                if (info) {\n                    var result_1 = policies.readField(__assign(__assign({}, options), { from: info.storeObject }), context);\n                    if (result_1 !== void 0) {\n                        return result_1;\n                    }\n                }\n            }\n            return policies.readField(options, context);\n        };\n        var fieldNodeSet = new Set();\n        this.flattenFields(selectionSet, result, \n        // This WriteContext will be the default context value for fields returned\n        // by the flattenFields method, but some fields may be assigned a modified\n        // context, depending on the presence of @client and other directives.\n        context, typename).forEach(function (context, field) {\n            var _a;\n            var resultFieldKey = resultKeyNameFromField(field);\n            var value = result[resultFieldKey];\n            fieldNodeSet.add(field);\n            if (value !== void 0) {\n                var storeFieldName = policies.getStoreFieldName({\n                    typename: typename,\n                    fieldName: field.name.value,\n                    field: field,\n                    variables: context.variables,\n                });\n                var childTree = getChildMergeTree(mergeTree, storeFieldName);\n                var incomingValue = _this.processFieldValue(value, field, \n                // Reset context.clientOnly and context.deferred to their default\n                // values before processing nested selection sets.\n                field.selectionSet ?\n                    getContextFlavor(context, false, false)\n                    : context, childTree);\n                // To determine if this field holds a child object with a merge function\n                // defined in its type policy (see PR #7070), we need to figure out the\n                // child object's __typename.\n                var childTypename = void 0;\n                // The field's value can be an object that has a __typename only if the\n                // field has a selection set. Otherwise incomingValue is scalar.\n                if (field.selectionSet &&\n                    (isReference(incomingValue) || storeValueIsStoreObject(incomingValue))) {\n                    childTypename = readField(\"__typename\", incomingValue);\n                }\n                var merge = policies.getMergeFunction(typename, field.name.value, childTypename);\n                if (merge) {\n                    childTree.info = {\n                        // TODO Check compatibility against any existing childTree.field?\n                        field: field,\n                        typename: typename,\n                        merge: merge,\n                    };\n                }\n                else {\n                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);\n                }\n                incoming = context.merge(incoming, (_a = {},\n                    _a[storeFieldName] = incomingValue,\n                    _a));\n            }\n            else if (globalThis.__DEV__ !== false &&\n                !context.clientOnly &&\n                !context.deferred &&\n                !addTypenameToDocument.added(field) &&\n                // If the field has a read function, it may be a synthetic field or\n                // provide a default value, so its absence from the written data should\n                // not be cause for alarm.\n                !policies.getReadFunction(typename, field.name.value)) {\n                globalThis.__DEV__ !== false && invariant.error(12, resultKeyNameFromField(field), result);\n            }\n        });\n        // Identify the result object, even if dataId was already provided,\n        // since we always need keyObject below.\n        try {\n            var _b = policies.identify(result, {\n                typename: typename,\n                selectionSet: selectionSet,\n                fragmentMap: context.fragmentMap,\n                storeObject: incoming,\n                readField: readField,\n            }), id = _b[0], keyObject = _b[1];\n            // If dataId was not provided, fall back to the id just generated by\n            // policies.identify.\n            dataId = dataId || id;\n            // Write any key fields that were used during identification, even if\n            // they were not mentioned in the original query.\n            if (keyObject) {\n                // TODO Reverse the order of the arguments?\n                incoming = context.merge(incoming, keyObject);\n            }\n        }\n        catch (e) {\n            // If dataId was provided, tolerate failure of policies.identify.\n            if (!dataId)\n                throw e;\n        }\n        if (\"string\" === typeof dataId) {\n            var dataRef = makeReference(dataId);\n            // Avoid processing the same entity object using the same selection\n            // set more than once. We use an array instead of a Set since most\n            // entity IDs will be written using only one selection set, so the\n            // size of this array is likely to be very small, meaning indexOf is\n            // likely to be faster than Set.prototype.has.\n            var sets = context.written[dataId] || (context.written[dataId] = []);\n            if (sets.indexOf(selectionSet) >= 0)\n                return dataRef;\n            sets.push(selectionSet);\n            // If we're about to write a result object into the store, but we\n            // happen to know that the exact same (===) result object would be\n            // returned if we were to reread the result with the same inputs,\n            // then we can skip the rest of the processSelectionSet work for\n            // this object, and immediately return a Reference to it.\n            if (this.reader &&\n                this.reader.isFresh(result, dataRef, selectionSet, context)) {\n                return dataRef;\n            }\n            var previous_1 = context.incomingById.get(dataId);\n            if (previous_1) {\n                previous_1.storeObject = context.merge(previous_1.storeObject, incoming);\n                previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);\n                fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });\n            }\n            else {\n                context.incomingById.set(dataId, {\n                    storeObject: incoming,\n                    // Save a reference to mergeTree only if it is not empty, because\n                    // empty MergeTrees may be recycled by maybeRecycleChildMergeTree and\n                    // reused for entirely different parts of the result tree.\n                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,\n                    fieldNodeSet: fieldNodeSet,\n                });\n            }\n            return dataRef;\n        }\n        return incoming;\n    };\n    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {\n        var _this = this;\n        if (!field.selectionSet || value === null) {\n            // In development, we need to clone scalar values so that they can be\n            // safely frozen with maybeDeepFreeze in readFromStore.ts. In production,\n            // it's cheaper to store the scalar values directly in the cache.\n            return globalThis.__DEV__ !== false ? cloneDeep(value) : value;\n        }\n        if (isArray(value)) {\n            return value.map(function (item, i) {\n                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));\n                maybeRecycleChildMergeTree(mergeTree, i);\n                return value;\n            });\n        }\n        return this.processSelectionSet({\n            result: value,\n            selectionSet: field.selectionSet,\n            context: context,\n            mergeTree: mergeTree,\n        });\n    };\n    // Implements https://spec.graphql.org/draft/#sec-Field-Collection, but with\n    // some additions for tracking @client and @defer directives.\n    StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {\n        if (typename === void 0) { typename = getTypenameFromResult(result, selectionSet, context.fragmentMap); }\n        var fieldMap = new Map();\n        var policies = this.cache.policies;\n        var limitingTrie = new Trie(false); // No need for WeakMap, since limitingTrie does not escape.\n        (function flatten(selectionSet, inheritedContext) {\n            var visitedNode = limitingTrie.lookup(selectionSet, \n            // Because we take inheritedClientOnly and inheritedDeferred into\n            // consideration here (in addition to selectionSet), it's possible for\n            // the same selection set to be flattened more than once, if it appears\n            // in the query with different @client and/or @directive configurations.\n            inheritedContext.clientOnly, inheritedContext.deferred);\n            if (visitedNode.visited)\n                return;\n            visitedNode.visited = true;\n            selectionSet.selections.forEach(function (selection) {\n                if (!shouldInclude(selection, context.variables))\n                    return;\n                var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;\n                if (\n                // Since the presence of @client or @defer on this field can only\n                // cause clientOnly or deferred to become true, we can skip the\n                // forEach loop if both clientOnly and deferred are already true.\n                !(clientOnly && deferred) &&\n                    isNonEmptyArray(selection.directives)) {\n                    selection.directives.forEach(function (dir) {\n                        var name = dir.name.value;\n                        if (name === \"client\")\n                            clientOnly = true;\n                        if (name === \"defer\") {\n                            var args = argumentsObjectFromField(dir, context.variables);\n                            // The @defer directive takes an optional args.if boolean\n                            // argument, similar to @include(if: boolean). Note that\n                            // @defer(if: false) does not make context.deferred false, but\n                            // instead behaves as if there was no @defer directive.\n                            if (!args || args.if !== false) {\n                                deferred = true;\n                            }\n                            // TODO In the future, we may want to record args.label using\n                            // context.deferred, if a label is specified.\n                        }\n                    });\n                }\n                if (isField(selection)) {\n                    var existing = fieldMap.get(selection);\n                    if (existing) {\n                        // If this field has been visited along another recursive path\n                        // before, the final context should have clientOnly or deferred set\n                        // to true only if *all* paths have the directive (hence the &&).\n                        clientOnly = clientOnly && existing.clientOnly;\n                        deferred = deferred && existing.deferred;\n                    }\n                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));\n                }\n                else {\n                    var fragment = getFragmentFromSelection(selection, context.lookupFragment);\n                    if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {\n                        throw newInvariantError(13, selection.name.value);\n                    }\n                    if (fragment &&\n                        policies.fragmentMatches(fragment, typename, result, context.variables)) {\n                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));\n                    }\n                }\n            });\n        })(selectionSet, context);\n        return fieldMap;\n    };\n    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {\n        var _a;\n        var _this = this;\n        if (mergeTree.map.size && !isReference(incoming)) {\n            var e_1 = \n            // Items in the same position in different arrays are not\n            // necessarily related to each other, so when incoming is an array\n            // we process its elements as if there was no existing data.\n            (!isArray(incoming) &&\n                // Likewise, existing must be either a Reference or a StoreObject\n                // in order for its fields to be safe to merge with the fields of\n                // the incoming object.\n                (isReference(existing) || storeValueIsStoreObject(existing))) ?\n                existing\n                : void 0;\n            // This narrowing is implied by mergeTree.map.size > 0 and\n            // !isReference(incoming), though TypeScript understandably cannot\n            // hope to infer this type.\n            var i_1 = incoming;\n            // The options.storage objects provided to read and merge functions\n            // are derived from the identity of the parent object plus a\n            // sequence of storeFieldName strings/numbers identifying the nested\n            // field name path of each field value to be merged.\n            if (e_1 && !getStorageArgs) {\n                getStorageArgs = [isReference(e_1) ? e_1.__ref : e_1];\n            }\n            // It's possible that applying merge functions to this subtree will\n            // not change the incoming data, so this variable tracks the fields\n            // that did change, so we can create a new incoming object when (and\n            // only when) at least one incoming field has changed. We use a Map\n            // to preserve the type of numeric keys.\n            var changedFields_1;\n            var getValue_1 = function (from, name) {\n                return (isArray(from) ?\n                    typeof name === \"number\" ?\n                        from[name]\n                        : void 0\n                    : context.store.getFieldValue(from, String(name)));\n            };\n            mergeTree.map.forEach(function (childTree, storeFieldName) {\n                var eVal = getValue_1(e_1, storeFieldName);\n                var iVal = getValue_1(i_1, storeFieldName);\n                // If we have no incoming data, leave any existing data untouched.\n                if (void 0 === iVal)\n                    return;\n                if (getStorageArgs) {\n                    getStorageArgs.push(storeFieldName);\n                }\n                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);\n                if (aVal !== iVal) {\n                    changedFields_1 = changedFields_1 || new Map();\n                    changedFields_1.set(storeFieldName, aVal);\n                }\n                if (getStorageArgs) {\n                    invariant(getStorageArgs.pop() === storeFieldName);\n                }\n            });\n            if (changedFields_1) {\n                // Shallow clone i so we can add changed fields to it.\n                incoming = (isArray(i_1) ? i_1.slice(0) : __assign({}, i_1));\n                changedFields_1.forEach(function (value, name) {\n                    incoming[name] = value;\n                });\n            }\n        }\n        if (mergeTree.info) {\n            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));\n        }\n        return incoming;\n    };\n    return StoreWriter;\n}());\nexport { StoreWriter };\nvar emptyMergeTreePool = [];\nfunction getChildMergeTree(_a, name) {\n    var map = _a.map;\n    if (!map.has(name)) {\n        map.set(name, emptyMergeTreePool.pop() || { map: new Map() });\n    }\n    return map.get(name);\n}\nfunction mergeMergeTrees(left, right) {\n    if (left === right || !right || mergeTreeIsEmpty(right))\n        return left;\n    if (!left || mergeTreeIsEmpty(left))\n        return right;\n    var info = left.info && right.info ? __assign(__assign({}, left.info), right.info) : left.info || right.info;\n    var needToMergeMaps = left.map.size && right.map.size;\n    var map = needToMergeMaps ? new Map()\n        : left.map.size ? left.map\n            : right.map;\n    var merged = { info: info, map: map };\n    if (needToMergeMaps) {\n        var remainingRightKeys_1 = new Set(right.map.keys());\n        left.map.forEach(function (leftTree, key) {\n            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));\n            remainingRightKeys_1.delete(key);\n        });\n        remainingRightKeys_1.forEach(function (key) {\n            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));\n        });\n    }\n    return merged;\n}\nfunction mergeTreeIsEmpty(tree) {\n    return !tree || !(tree.info || tree.map.size);\n}\nfunction maybeRecycleChildMergeTree(_a, name) {\n    var map = _a.map;\n    var childTree = map.get(name);\n    if (childTree && mergeTreeIsEmpty(childTree)) {\n        emptyMergeTreePool.push(childTree);\n        map.delete(name);\n    }\n}\nvar warnings = new Set();\n// Note that this function is unused in production, and thus should be\n// pruned by any well-configured minifier.\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    // It's always safe to replace a reference, since it refers to data\n    // safely stored elsewhere.\n    if (isReference(existing))\n        return;\n    // If the values are structurally equivalent, we do not need to worry\n    // about incoming replacing existing.\n    if (equal(existing, incoming))\n        return;\n    // If we're replacing every key of the existing object, then the\n    // existing data would be overwritten even if the objects were\n    // normalized, so warning would not be helpful here.\n    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {\n        return;\n    }\n    var parentType = store.getFieldValue(existingRef, \"__typename\") ||\n        store.getFieldValue(incomingObj, \"__typename\");\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var typeDotName = \"\".concat(parentType, \".\").concat(fieldName);\n    // Avoid warning more than once for the same type and field name.\n    if (warnings.has(typeDotName))\n        return;\n    warnings.add(typeDotName);\n    var childTypenames = [];\n    // Arrays do not have __typename fields, and always need a custom merge\n    // function, even if their elements are normalized entities.\n    if (!isArray(existing) && !isArray(incoming)) {\n        [existing, incoming].forEach(function (child) {\n            var typename = store.getFieldValue(child, \"__typename\");\n            if (typeof typename === \"string\" && !childTypenames.includes(typename)) {\n                childTypenames.push(typename);\n            }\n        });\n    }\n    globalThis.__DEV__ !== false && invariant.warn(14, fieldName, parentType, childTypenames.length ?\n        \"either ensure all objects of type \" +\n            childTypenames.join(\" and \") +\n            \" have an ID or a custom merge function, or \"\n        : \"\", typeDotName, existing, incoming);\n}\n//# sourceMappingURL=writeToStore.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\n// Make builtins like Map and Set safe to use with non-extensible objects.\nimport \"./fixPolyfills.js\";\nimport { wrap } from \"optimism\";\nimport { equal } from \"@wry/equality\";\nimport { ApolloCache } from \"../core/cache.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\nimport { addTypenameToDocument, isReference, DocumentTransform, } from \"../../utilities/index.js\";\nimport { StoreReader } from \"./readFromStore.js\";\nimport { StoreWriter } from \"./writeToStore.js\";\nimport { EntityStore, supportsResultCaching } from \"./entityStore.js\";\nimport { makeVar, forgetCache, recallCache } from \"./reactiveVars.js\";\nimport { Policies } from \"./policies.js\";\nimport { hasOwn, normalizeConfig, shouldCanonizeResults } from \"./helpers.js\";\nimport { canonicalStringify } from \"./object-canon.js\";\nvar InMemoryCache = /** @class */ (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.addTypenameTransform = new DocumentTransform(addTypenameToDocument);\n        // Override the default value, since InMemoryCache result objects are frozen\n        // in development and expected to remain logically immutable in production.\n        _this.assumeImmutableResults = true;\n        _this.makeVar = makeVar;\n        _this.txCount = 0;\n        _this.config = normalizeConfig(config);\n        _this.addTypename = !!_this.config.addTypename;\n        _this.policies = new Policies({\n            cache: _this,\n            dataIdFromObject: _this.config.dataIdFromObject,\n            possibleTypes: _this.config.possibleTypes,\n            typePolicies: _this.config.typePolicies,\n        });\n        _this.init();\n        return _this;\n    }\n    InMemoryCache.prototype.init = function () {\n        // Passing { resultCaching: false } in the InMemoryCache constructor options\n        // will completely disable dependency tracking, which will improve memory\n        // usage but worsen the performance of repeated reads.\n        var rootStore = (this.data = new EntityStore.Root({\n            policies: this.policies,\n            resultCaching: this.config.resultCaching,\n        }));\n        // When no optimistic writes are currently active, cache.optimisticData ===\n        // cache.data, so there are no additional layers on top of the actual data.\n        // When an optimistic update happens, this.optimisticData will become a\n        // linked list of EntityStore Layer objects that terminates with the\n        // original this.data cache object.\n        this.optimisticData = rootStore.stump;\n        this.resetResultCache();\n    };\n    InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {\n        var _this = this;\n        var previousReader = this.storeReader;\n        var fragments = this.config.fragments;\n        // The StoreWriter is mostly stateless and so doesn't really need to be\n        // reset, but it does need to have its writer.storeReader reference updated,\n        // so it's simpler to update this.storeWriter as well.\n        this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({\n            cache: this,\n            addTypename: this.addTypename,\n            resultCacheMaxSize: this.config.resultCacheMaxSize,\n            canonizeResults: shouldCanonizeResults(this.config),\n            canon: resetResultIdentities ? void 0 : (previousReader && previousReader.canon),\n            fragments: fragments,\n        })), fragments);\n        this.maybeBroadcastWatch = wrap(function (c, options) {\n            return _this.broadcastWatch(c, options);\n        }, {\n            max: this.config.resultCacheMaxSize,\n            makeCacheKey: function (c) {\n                // Return a cache key (thus enabling result caching) only if we're\n                // currently using a data store that can track cache dependencies.\n                var store = c.optimistic ? _this.optimisticData : _this.data;\n                if (supportsResultCaching(store)) {\n                    var optimistic = c.optimistic, id = c.id, variables = c.variables;\n                    return store.makeCacheKey(c.query, \n                    // Different watches can have the same query, optimistic\n                    // status, rootId, and variables, but if their callbacks are\n                    // different, the (identical) result needs to be delivered to\n                    // each distinct callback. The easiest way to achieve that\n                    // separation is to include c.callback in the cache key for\n                    // maybeBroadcastWatch calls. See issue #5733.\n                    c.callback, canonicalStringify({ optimistic: optimistic, id: id, variables: variables }));\n                }\n            },\n        });\n        // Since we have thrown away all the cached functions that depend on the\n        // CacheGroup dependencies maintained by EntityStore, we should also reset\n        // all CacheGroup dependency information.\n        new Set([this.data.group, this.optimisticData.group]).forEach(function (group) {\n            return group.resetCaching();\n        });\n    };\n    InMemoryCache.prototype.restore = function (data) {\n        this.init();\n        // Since calling this.init() discards/replaces the entire StoreReader, along\n        // with the result caches it maintains, this.data.replace(data) won't have\n        // to bother deleting the old 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 \n        // Since read returns data or null, without any additional metadata\n        // about whether/where there might have been missing fields, the\n        // default behavior cannot be returnPartialData = true (like it is\n        // for the diff method), since defaulting to true would violate the\n        // integrity of the T in the return type. However, partial data may\n        // be useful in some cases, so returnPartialData:true may be\n        // specified explicitly.\n        _a = options.returnPartialData, \n        // Since read returns data or null, without any additional metadata\n        // about whether/where there might have been missing fields, the\n        // default behavior cannot be returnPartialData = true (like it is\n        // for the diff method), since defaulting to true would violate the\n        // integrity of the T in the return type. However, partial data may\n        // be useful in some cases, so returnPartialData:true may be\n        // specified explicitly.\n        returnPartialData = _a === void 0 ? false : _a;\n        try {\n            return (this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null);\n        }\n        catch (e) {\n            if (e instanceof MissingFieldError) {\n                // Swallow MissingFieldError and return null, so callers do not need to\n                // worry about catching \"normal\" exceptions resulting from incomplete\n                // cache data. Unexpected errors will be re-thrown. If you need more\n                // information about which fields were missing, use cache.diff instead,\n                // and examine diffResult.missing.\n                return null;\n            }\n            throw e;\n        }\n    };\n    InMemoryCache.prototype.write = function (options) {\n        try {\n            ++this.txCount;\n            return this.storeWriter.writeToStore(this.data, options);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.modify = function (options) {\n        if (hasOwn.call(options, \"id\") && !options.id) {\n            // To my knowledge, TypeScript does not currently provide a way to\n            // enforce that an optional property?:type must *not* be undefined\n            // when present. That ability would be useful here, because we want\n            // options.id to default to ROOT_QUERY only when no options.id was\n            // provided. If the caller attempts to pass options.id with a\n            // falsy/undefined value (perhaps because cache.identify failed), we\n            // should not assume the goal was to modify the ROOT_QUERY object.\n            // We could throw, but it seems natural to return false to indicate\n            // that nothing was modified.\n            return false;\n        }\n        var store = ((options.optimistic) // Defaults to false.\n        ) ?\n            this.optimisticData\n            : this.data;\n        try {\n            ++this.txCount;\n            return store.modify(options.id || \"ROOT_QUERY\", options.fields);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.diff = function (options) {\n        return this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || \"ROOT_QUERY\", config: this.config }));\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        if (!this.watches.size) {\n            // In case we previously called forgetCache(this) because\n            // this.watches became empty (see below), reattach this cache to any\n            // reactive variables on which it previously depended. It might seem\n            // paradoxical that we're able to recall something we supposedly\n            // forgot, but the point of calling forgetCache(this) is to silence\n            // useless broadcasts while this.watches is empty, and to allow the\n            // cache to be garbage collected. If, however, we manage to call\n            // recallCache(this) here, this cache object must not have been\n            // garbage collected yet, and should resume receiving updates from\n            // reactive variables, now that it has a watcher to notify.\n            recallCache(this);\n        }\n        this.watches.add(watch);\n        if (watch.immediate) {\n            this.maybeBroadcastWatch(watch);\n        }\n        return function () {\n            // Once we remove the last watch from this.watches, cache.broadcastWatches\n            // no longer does anything, so we preemptively tell the reactive variable\n            // system to exclude this cache from future broadcasts.\n            if (_this.watches.delete(watch) && !_this.watches.size) {\n                forgetCache(_this);\n            }\n            // Remove this watch from the LRU cache managed by the\n            // maybeBroadcastWatch OptimisticWrapperFunction, to prevent memory\n            // leaks involving the closure of watch.callback.\n            _this.maybeBroadcastWatch.forget(watch);\n        };\n    };\n    InMemoryCache.prototype.gc = function (options) {\n        canonicalStringify.reset();\n        var ids = this.optimisticData.gc();\n        if (options && !this.txCount) {\n            if (options.resetResultCache) {\n                this.resetResultCache(options.resetResultIdentities);\n            }\n            else if (options.resetResultIdentities) {\n                this.storeReader.resetCanon();\n            }\n        }\n        return ids;\n    };\n    // Call this method to ensure the given root ID remains in the cache after\n    // garbage collection, along with its transitive child entities. Note that\n    // the cache automatically retains all directly written entities. By default,\n    // the retainment persists after optimistic updates are removed. Pass true\n    // for the optimistic argument if you would prefer for the retainment to be\n    // discarded when the top-most optimistic layer is removed. Returns the\n    // resulting (non-negative) retainment count.\n    InMemoryCache.prototype.retain = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).retain(rootId);\n    };\n    // Call this method to undo the effect of the retain method, above. Once the\n    // retainment count falls to zero, the given ID will no longer be preserved\n    // during garbage collection, though it may still be preserved by other safe\n    // entities that refer to it. Returns the resulting (non-negative) retainment\n    // count, in case that's useful.\n    InMemoryCache.prototype.release = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).release(rootId);\n    };\n    // Returns the canonical ID for a given StoreObject, obeying typePolicies\n    // and keyFields (and dataIdFromObject, if you still use that). At minimum,\n    // the object must contain a __typename and any primary key fields required\n    // to identify entities of that type. If you pass a query result object, be\n    // sure that none of the primary key fields have been renamed by aliasing.\n    // If you pass a Reference object, its __ref ID string will be returned.\n    InMemoryCache.prototype.identify = function (object) {\n        if (isReference(object))\n            return object.__ref;\n        try {\n            return this.policies.identify(object)[0];\n        }\n        catch (e) {\n            globalThis.__DEV__ !== false && invariant.warn(e);\n        }\n    };\n    InMemoryCache.prototype.evict = function (options) {\n        if (!options.id) {\n            if (hasOwn.call(options, \"id\")) {\n                // See comment in modify method about why we return false when\n                // options.id exists but is falsy/undefined.\n                return false;\n            }\n            options = __assign(__assign({}, options), { id: \"ROOT_QUERY\" });\n        }\n        try {\n            // It's unlikely that the eviction will end up invoking any other\n            // cache update operations while it's running, but {in,de}crementing\n            // this.txCount still seems like a good idea, for uniformity with\n            // the other update methods.\n            ++this.txCount;\n            // Pass this.data as a limit on the depth of the eviction, so evictions\n            // during optimistic updates (when this.data is temporarily set equal to\n            // this.optimisticData) do not escape their optimistic Layer.\n            return this.optimisticData.evict(options, this.data);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.reset = function (options) {\n        var _this = this;\n        this.init();\n        canonicalStringify.reset();\n        if (options && options.discardWatches) {\n            // Similar to what happens in the unsubscribe function returned by\n            // cache.watch, applied to all current watches.\n            this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });\n            this.watches.clear();\n            forgetCache(this);\n        }\n        else {\n            // Calling this.init() above unblocks all maybeBroadcastWatch caching, so\n            // this.broadcastWatches() triggers a broadcast to every current watcher\n            // (letting them know their data is now missing). This default behavior is\n            // convenient because it means the watches do not have to be manually\n            // reestablished after resetting the cache. To prevent this broadcast and\n            // cancel all watches, pass true for options.discardWatches.\n            this.broadcastWatches();\n        }\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var newOptimisticData = this.optimisticData.removeLayer(idToRemove);\n        if (newOptimisticData !== this.optimisticData) {\n            this.optimisticData = newOptimisticData;\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.batch = function (options) {\n        var _this = this;\n        var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;\n        var updateResult;\n        var perform = function (layer) {\n            var _a = _this, data = _a.data, optimisticData = _a.optimisticData;\n            ++_this.txCount;\n            if (layer) {\n                _this.data = _this.optimisticData = layer;\n            }\n            try {\n                return (updateResult = update(_this));\n            }\n            finally {\n                --_this.txCount;\n                _this.data = data;\n                _this.optimisticData = optimisticData;\n            }\n        };\n        var alreadyDirty = new Set();\n        if (onWatchUpdated && !this.txCount) {\n            // If an options.onWatchUpdated callback is provided, we want to call it\n            // with only the Cache.WatchOptions objects affected by options.update,\n            // but there might be dirty watchers already waiting to be broadcast that\n            // have nothing to do with the update. To prevent including those watchers\n            // in the post-update broadcast, we perform this initial broadcast to\n            // collect the dirty watchers, so we can re-dirty them later, after the\n            // post-update broadcast, allowing them to receive their pending\n            // broadcasts the next time broadcastWatches is called, just as they would\n            // if we never called cache.batch.\n            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch) {\n                    alreadyDirty.add(watch);\n                    return false;\n                } }));\n        }\n        if (typeof optimistic === \"string\") {\n            // Note that there can be multiple layers with the same optimistic ID.\n            // When removeOptimistic(id) is called for that id, all matching layers\n            // will be removed, and the remaining layers will be reapplied.\n            this.optimisticData = this.optimisticData.addLayer(optimistic, perform);\n        }\n        else if (optimistic === false) {\n            // Ensure both this.data and this.optimisticData refer to the root\n            // (non-optimistic) layer of the cache during the update. Note that\n            // this.data could be a Layer if we are currently executing an optimistic\n            // update function, but otherwise will always be an EntityStore.Root\n            // instance.\n            perform(this.data);\n        }\n        else {\n            // Otherwise, leave this.data and this.optimisticData unchanged and run\n            // the update with broadcast batching.\n            perform();\n        }\n        if (typeof removeOptimistic === \"string\") {\n            this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);\n        }\n        // Note: if this.txCount > 0, then alreadyDirty.size === 0, so this code\n        // takes the else branch and calls this.broadcastWatches(options), which\n        // does nothing when this.txCount > 0.\n        if (onWatchUpdated && alreadyDirty.size) {\n            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch, diff) {\n                    var result = onWatchUpdated.call(this, watch, diff);\n                    if (result !== false) {\n                        // Since onWatchUpdated did not return false, this diff is\n                        // about to be broadcast to watch.callback, so we don't need\n                        // to re-dirty it with the other alreadyDirty watches below.\n                        alreadyDirty.delete(watch);\n                    }\n                    return result;\n                } }));\n            // Silently re-dirty any watches that were already dirty before the update\n            // was performed, and were not broadcast just now.\n            if (alreadyDirty.size) {\n                alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });\n            }\n        }\n        else {\n            // If alreadyDirty is empty or we don't have an onWatchUpdated\n            // function, we don't need to go to the trouble of wrapping\n            // options.onWatchUpdated.\n            this.broadcastWatches(options);\n        }\n        return updateResult;\n    };\n    InMemoryCache.prototype.performTransaction = function (update, optimisticId) {\n        return this.batch({\n            update: update,\n            optimistic: optimisticId || optimisticId !== null,\n        });\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        return this.addTypenameToDocument(this.addFragmentsToDocument(document));\n    };\n    InMemoryCache.prototype.broadcastWatches = function (options) {\n        var _this = this;\n        if (!this.txCount) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });\n        }\n    };\n    InMemoryCache.prototype.addFragmentsToDocument = function (document) {\n        var fragments = this.config.fragments;\n        return fragments ? fragments.transform(document) : document;\n    };\n    InMemoryCache.prototype.addTypenameToDocument = function (document) {\n        if (this.addTypename) {\n            return this.addTypenameTransform.transformDocument(document);\n        }\n        return document;\n    };\n    // This method is wrapped by maybeBroadcastWatch, which is called by\n    // broadcastWatches, so that we compute and broadcast results only when\n    // the data that would be broadcast might have changed. It would be\n    // simpler to check for changes after recomputing a result but before\n    // broadcasting it, but this wrapping approach allows us to skip both\n    // the recomputation and the broadcast, in most cases.\n    InMemoryCache.prototype.broadcastWatch = function (c, options) {\n        var lastDiff = c.lastDiff;\n        // Both WatchOptions and DiffOptions extend ReadOptions, and DiffOptions\n        // currently requires no additional properties, so we can use c (a\n        // WatchOptions object) as DiffOptions, without having to allocate a new\n        // object, and without having to enumerate the relevant properties (query,\n        // variables, etc.) explicitly. There will be some additional properties\n        // (lastDiff, callback, etc.), but cache.diff ignores them.\n        var diff = this.diff(c);\n        if (options) {\n            if (c.optimistic && typeof options.optimistic === \"string\") {\n                diff.fromOptimisticTransaction = true;\n            }\n            if (options.onWatchUpdated &&\n                options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {\n                // Returning false from the onWatchUpdated callback will prevent\n                // calling c.callback(diff) for this watcher.\n                return;\n            }\n        }\n        if (!lastDiff || !equal(lastDiff.result, diff.result)) {\n            c.callback((c.lastDiff = diff), lastDiff);\n        }\n    };\n    return InMemoryCache;\n}(ApolloCache));\nexport { InMemoryCache };\n//# sourceMappingURL=inMemoryCache.js.map","import { __assign } from \"tslib\";\nimport { Trie } from \"@wry/trie\";\nimport { canUseWeakMap, canUseWeakSet, isNonNullObject as isObjectOrArray, } from \"../../utilities/index.js\";\nimport { isArray } from \"./helpers.js\";\nfunction shallowCopy(value) {\n    if (isObjectOrArray(value)) {\n        return isArray(value) ?\n            value.slice(0)\n            : __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n    }\n    return value;\n}\n// When programmers talk about the \"canonical form\" of an object, they\n// usually have the following meaning in mind, which I've copied from\n// https://en.wiktionary.org/wiki/canonical_form:\n//\n// 1. A standard or normal presentation of a mathematical entity [or\n//    object]. A canonical form is an element of a set of representatives\n//    of equivalence classes of forms such that there is a function or\n//    procedure which projects every element of each equivalence class\n//    onto that one element, the canonical form of that equivalence\n//    class. The canonical form is expected to be simpler than the rest of\n//    the forms in some way.\n//\n// That's a long-winded way of saying any two objects that have the same\n// canonical form may be considered equivalent, even if they are !==,\n// which usually means the objects are structurally equivalent (deeply\n// equal), but don't necessarily use the same memory.\n//\n// Like a literary or musical canon, this ObjectCanon class represents a\n// collection of unique canonical items (JavaScript objects), with the\n// important property that canon.admit(a) === canon.admit(b) if a and b\n// are deeply equal to each other. In terms of the definition above, the\n// canon.admit method is the \"function or procedure which projects every\"\n// object \"onto that one element, the canonical form.\"\n//\n// In the worst case, the canonicalization process may involve looking at\n// every property in the provided object tree, so it takes the same order\n// of time as deep equality checking. Fortunately, already-canonicalized\n// objects are returned immediately from canon.admit, so the presence of\n// canonical subtrees tends to speed up canonicalization.\n//\n// Since consumers of canonical objects can check for deep equality in\n// constant time, canonicalizing cache results can massively improve the\n// performance of application code that skips re-rendering unchanged\n// results, such as \"pure\" UI components in a framework like React.\n//\n// Of course, since canonical objects may be shared widely between\n// unrelated consumers, it's important to think of them as immutable, even\n// though they are not actually frozen with Object.freeze in production,\n// due to the extra performance overhead that comes with frozen objects.\n//\n// Custom scalar objects whose internal class name is neither Array nor\n// Object can be included safely in the admitted tree, but they will not\n// be replaced with a canonical version (to put it another way, they are\n// assumed to be canonical already).\n//\n// If we ignore custom objects, no detection of cycles or repeated object\n// references is currently required by the StoreReader class, since\n// GraphQL result objects are JSON-serializable trees (and thus contain\n// neither cycles nor repeated subtrees), so we can avoid the complexity\n// of keeping track of objects we've already seen during the recursion of\n// the admit method.\n//\n// In the future, we may consider adding additional cases to the switch\n// statement to handle other common object types, such as \"[object Date]\"\n// objects, as needed.\nvar ObjectCanon = /** @class */ (function () {\n    function ObjectCanon() {\n        // Set of all canonical objects this ObjectCanon has admitted, allowing\n        // canon.admit to return previously-canonicalized objects immediately.\n        this.known = new (canUseWeakSet ? WeakSet : Set)();\n        // Efficient storage/lookup structure for canonical objects.\n        this.pool = new Trie(canUseWeakMap);\n        // Make the ObjectCanon assume this value has already been\n        // canonicalized.\n        this.passes = new WeakMap();\n        // Arrays that contain the same elements in a different order can share\n        // the same SortedKeysInfo object, to save memory.\n        this.keysByJSON = new Map();\n        // This has to come last because it depends on keysByJSON.\n        this.empty = this.admit({});\n    }\n    ObjectCanon.prototype.isKnown = function (value) {\n        return isObjectOrArray(value) && this.known.has(value);\n    };\n    ObjectCanon.prototype.pass = function (value) {\n        if (isObjectOrArray(value)) {\n            var copy = shallowCopy(value);\n            this.passes.set(copy, value);\n            return copy;\n        }\n        return value;\n    };\n    ObjectCanon.prototype.admit = function (value) {\n        var _this = this;\n        if (isObjectOrArray(value)) {\n            var original = this.passes.get(value);\n            if (original)\n                return original;\n            var proto = Object.getPrototypeOf(value);\n            switch (proto) {\n                case Array.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var array = value.map(this.admit, this);\n                    // Arrays are looked up in the Trie using their recursively\n                    // canonicalized elements, and the known version of the array is\n                    // preserved as node.array.\n                    var node = this.pool.lookupArray(array);\n                    if (!node.array) {\n                        this.known.add((node.array = array));\n                        // Since canonical arrays may be shared widely between\n                        // unrelated consumers, it's important to regard them as\n                        // immutable, even if they are not frozen in production.\n                        if (globalThis.__DEV__ !== false) {\n                            Object.freeze(array);\n                        }\n                    }\n                    return node.array;\n                }\n                case null:\n                case Object.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var proto_1 = Object.getPrototypeOf(value);\n                    var array_1 = [proto_1];\n                    var keys = this.sortedKeys(value);\n                    array_1.push(keys.json);\n                    var firstValueIndex_1 = array_1.length;\n                    keys.sorted.forEach(function (key) {\n                        array_1.push(_this.admit(value[key]));\n                    });\n                    // Objects are looked up in the Trie by their prototype (which\n                    // is *not* recursively canonicalized), followed by a JSON\n                    // representation of their (sorted) keys, followed by the\n                    // sequence of recursively canonicalized values corresponding to\n                    // those keys. To keep the final results unambiguous with other\n                    // sequences (such as arrays that just happen to contain [proto,\n                    // keys.json, value1, value2, ...]), the known version of the\n                    // object is stored as node.object.\n                    var node = this.pool.lookupArray(array_1);\n                    if (!node.object) {\n                        var obj_1 = (node.object = Object.create(proto_1));\n                        this.known.add(obj_1);\n                        keys.sorted.forEach(function (key, i) {\n                            obj_1[key] = array_1[firstValueIndex_1 + i];\n                        });\n                        // Since canonical objects may be shared widely between\n                        // unrelated consumers, it's important to regard them as\n                        // immutable, even if they are not frozen in production.\n                        if (globalThis.__DEV__ !== false) {\n                            Object.freeze(obj_1);\n                        }\n                    }\n                    return node.object;\n                }\n            }\n        }\n        return value;\n    };\n    // It's worthwhile to cache the sorting of arrays of strings, since the\n    // same initial unsorted arrays tend to be encountered many times.\n    // Fortunately, we can reuse the Trie machinery to look up the sorted\n    // arrays in linear time (which is faster than sorting large arrays).\n    ObjectCanon.prototype.sortedKeys = function (obj) {\n        var keys = Object.keys(obj);\n        var node = this.pool.lookupArray(keys);\n        if (!node.keys) {\n            keys.sort();\n            var json = JSON.stringify(keys);\n            if (!(node.keys = this.keysByJSON.get(json))) {\n                this.keysByJSON.set(json, (node.keys = { sorted: keys, json: json }));\n            }\n        }\n        return node.keys;\n    };\n    return ObjectCanon;\n}());\nexport { ObjectCanon };\n// Since the keys of canonical objects are always created in lexicographically\n// sorted order, we can use the ObjectCanon to implement a fast and stable\n// version of JSON.stringify, which automatically sorts object keys.\nexport var canonicalStringify = Object.assign(function (value) {\n    if (isObjectOrArray(value)) {\n        if (stringifyCanon === void 0) {\n            resetCanonicalStringify();\n        }\n        var canonical = stringifyCanon.admit(value);\n        var json = stringifyCache.get(canonical);\n        if (json === void 0) {\n            stringifyCache.set(canonical, (json = JSON.stringify(canonical)));\n        }\n        return json;\n    }\n    return JSON.stringify(value);\n}, {\n    reset: resetCanonicalStringify,\n});\n// Can be reset by calling canonicalStringify.reset().\nvar stringifyCanon;\nvar stringifyCache;\nfunction resetCanonicalStringify() {\n    stringifyCanon = new ObjectCanon();\n    stringifyCache = new (canUseWeakMap ? WeakMap : Map)();\n}\n//# sourceMappingURL=object-canon.js.map","import { dep, Slot } from \"optimism\";\n// Contextual Slot that acquires its value when custom read functions are\n// called in Policies#readField.\nexport var cacheSlot = new Slot();\nvar cacheInfoMap = new WeakMap();\nfunction getCacheInfo(cache) {\n    var info = cacheInfoMap.get(cache);\n    if (!info) {\n        cacheInfoMap.set(cache, (info = {\n            vars: new Set(),\n            dep: dep(),\n        }));\n    }\n    return info;\n}\nexport function forgetCache(cache) {\n    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });\n}\n// Calling forgetCache(cache) serves to silence broadcasts and allows the\n// cache to be garbage collected. However, the varsByCache WeakMap\n// preserves the set of reactive variables that were previously associated\n// with this cache, which makes it possible to \"recall\" the cache at a\n// later time, by reattaching it to those variables. If the cache has been\n// garbage collected in the meantime, because it is no longer reachable,\n// you won't be able to call recallCache(cache), and the cache will\n// automatically disappear from the varsByCache WeakMap.\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                    // Invalidate any fields with custom read functions that\n                    // consumed this variable, so query results involving those\n                    // fields will be recomputed the next time we read them.\n                    getCacheInfo(cache).dep.dirty(rv);\n                    // Broadcast changes to any caches that have previously read\n                    // from this variable.\n                    broadcast(cache);\n                });\n                // Finally, notify any listeners added via rv.onNextChange.\n                var oldListeners = Array.from(listeners);\n                listeners.clear();\n                oldListeners.forEach(function (listener) { return listener(value); });\n            }\n        }\n        else {\n            // When reading from the variable, obtain the current cache from\n            // context via cacheSlot. This isn't entirely foolproof, but it's\n            // the same system that powers varDep.\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 { ApolloLink } from \"./ApolloLink.js\";\nexport var execute = ApolloLink.execute;\n//# sourceMappingURL=execute.js.map","import { __extends } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { createHttpLink } from \"./createHttpLink.js\";\nvar HttpLink = /** @class */ (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 { Observable } from \"./Observable.js\";\n// Like Observable.prototype.map, except that the mapping function can\n// optionally return a Promise (or be async).\nexport function asyncMap(observable, mapFn, catchFn) {\n    return new Observable(function (observer) {\n        var promiseQueue = {\n            // Normally we would initialize promiseQueue to Promise.resolve(), but\n            // in this case, for backwards compatibility, we need to be careful to\n            // invoke the first callback synchronously.\n            then: function (callback) {\n                return new Promise(function (resolve) { return resolve(callback()); });\n            },\n        };\n        function makeCallback(examiner, key) {\n            return function (arg) {\n                if (examiner) {\n                    var both = function () {\n                        // If the observer is closed, we don't want to continue calling the\n                        // mapping function - it's result will be swallowed anyways.\n                        return observer.closed ?\n                            /* will be swallowed */ 0\n                            : examiner(arg);\n                    };\n                    promiseQueue = promiseQueue.then(both, both).then(function (result) { return observer.next(result); }, function (error) { return observer.error(error); });\n                }\n                else {\n                    observer[key](arg);\n                }\n            };\n        }\n        var handler = {\n            next: makeCallback(mapFn, \"next\"),\n            error: makeCallback(catchFn, \"error\"),\n            complete: function () {\n                // no need to reassign `promiseQueue`, after `observer.complete`,\n                // the observer will be closed and short-circuit everything anyways\n                /*promiseQueue = */ promiseQueue.then(function () { return observer.complete(); });\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n//# sourceMappingURL=asyncMap.js.map","import { isNonEmptyArray } from \"./arrays.js\";\nimport { isExecutionPatchIncrementalResult } from \"./incrementalResult.js\";\nexport function graphQLResultHasError(result) {\n    var errors = getGraphQLErrorsFromResult(result);\n    return isNonEmptyArray(errors);\n}\nexport function getGraphQLErrorsFromResult(result) {\n    var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];\n    if (isExecutionPatchIncrementalResult(result) &&\n        isNonEmptyArray(result.incremental)) {\n        result.incremental.forEach(function (incrementalResult) {\n            if (incrementalResult.errors) {\n                graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);\n            }\n        });\n    }\n    return graphQLErrors;\n}\n//# sourceMappingURL=errorHandling.js.map","export function iterateObserversSafely(observers, method, argument) {\n    // In case observers is modified during iteration, we need to commit to the\n    // original elements, which also provides an opportunity to filter them down\n    // to just the observers with the given method.\n    var observersWithMethod = [];\n    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });\n    observersWithMethod.forEach(function (obs) { return obs[method](argument); });\n}\n//# sourceMappingURL=iteration.js.map","import { Observable } from \"./Observable.js\";\nimport { canUseSymbol } from \"../common/canUse.js\";\n// Generic implementations of Observable.prototype methods like map and\n// filter need to know how to create a new Observable from an Observable\n// subclass (like Concast or ObservableQuery). Those methods assume\n// (perhaps unwisely?) that they can call the subtype's constructor with a\n// Subscriber function, even though the subclass constructor might expect\n// different parameters. Defining this static Symbol.species property on\n// the subclass is a hint to generic Observable code to use the default\n// constructor instead of trying to do `new Subclass(observer => ...)`.\nexport function fixObservableSubclass(subclass) {\n    function set(key) {\n        // Object.defineProperty is necessary because the Symbol.species\n        // property is a getter by default in modern JS environments, so we\n        // can't assign to it with a normal assignment expression.\n        Object.defineProperty(subclass, key, { value: Observable });\n    }\n    if (canUseSymbol && Symbol.species) {\n        set(Symbol.species);\n    }\n    // The \"@@species\" string is used as a fake Symbol.species value in some\n    // polyfill systems (including the SymbolSpecies variable used by\n    // zen-observable), so we should set it as well, to be safe.\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}\n// A Concast<T> observable concatenates the given sources into a single\n// non-overlapping sequence of Ts, automatically unwrapping any promises,\n// and broadcasts the T elements of that sequence to any number of\n// subscribers, all without creating a bunch of intermediary Observable\n// wrapper objects.\n//\n// Even though any number of observers can subscribe to the Concast, each\n// source observable is guaranteed to receive at most one subscribe call,\n// and the results are multicast to all observers.\n//\n// In addition to broadcasting every next/error message to this.observers,\n// the Concast stores the most recent message using this.latest, so any\n// new observers can immediately receive the latest message, even if it\n// was originally delivered in the past. This behavior means we can assume\n// every active observer in this.observers has received the same most\n// recent message.\n//\n// With the exception of this.latest replay, a Concast is a \"hot\"\n// observable in the sense that it does not replay past results from the\n// beginning of time for each new observer.\n//\n// Could we have used some existing RxJS class instead? Concast<T> is\n// similar to a BehaviorSubject<T>, because it is multicast and redelivers\n// the latest next/error message to new subscribers. Unlike Subject<T>,\n// Concast<T> does not expose an Observer<T> interface (this.handlers is\n// intentionally private), since Concast<T> gets its inputs from the\n// concatenated sources. If we ever switch to RxJS, there may be some\n// value in reusing their code, but for now we use zen-observable, which\n// does not contain any Subject implementations.\nvar Concast = /** @class */ (function (_super) {\n    __extends(Concast, _super);\n    // Not only can the individual elements of the iterable be promises, but\n    // also the iterable itself can be wrapped in a promise.\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        // Active observers receiving broadcast messages. Thanks to this.latest,\n        // we can assume all observers in this Set have received the same most\n        // recent message, though possibly at different times in the past.\n        _this.observers = new Set();\n        _this.promise = new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        });\n        // Bound handler functions that can be reused for every internal\n        // subscription.\n        _this.handlers = {\n            next: function (result) {\n                if (_this.sub !== null) {\n                    _this.latest = [\"next\", result];\n                    _this.notify(\"next\", result);\n                    iterateObserversSafely(_this.observers, \"next\", result);\n                }\n            },\n            error: function (error) {\n                var sub = _this.sub;\n                if (sub !== null) {\n                    // Delay unsubscribing from the underlying subscription slightly,\n                    // so that immediately subscribing another observer can keep the\n                    // subscription active.\n                    if (sub)\n                        setTimeout(function () { return sub.unsubscribe(); });\n                    _this.sub = null;\n                    _this.latest = [\"error\", error];\n                    _this.reject(error);\n                    _this.notify(\"error\", error);\n                    iterateObserversSafely(_this.observers, \"error\", error);\n                }\n            },\n            complete: function () {\n                var _a = _this, sub = _a.sub, _b = _a.sources, sources = _b === void 0 ? [] : _b;\n                if (sub !== null) {\n                    // If complete is called before concast.start, this.sources may be\n                    // undefined, so we use a default value of [] for sources. That works\n                    // here because it falls into the if (!value) {...} block, which\n                    // appropriately terminates the Concast, even if this.sources might\n                    // eventually have been initialized to a non-empty array.\n                    var value = sources.shift();\n                    if (!value) {\n                        if (sub)\n                            setTimeout(function () { return sub.unsubscribe(); });\n                        _this.sub = null;\n                        if (_this.latest && _this.latest[0] === \"next\") {\n                            _this.resolve(_this.latest[1]);\n                        }\n                        else {\n                            _this.resolve();\n                        }\n                        _this.notify(\"complete\");\n                        // We do not store this.latest = [\"complete\"], because doing so\n                        // discards useful information about the previous next (or\n                        // error) message. Instead, if new observers subscribe after\n                        // this Concast has completed, they will receive the final\n                        // 'next' message (unless there was an error) immediately\n                        // followed by a 'complete' message (see addObserver).\n                        iterateObserversSafely(_this.observers, \"complete\");\n                    }\n                    else if (isPromiseLike(value)) {\n                        value.then(function (obs) { return (_this.sub = obs.subscribe(_this.handlers)); });\n                    }\n                    else {\n                        _this.sub = value.subscribe(_this.handlers);\n                    }\n                }\n            },\n        };\n        _this.nextResultListeners = new Set();\n        // A public way to abort observation and broadcast.\n        _this.cancel = function (reason) {\n            _this.reject(reason);\n            _this.sources = [];\n            _this.handlers.complete();\n        };\n        // Suppress rejection warnings for this.promise, since it's perfectly\n        // acceptable to pay no attention to this.promise if you're consuming\n        // the results through the normal observable API.\n        _this.promise.catch(function (_) { });\n        // If someone accidentally tries to create a Concast using a subscriber\n        // function, recover by creating an Observable from that subscriber and\n        // using it as the source.\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        // In practice, sources is most often simply an Array of observables.\n        // TODO Consider using sources[Symbol.iterator]() to take advantage\n        // of the laziness of non-Array iterables.\n        this.sources = Array.from(sources);\n        // Calling this.handlers.complete() kicks off consumption of the first\n        // source observable. It's tempting to do this step lazily in\n        // addObserver, but this.promise can be accessed without calling\n        // addObserver, so consumption needs to begin eagerly.\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 the subscription is already closed, and the last message was\n            // a 'next' message, simulate delivery of the final 'complete'\n            // message again.\n            if (this.sub === null && nextOrError === \"next\" && observer.complete) {\n                observer.complete();\n            }\n        }\n    };\n    Concast.prototype.addObserver = function (observer) {\n        if (!this.observers.has(observer)) {\n            // Immediately deliver the most recent message, so we can always\n            // be sure all observers have the latest information.\n            this.deliverLastMessage(observer);\n            this.observers.add(observer);\n        }\n    };\n    Concast.prototype.removeObserver = function (observer) {\n        if (this.observers.delete(observer) && this.observers.size < 1) {\n            // In case there are still any listeners in this.nextResultListeners, and\n            // no error or completion has been broadcast yet, make sure those\n            // observers have a chance to run and then remove themselves from\n            // this.observers.\n            this.handlers.complete();\n        }\n    };\n    Concast.prototype.notify = function (method, arg) {\n        var nextResultListeners = this.nextResultListeners;\n        if (nextResultListeners.size) {\n            // Replacing this.nextResultListeners first ensures it does not grow while\n            // we are iterating over it, potentially leading to infinite loops.\n            this.nextResultListeners = new Set();\n            nextResultListeners.forEach(function (listener) { return listener(method, arg); });\n        }\n    };\n    // We need a way to run callbacks just *before* the next result (or error or\n    // completion) is delivered by this Concast, so we can be sure any code that\n    // runs as a result of delivering that result/error observes the effects of\n    // running the callback(s). It was tempting to reuse the Observer type instead\n    // of introducing NextResultListener, but that messes with the sizing and\n    // maintenance of this.observers, and ends up being more code overall.\n    Concast.prototype.beforeNext = function (callback) {\n        var called = false;\n        this.nextResultListeners.add(function (method, arg) {\n            if (!called) {\n                called = true;\n                callback(method, arg);\n            }\n        });\n    };\n    return Concast;\n}(Observable));\nexport { Concast };\n// Necessary because the Concast constructor has a different signature\n// than the Observable constructor.\nfixObservableSubclass(Concast);\n//# sourceMappingURL=Concast.js.map","import { __rest } from \"tslib\";\nimport equal from \"@wry/equality\";\nimport { createFragmentMap, getFragmentDefinitions, getFragmentFromSelection, getMainDefinition, isField, resultKeyNameFromField, shouldInclude, } from \"../utilities/index.js\";\n// Returns true if aResult and bResult are deeply equal according to the fields\n// selected by the given query, ignoring any fields marked as @nonreactive.\nexport function equalByQuery(query, _a, _b, variables) {\n    var aData = _a.data, aRest = __rest(_a, [\"data\"]);\n    var bData = _b.data, bRest = __rest(_b, [\"data\"]);\n    return (equal(aRest, bRest) &&\n        equalBySelectionSet(getMainDefinition(query).selectionSet, aData, bData, {\n            fragmentMap: createFragmentMap(getFragmentDefinitions(query)),\n            variables: variables,\n        }));\n}\nfunction equalBySelectionSet(selectionSet, aResult, bResult, context) {\n    if (aResult === bResult) {\n        return true;\n    }\n    var seenSelections = new Set();\n    // Returning true from this Array.prototype.every callback function skips the\n    // current field/subtree. Returning false aborts the entire traversal\n    // immediately, causing equalBySelectionSet to return false.\n    return selectionSet.selections.every(function (selection) {\n        // Avoid re-processing the same selection at the same level of recursion, in\n        // case the same field gets included via multiple indirect fragment spreads.\n        if (seenSelections.has(selection))\n            return true;\n        seenSelections.add(selection);\n        // Ignore @skip(if: true) and @include(if: false) fields.\n        if (!shouldInclude(selection, context.variables))\n            return true;\n        // If the field or (named) fragment spread has a @nonreactive directive on\n        // it, we don't care if it's different, so we pretend it's the same.\n        if (selectionHasNonreactiveDirective(selection))\n            return true;\n        if (isField(selection)) {\n            var resultKey = resultKeyNameFromField(selection);\n            var aResultChild = aResult && aResult[resultKey];\n            var bResultChild = bResult && bResult[resultKey];\n            var childSelectionSet = selection.selectionSet;\n            if (!childSelectionSet) {\n                // These are scalar values, so we can compare them with deep equal\n                // without redoing the main recursive work.\n                return equal(aResultChild, bResultChild);\n            }\n            var aChildIsArray = Array.isArray(aResultChild);\n            var bChildIsArray = Array.isArray(bResultChild);\n            if (aChildIsArray !== bChildIsArray)\n                return false;\n            if (aChildIsArray && bChildIsArray) {\n                var length_1 = aResultChild.length;\n                if (bResultChild.length !== length_1) {\n                    return false;\n                }\n                for (var i = 0; i < length_1; ++i) {\n                    if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {\n                        return false;\n                    }\n                }\n                return true;\n            }\n            return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);\n        }\n        else {\n            var fragment = getFragmentFromSelection(selection, context.fragmentMap);\n            if (fragment) {\n                // The fragment might === selection if it's an inline fragment, but\n                // could be !== if it's a named fragment ...spread.\n                if (selectionHasNonreactiveDirective(fragment))\n                    return true;\n                return equalBySelectionSet(fragment.selectionSet, \n                // Notice that we reuse the same aResult and bResult values here,\n                // since the fragment ...spread does not specify a field name, but\n                // consists of multiple fields (within the fragment's selection set)\n                // that should be applied to the current result value(s).\n                aResult, bResult, context);\n            }\n        }\n    });\n}\nfunction selectionHasNonreactiveDirective(selection) {\n    return (!!selection.directives && selection.directives.some(directiveIsNonreactive));\n}\nfunction directiveIsNonreactive(dir) {\n    return dir.name.value === \"nonreactive\";\n}\n//# sourceMappingURL=equalByQuery.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from \"../utilities/globals/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { cloneDeep, compact, getOperationDefinition, Observable, iterateObserversSafely, fixObservableSubclass, getQueryDefinition, } from \"../utilities/index.js\";\nimport { equalByQuery } from \"./equalByQuery.js\";\nvar assign = Object.assign, hasOwnProperty = Object.hasOwnProperty;\nvar ObservableQuery = /** @class */ (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            // Zen Observable has its own error function, so in order to log correctly\n            // we need to provide a custom error callback.\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            // Deliver most recent error or result.\n            var last = _this.last;\n            if (last && last.error) {\n                observer.error && observer.error(last.error);\n            }\n            else if (last && last.result) {\n                observer.next && observer.next(last.result);\n            }\n            // Initiate observation of this query if it hasn't been reported to\n            // the QueryManager yet.\n            if (first) {\n                // Blindly catching here prevents unhandled promise rejections,\n                // and is safe because the ObservableQuery handles this error with\n                // this.observer.error, so we're not just swallowing the error by\n                // ignoring it here.\n                _this.reobserve().catch(function () { });\n            }\n            return function () {\n                if (_this.observers.delete(observer) && !_this.observers.size) {\n                    _this.tearDownQuery();\n                }\n            };\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        // related classes\n        _this.queryInfo = queryInfo;\n        _this.queryManager = queryManager;\n        // active state\n        _this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);\n        _this.isTornDown = false;\n        var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? \"cache-first\" : _d;\n        var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e, \n        // Make sure we don't store \"standby\" as the initialFetchPolicy.\n        _f = options.initialFetchPolicy, \n        // Make sure we don't store \"standby\" as the initialFetchPolicy.\n        initialFetchPolicy = _f === void 0 ? fetchPolicy === \"standby\" ? defaultFetchPolicy : (fetchPolicy) : _f;\n        _this.options = __assign(__assign({}, options), { \n            // Remember the initial options.fetchPolicy so we can revert back to this\n            // policy when variables change. This information can also be specified\n            // (or overridden) by providing options.initialFetchPolicy explicitly.\n            initialFetchPolicy: initialFetchPolicy, \n            // This ensures this.options.fetchPolicy always has a string value, in\n            // case options.fetchPolicy was not provided.\n            fetchPolicy: fetchPolicy });\n        _this.queryId = queryInfo.queryId || queryManager.generateQueryId();\n        var opDef = getOperationDefinition(_this.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        return _this;\n    }\n    Object.defineProperty(ObservableQuery.prototype, \"query\", {\n        // The `query` computed property will always reflect the document transformed\n        // by the last run query. `this.options.query` will always reflect the raw\n        // untransformed query to ensure document transforms with runtime conditionals\n        // are run on the original document.\n        get: function () {\n            return this.lastQuery || this.options.query;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(ObservableQuery.prototype, \"variables\", {\n        // Computed shorthand for this.options.variables, preserved for\n        // backwards compatibility.\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            // TODO: this code doesn’t actually make sense insofar as the observer\n            // will never exist in this.observers due how zen-observable wraps observables.\n            // https://github.com/zenparsing/zen-observable/blob/master/src/Observable.js#L169\n            var observer = {\n                next: function (result) {\n                    resolve(result);\n                    // Stop the query within the QueryManager if we can before\n                    // this function returns.\n                    //\n                    // We do this in order to prevent observers piling up within\n                    // the QueryManager. Notice that we only fully unsubscribe\n                    // from the subscription in a setTimeout(..., 0)  call. This call can\n                    // actually be handled by the browser at a much later time. If queries\n                    // are fired in the meantime, observers that should have been removed\n                    // from the QueryManager will continue to fire, causing an unnecessary\n                    // performance hit.\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        // Use the last result as long as the variables match this.variables.\n        var lastResult = this.getLastResult(true);\n        var networkStatus = this.queryInfo.networkStatus ||\n            (lastResult && lastResult.networkStatus) ||\n            NetworkStatus.ready;\n        var result = __assign(__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });\n        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a;\n        if (\n        // These fetch policies should never deliver data from the cache, unless\n        // redelivering a previously delivered result.\n        skipCacheDataFor(fetchPolicy) ||\n            // If this.options.query has @client(always: true) fields, we cannot\n            // trust diff.result, since it was read from the cache without running\n            // local resolvers (and it's too late to run resolvers now, since we must\n            // return a result synchronously).\n            this.queryManager.getDocumentInfo(this.query).hasForcedResolvers) {\n            // Fall through.\n        }\n        else if (this.waitForOwnResult) {\n            // This would usually be a part of `QueryInfo.getDiff()`.\n            // which we skip in the waitForOwnResult case since we are not\n            // interested in the diff.\n            this.queryInfo[\"updateWatch\"]();\n        }\n        else {\n            var diff = this.queryInfo.getDiff();\n            if (diff.complete || this.options.returnPartialData) {\n                result.data = diff.result;\n            }\n            if (equal(result.data, {})) {\n                result.data = void 0;\n            }\n            if (diff.complete) {\n                // Similar to setting result.partial to false, but taking advantage of the\n                // falsiness of missing fields.\n                delete result.partial;\n                // If the diff is complete, and we're using a FetchPolicy that\n                // terminates after a complete cache read, we can assume the next result\n                // we receive will have NetworkStatus.ready and !loading.\n                if (diff.complete &&\n                    result.networkStatus === NetworkStatus.loading &&\n                    (fetchPolicy === \"cache-first\" || fetchPolicy === \"cache-only\")) {\n                    result.networkStatus = NetworkStatus.ready;\n                    result.loading = false;\n                }\n            }\n            else {\n                result.partial = true;\n            }\n            if (globalThis.__DEV__ !== false &&\n                !diff.complete &&\n                !this.options.partialRefetch &&\n                !result.loading &&\n                !result.data &&\n                !result.error) {\n                logMissingFieldErrors(diff.missing);\n            }\n        }\n        if (saveAsLastResult) {\n            this.updateLastResult(result);\n        }\n        return result;\n    };\n    // Compares newResult to the snapshot we took of this.lastResult when it was\n    // first received.\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {\n        if (!this.last) {\n            return true;\n        }\n        var resultIsDifferent = this.queryManager.getDocumentInfo(this.query).hasNonreactiveDirective ?\n            !equalByQuery(this.query, this.last.result, newResult, this.variables)\n            : !equal(this.last.result, newResult);\n        return (resultIsDifferent || (variables && !equal(this.last.variables, variables)));\n    };\n    ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {\n        var last = this.last;\n        if (last &&\n            last[key] &&\n            (!variablesMustMatch || equal(last.variables, this.variables))) {\n            return last[key];\n        }\n    };\n    ObservableQuery.prototype.getLastResult = function (variablesMustMatch) {\n        return this.getLast(\"result\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.getLastError = function (variablesMustMatch) {\n        return this.getLast(\"error\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.last;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        this.queryManager.resetErrors(this.queryId);\n    };\n    /**\n     * Update the variables of this observable query, and fetch the new results.\n     * This method should be preferred over `setVariables` in most use cases.\n     *\n     * @param variables - The new set of variables. If there are missing variables,\n     * the previous values of those variables will be used.\n     */\n    ObservableQuery.prototype.refetch = function (variables) {\n        var _a;\n        var reobserveOptions = {\n            // Always disable polling for refetches.\n            pollInterval: 0,\n        };\n        // Unless the provided fetchPolicy always consults the network\n        // (no-cache, network-only, or cache-and-network), override it with\n        // network-only to force the refetch for this fetchQuery call.\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === \"cache-and-network\") {\n            reobserveOptions.fetchPolicy = fetchPolicy;\n        }\n        else if (fetchPolicy === \"no-cache\") {\n            reobserveOptions.fetchPolicy = \"no-cache\";\n        }\n        else {\n            reobserveOptions.fetchPolicy = \"network-only\";\n        }\n        if (globalThis.__DEV__ !== false && variables && hasOwnProperty.call(variables, \"variables\")) {\n            var queryDef = getQueryDefinition(this.query);\n            var vars = queryDef.variableDefinitions;\n            if (!vars || !vars.some(function (v) { return v.variable.name.value === \"variables\"; })) {\n                globalThis.__DEV__ !== false && invariant.warn(\n                    20,\n                    variables,\n                    ((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || queryDef\n                );\n            }\n        }\n        if (variables && !equal(this.options.variables, variables)) {\n            // Update the existing options with new variables\n            reobserveOptions.variables = this.options.variables = __assign(__assign({}, this.options.variables), variables);\n        }\n        this.queryInfo.resetLastWrite();\n        return this.reobserve(reobserveOptions, NetworkStatus.refetch);\n    };\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : (__assign(__assign(__assign(__assign({}, this.options), { query: this.options.query }), fetchMoreOptions), { variables: __assign(__assign({}, this.options.variables), fetchMoreOptions.variables) })))), { \n            // The fetchMore request goes immediately to the network and does\n            // not automatically write its result to the cache (hence no-cache\n            // instead of network-only), because we allow the caller of\n            // fetchMore to provide an updateQuery callback that determines how\n            // the data gets written to the cache.\n            fetchPolicy: \"no-cache\" });\n        combinedOptions.query = this.transformDocument(combinedOptions.query);\n        var qid = this.queryManager.generateQueryId();\n        // If a temporary query is passed to `fetchMore`, we don't want to store\n        // it as the last query result since it may be an optimized query for\n        // pagination. We will however run the transforms on the original document\n        // as well as the document passed in `fetchMoreOptions` to ensure the cache\n        // uses the most up-to-date document which may rely on runtime conditionals.\n        this.lastQuery =\n            fetchMoreOptions.query ?\n                this.transformDocument(this.options.query)\n                : combinedOptions.query;\n        // Simulate a loading result for the original query with\n        // result.networkStatus === NetworkStatus.fetchMore.\n        var queryInfo = this.queryInfo;\n        var originalNetworkStatus = queryInfo.networkStatus;\n        queryInfo.networkStatus = NetworkStatus.fetchMore;\n        if (combinedOptions.notifyOnNetworkStatusChange) {\n            this.observe();\n        }\n        var updatedQuerySet = new Set();\n        return this.queryManager\n            .fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore)\n            .then(function (fetchMoreResult) {\n            _this.queryManager.removeQuery(qid);\n            if (queryInfo.networkStatus === NetworkStatus.fetchMore) {\n                queryInfo.networkStatus = originalNetworkStatus;\n            }\n            // Performing this cache update inside a cache.batch transaction ensures\n            // any affected cache.watch watchers are notified at most once about any\n            // updates. Most watchers will be using the QueryInfo class, which\n            // responds to notifications by calling reobserveCacheFirst to deliver\n            // fetchMore cache results back to this ObservableQuery.\n            _this.queryManager.cache.batch({\n                update: function (cache) {\n                    var updateQuery = fetchMoreOptions.updateQuery;\n                    if (updateQuery) {\n                        cache.updateQuery({\n                            query: _this.query,\n                            variables: _this.variables,\n                            returnPartialData: true,\n                            optimistic: false,\n                        }, function (previous) {\n                            return updateQuery(previous, {\n                                fetchMoreResult: fetchMoreResult.data,\n                                variables: combinedOptions.variables,\n                            });\n                        });\n                    }\n                    else {\n                        // If we're using a field policy instead of updateQuery, the only\n                        // thing we need to do is write the new data to the cache using\n                        // combinedOptions.variables (instead of this.variables, which is\n                        // what this.updateQuery uses, because it works by abusing the\n                        // original field value, keyed by the original variables).\n                        cache.writeQuery({\n                            query: combinedOptions.query,\n                            variables: combinedOptions.variables,\n                            data: fetchMoreResult.data,\n                        });\n                    }\n                },\n                onWatchUpdated: function (watch) {\n                    // Record the DocumentNode associated with any watched query whose\n                    // data were updated by the cache writes above.\n                    updatedQuerySet.add(watch.query);\n                },\n            });\n            return fetchMoreResult;\n        })\n            .finally(function () {\n            // In case the cache writes above did not generate a broadcast\n            // notification (which would have been intercepted by onWatchUpdated),\n            // likely because the written data were the same as what was already in\n            // the cache, we still want fetchMore to deliver its final loading:false\n            // result with the unchanged data.\n            if (!updatedQuerySet.has(_this.query)) {\n                reobserveCacheFirst(_this);\n            }\n        });\n    };\n    // XXX the subscription variables are separate from the query variables.\n    // if you want to update subscription variables, right now you have to do that separately,\n    // and you can only do it by stopping the subscription and then subscribing again with new variables.\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                globalThis.__DEV__ !== false && invariant.error(21, 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.silentSetOptions = function (newOptions) {\n        var mergedOptions = compact(this.options, newOptions || {});\n        assign(this.options, mergedOptions);\n    };\n    /**\n     * Update the variables of this observable query, and fetch the new results\n     * if they've changed. Most users should prefer `refetch` instead of\n     * `setVariables` in order to to be properly notified of results even when\n     * they come from the cache.\n     *\n     * Note: the `next` callback will *not* fire if the variables have not changed\n     * or if the result is coming from cache.\n     *\n     * Note: the promise will return the old results immediately if the variables\n     * have not changed.\n     *\n     * Note: the promise will return null immediately if the query is not active\n     * (there are no subscribers).\n     *\n     * @param variables - The new set of variables. If there are missing variables,\n     * the previous values of those variables will be used.\n     */\n    ObservableQuery.prototype.setVariables = function (variables) {\n        if (equal(this.variables, variables)) {\n            // If we have no observers, then we don't actually want to make a network\n            // request. As soon as someone observes the query, the request will kick\n            // off. For now, we just store any changes. (See #1077)\n            return this.observers.size ? this.result() : Promise.resolve();\n        }\n        this.options.variables = variables;\n        // See comment above\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        return this.reobserve({\n            // Reset options.fetchPolicy to its original value.\n            fetchPolicy: this.options.initialFetchPolicy,\n            variables: variables,\n        }, NetworkStatus.setVariables);\n    };\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var queryManager = this.queryManager;\n        var result = queryManager.cache.diff({\n            query: this.options.query,\n            variables: this.variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n        var newResult = mapFn(result, {\n            variables: this.variables,\n        });\n        if (newResult) {\n            queryManager.cache.writeQuery({\n                query: this.options.query,\n                data: newResult,\n                variables: this.variables,\n            });\n            queryManager.broadcastQueries();\n        }\n    };\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        this.options.pollInterval = pollInterval;\n        this.updatePolling();\n    };\n    ObservableQuery.prototype.stopPolling = function () {\n        this.options.pollInterval = 0;\n        this.updatePolling();\n    };\n    // Update options.fetchPolicy according to options.nextFetchPolicy.\n    ObservableQuery.prototype.applyNextFetchPolicy = function (reason, \n    // It's possible to use this method to apply options.nextFetchPolicy to\n    // options.fetchPolicy even if options !== this.options, though that happens\n    // most often when the options are temporary, used for only one request and\n    // then thrown away, so nextFetchPolicy may not end up mattering.\n    options) {\n        if (options.nextFetchPolicy) {\n            var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a, _b = options.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? fetchPolicy : _b;\n            if (fetchPolicy === \"standby\") {\n                // Do nothing, leaving options.fetchPolicy unchanged.\n            }\n            else if (typeof options.nextFetchPolicy === \"function\") {\n                // When someone chooses \"cache-and-network\" or \"network-only\" as their\n                // initial FetchPolicy, they often do not want future cache updates to\n                // trigger unconditional network requests, which is what repeatedly\n                // applying the \"cache-and-network\" or \"network-only\" policies would\n                // seem to imply. Instead, when the cache reports an update after the\n                // initial network request, it may be desirable for subsequent network\n                // requests to be triggered only if the cache result is incomplete. To\n                // that end, the options.nextFetchPolicy option provides an easy way to\n                // update options.fetchPolicy after the initial network request, without\n                // having to call observableQuery.setOptions.\n                options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {\n                    reason: reason,\n                    options: options,\n                    observable: this,\n                    initialFetchPolicy: initialFetchPolicy,\n                });\n            }\n            else if (reason === \"variables-changed\") {\n                options.fetchPolicy = initialFetchPolicy;\n            }\n            else {\n                options.fetchPolicy = options.nextFetchPolicy;\n            }\n        }\n        return options.fetchPolicy;\n    };\n    ObservableQuery.prototype.fetch = function (options, newNetworkStatus, query) {\n        // TODO Make sure we update the networkStatus (and infer fetchVariables)\n        // before actually committing to the fetch.\n        this.queryManager.setObservableQuery(this);\n        return this.queryManager[\"fetchConcastWithInfo\"](this.queryId, options, newNetworkStatus, query);\n    };\n    // Turns polling on or off based on this.options.pollInterval.\n    ObservableQuery.prototype.updatePolling = function () {\n        var _this = this;\n        // Avoid polling in SSR mode\n        if (this.queryManager.ssrMode) {\n            return;\n        }\n        var _a = this, pollingInfo = _a.pollingInfo, pollInterval = _a.options.pollInterval;\n        if (!pollInterval) {\n            if (pollingInfo) {\n                clearTimeout(pollingInfo.timeout);\n                delete this.pollingInfo;\n            }\n            return;\n        }\n        if (pollingInfo && pollingInfo.interval === pollInterval) {\n            return;\n        }\n        invariant(pollInterval, 22);\n        var info = pollingInfo || (this.pollingInfo = {});\n        info.interval = pollInterval;\n        var maybeFetch = function () {\n            if (_this.pollingInfo) {\n                if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus)) {\n                    _this.reobserve({\n                        // Most fetchPolicy options don't make sense to use in a polling context, as\n                        // users wouldn't want to be polling the cache directly. However, network-only and\n                        // no-cache are both useful for when the user wants to control whether or not the\n                        // polled results are written to the cache.\n                        fetchPolicy: _this.options.initialFetchPolicy === \"no-cache\" ?\n                            \"no-cache\"\n                            : \"network-only\",\n                    }, NetworkStatus.poll).then(poll, poll);\n                }\n                else {\n                    poll();\n                }\n            }\n        };\n        var poll = function () {\n            var info = _this.pollingInfo;\n            if (info) {\n                clearTimeout(info.timeout);\n                info.timeout = setTimeout(maybeFetch, info.interval);\n            }\n        };\n        poll();\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult, variables) {\n        if (variables === void 0) { variables = this.variables; }\n        var error = this.getLastError();\n        // Preserve this.last.error unless the variables have changed.\n        if (error && this.last && !equal(variables, this.last.variables)) {\n            error = void 0;\n        }\n        return (this.last = __assign({ result: this.queryManager.assumeImmutableResults ?\n                newResult\n                : cloneDeep(newResult), variables: variables }, (error ? { error: error } : null)));\n    };\n    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {\n        var _this = this;\n        this.isTornDown = false;\n        var useDisposableConcast = \n        // Refetching uses a disposable Concast to allow refetches using different\n        // options/variables, without permanently altering the options of the\n        // original ObservableQuery.\n        newNetworkStatus === NetworkStatus.refetch ||\n            // The fetchMore method does not actually call the reobserve method, but,\n            // if it did, it would definitely use a disposable Concast.\n            newNetworkStatus === NetworkStatus.fetchMore ||\n            // Polling uses a disposable Concast so the polling options (which force\n            // fetchPolicy to be \"network-only\" or \"no-cache\") won't override the original options.\n            newNetworkStatus === NetworkStatus.poll;\n        // Save the old variables, since Object.assign may modify them below.\n        var oldVariables = this.options.variables;\n        var oldFetchPolicy = this.options.fetchPolicy;\n        var mergedOptions = compact(this.options, newOptions || {});\n        var options = useDisposableConcast ?\n            // Disposable Concast fetches receive a shallow copy of this.options\n            // (merged with newOptions), leaving this.options unmodified.\n            mergedOptions\n            : assign(this.options, mergedOptions);\n        // Don't update options.query with the transformed query to avoid\n        // overwriting this.options.query when we aren't using a disposable concast.\n        // We want to ensure we can re-run the custom document transforms the next\n        // time a request is made against the original query.\n        var query = this.transformDocument(options.query);\n        this.lastQuery = query;\n        if (!useDisposableConcast) {\n            // We can skip calling updatePolling if we're not changing this.options.\n            this.updatePolling();\n            // Reset options.fetchPolicy to its original value when variables change,\n            // unless a new fetchPolicy was provided by newOptions.\n            if (newOptions &&\n                newOptions.variables &&\n                !equal(newOptions.variables, oldVariables) &&\n                // Don't mess with the fetchPolicy if it's currently \"standby\".\n                options.fetchPolicy !== \"standby\" &&\n                // If we're changing the fetchPolicy anyway, don't try to change it here\n                // using applyNextFetchPolicy. The explicit options.fetchPolicy wins.\n                options.fetchPolicy === oldFetchPolicy) {\n                this.applyNextFetchPolicy(\"variables-changed\", options);\n                if (newNetworkStatus === void 0) {\n                    newNetworkStatus = NetworkStatus.setVariables;\n                }\n            }\n        }\n        this.waitForOwnResult && (this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy));\n        var finishWaitingForOwnResult = function () {\n            if (_this.concast === concast) {\n                _this.waitForOwnResult = false;\n            }\n        };\n        var variables = options.variables && __assign({}, options.variables);\n        var _a = this.fetch(options, newNetworkStatus, query), concast = _a.concast, fromLink = _a.fromLink;\n        var observer = {\n            next: function (result) {\n                finishWaitingForOwnResult();\n                _this.reportResult(result, variables);\n            },\n            error: function (error) {\n                finishWaitingForOwnResult();\n                _this.reportError(error, variables);\n            },\n        };\n        if (!useDisposableConcast && (fromLink || !this.concast)) {\n            // We use the {add,remove}Observer methods directly to avoid wrapping\n            // observer with an unnecessary SubscriptionObserver object.\n            if (this.concast && this.observer) {\n                this.concast.removeObserver(this.observer);\n            }\n            this.concast = concast;\n            this.observer = observer;\n        }\n        concast.addObserver(observer);\n        return concast;\n    };\n    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {\n        return this.reobserveAsConcast(newOptions, newNetworkStatus)\n            .promise;\n    };\n    ObservableQuery.prototype.resubscribeAfterError = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        // If `lastError` is set in the current when the subscription is re-created,\n        // the subscription will immediately receive the error, which will\n        // cause it to terminate again. To avoid this, we first clear\n        // the last error/result from the `observableQuery` before re-starting\n        // the subscription, and restore the last value afterwards so that the\n        // subscription has a chance to stay open.\n        var last = this.last;\n        this.resetLastResults();\n        var subscription = this.subscribe.apply(this, args);\n        this.last = last;\n        return subscription;\n    };\n    // (Re)deliver the current result to this.observers without applying fetch\n    // policies or making network requests.\n    ObservableQuery.prototype.observe = function () {\n        this.reportResult(\n        // Passing false is important so that this.getCurrentResult doesn't\n        // save the fetchMore result as this.lastResult, causing it to be\n        // ignored due to the this.isDifferentFromLastResult check in\n        // this.reportResult.\n        this.getCurrentResult(false), this.variables);\n    };\n    ObservableQuery.prototype.reportResult = function (result, variables) {\n        var lastError = this.getLastError();\n        var isDifferent = this.isDifferentFromLastResult(result, variables);\n        // Update the last result even when isDifferentFromLastResult returns false,\n        // because the query may be using the @nonreactive directive, and we want to\n        // save the the latest version of any nonreactive subtrees (in case\n        // getCurrentResult is called), even though we skip broadcasting changes.\n        if (lastError || !result.partial || this.options.returnPartialData) {\n            this.updateLastResult(result, variables);\n        }\n        if (lastError || isDifferent) {\n            iterateObserversSafely(this.observers, \"next\", result);\n        }\n    };\n    ObservableQuery.prototype.reportError = function (error, variables) {\n        // Since we don't get the current result on errors, only the error, we\n        // must mirror the updates that occur in QueryStore.markQueryError here\n        var errorResult = __assign(__assign({}, this.getLastResult()), { error: error, errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false });\n        this.updateLastResult(errorResult, variables);\n        iterateObserversSafely(this.observers, \"error\", (this.last.error = error));\n    };\n    ObservableQuery.prototype.hasObservers = function () {\n        return this.observers.size > 0;\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        if (this.isTornDown)\n            return;\n        if (this.concast && this.observer) {\n            this.concast.removeObserver(this.observer);\n            delete this.concast;\n            delete this.observer;\n        }\n        this.stopPolling();\n        // stop all active GraphQL subscriptions\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    ObservableQuery.prototype.transformDocument = function (document) {\n        return this.queryManager.transform(document);\n    };\n    return ObservableQuery;\n}(Observable));\nexport { ObservableQuery };\n// Necessary because the ObservableQuery constructor has a different\n// signature than the Observable constructor.\nfixObservableSubclass(ObservableQuery);\n// Reobserve with fetchPolicy effectively set to \"cache-first\", triggering\n// delivery of any new data from the cache, possibly falling back to the network\n// if any cache data are missing. This allows _complete_ cache results to be\n// delivered without also kicking off unnecessary network requests when\n// this.options.fetchPolicy is \"cache-and-network\" or \"network-only\". When\n// this.options.fetchPolicy is any other policy (\"cache-first\", \"cache-only\",\n// \"standby\", or \"no-cache\"), we call this.reobserve() as usual.\nexport function reobserveCacheFirst(obsQuery) {\n    var _a = obsQuery.options, fetchPolicy = _a.fetchPolicy, nextFetchPolicy = _a.nextFetchPolicy;\n    if (fetchPolicy === \"cache-and-network\" || fetchPolicy === \"network-only\") {\n        return obsQuery.reobserve({\n            fetchPolicy: \"cache-first\",\n            // Use a temporary nextFetchPolicy function that replaces itself with the\n            // previous nextFetchPolicy value and returns the original fetchPolicy.\n            nextFetchPolicy: function (currentFetchPolicy, context) {\n                // Replace this nextFetchPolicy function in the options object with the\n                // original this.options.nextFetchPolicy value.\n                this.nextFetchPolicy = nextFetchPolicy;\n                // If the original nextFetchPolicy value was a function, give it a\n                // chance to decide what happens here.\n                if (typeof this.nextFetchPolicy === \"function\") {\n                    return this.nextFetchPolicy(currentFetchPolicy, context);\n                }\n                // Otherwise go back to the original this.options.fetchPolicy.\n                return fetchPolicy;\n            },\n        });\n    }\n    return obsQuery.reobserve();\n}\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    globalThis.__DEV__ !== false && invariant.error(23, error.message, error.stack);\n}\nexport function logMissingFieldErrors(missing) {\n    if (globalThis.__DEV__ !== false && missing) {\n        globalThis.__DEV__ !== false && invariant.debug(24, missing);\n    }\n}\nfunction skipCacheDataFor(fetchPolicy /* `undefined` would mean `\"cache-first\"` */) {\n    return (fetchPolicy === \"network-only\" ||\n        fetchPolicy === \"no-cache\" ||\n        fetchPolicy === \"standby\");\n}\n//# sourceMappingURL=ObservableQuery.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { invariant } from \"../utilities/globals/index.js\";\nimport { visit, BREAK, isSelectionNode } from \"graphql\";\nimport { argumentsObjectFromField, buildQueryFromSelectionSet, createFragmentMap, getFragmentDefinitions, getMainDefinition, hasDirectives, isField, isInlineFragment, mergeDeep, mergeDeepArray, removeClientSetsFromDocument, resultKeyNameFromField, shouldInclude, } from \"../utilities/index.js\";\nimport { cacheSlot } from \"../cache/index.js\";\nvar LocalState = /** @class */ (function () {\n    function LocalState(_a) {\n        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;\n        this.selectionsToResolveCache = new WeakMap();\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    // Run local client resolvers against the incoming query and remote data.\n    // Locally resolved field values are merged with the incoming remote data,\n    // and returned. Note that locally resolved fields will overwrite\n    // remote data using the same field name.\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 /*return*/, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (__assign(__assign({}, remoteResult), { data: localResult.result })); })];\n                }\n                return [2 /*return*/, 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    // Client queries contain everything in the incoming document (if a @client\n    // directive is found).\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    // Server queries are stripped of all @client based selection sets.\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            // Getting an entry's cache key is useful for local state resolvers.\n            getCacheKey: function (obj) {\n                return cache.identify(obj);\n            } });\n    };\n    // To support `@client @export(as: \"someVar\")` syntax, we'll first resolve\n    // @client @export fields locally, then pass the resolved values back to be\n    // used alongside the original operation variables.\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 /*return*/, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (__assign(__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2 /*return*/, __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    // Query the cache and return matching data.\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, selectionsToResolve, definitionOperation, defaultOperationType, _a, cache, client, execContext, isClientFieldDescendant;\n            return __generator(this, function (_b) {\n                mainDefinition = getMainDefinition(document);\n                fragments = getFragmentDefinitions(document);\n                fragmentMap = createFragmentMap(fragments);\n                selectionsToResolve = this.collectSelectionsToResolve(mainDefinition, fragmentMap);\n                definitionOperation = mainDefinition.operation;\n                defaultOperationType = definitionOperation ?\n                    definitionOperation.charAt(0).toUpperCase() +\n                        definitionOperation.slice(1)\n                    : \"Query\";\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: __assign(__assign({}, context), { cache: cache, client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    selectionsToResolve: selectionsToResolve,\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                isClientFieldDescendant = false;\n                return [2 /*return*/, this.resolveSelectionSet(mainDefinition.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, isClientFieldDescendant, 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 (!isClientFieldDescendant &&\n                            !execContext.selectionsToResolve.has(selection)) {\n                            // Skip selections without @client directives\n                            // (still processing if one of the ancestors or one of the child fields has @client directive)\n                            return [2 /*return*/];\n                        }\n                        if (!shouldInclude(selection, variables)) {\n                            // Skip this entirely.\n                            return [2 /*return*/];\n                        }\n                        if (isField(selection)) {\n                            return [2 /*return*/, this.resolveField(selection, isClientFieldDescendant, 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                            // This is a named fragment.\n                            fragment = fragmentMap[selection.name.value];\n                            invariant(fragment, 18, 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 /*return*/, this.resolveSelectionSet(fragment.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2 /*return*/];\n                    });\n                }); };\n                return [2 /*return*/, Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, isClientFieldDescendant, 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                if (!rootValue) {\n                    return [2 /*return*/, null];\n                }\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                // Usually all local resolvers are run when passing through here, but\n                // if we've specifically identified that we only want to run forced\n                // resolvers (that is, resolvers for fields marked with\n                // `@client(always: true)`), then we'll skip running non-forced resolvers.\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(\n                            // In case the resolve function accesses reactive variables,\n                            // set cacheSlot to the current cache instance.\n                            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 /*return*/, resultPromise.then(function (result) {\n                        var _a, _b;\n                        if (result === void 0) { result = defaultResult; }\n                        // If an @export directive is associated with the current field, store\n                        // the `as` export variable name and current result for later use.\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                        // Handle all scalar types here.\n                        if (!field.selectionSet) {\n                            return result;\n                        }\n                        // From here down, the field has a selection set, which means it's trying\n                        // to query a GraphQLObjectType.\n                        if (result == null) {\n                            // Basically any field in a GraphQL response can be null, or missing\n                            return result;\n                        }\n                        var isClientField = (_b = (_a = field.directives) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.name.value === \"client\"; })) !== null && _b !== void 0 ? _b : false;\n                        if (Array.isArray(result)) {\n                            return _this.resolveSubSelectedArray(field, isClientFieldDescendant || isClientField, result, execContext);\n                        }\n                        // Returned value is an object, and the query has a sub-selection. Recurse.\n                        if (field.selectionSet) {\n                            return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant || isClientField, result, execContext);\n                        }\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSubSelectedArray = function (field, isClientFieldDescendant, result, execContext) {\n        var _this = this;\n        return Promise.all(result.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            // This is a nested array, recurse.\n            if (Array.isArray(item)) {\n                return _this.resolveSubSelectedArray(field, isClientFieldDescendant, item, execContext);\n            }\n            // This is an object, run the selection set on it.\n            if (field.selectionSet) {\n                return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant, item, execContext);\n            }\n        }));\n    };\n    // Collect selection nodes on paths from document root down to all @client directives.\n    // This function takes into account transitive fragment spreads.\n    // Complexity equals to a single `visit` over the full document.\n    LocalState.prototype.collectSelectionsToResolve = function (mainDefinition, fragmentMap) {\n        var isSingleASTNode = function (node) { return !Array.isArray(node); };\n        var selectionsToResolveCache = this.selectionsToResolveCache;\n        function collectByDefinition(definitionNode) {\n            if (!selectionsToResolveCache.has(definitionNode)) {\n                var matches_1 = new Set();\n                selectionsToResolveCache.set(definitionNode, matches_1);\n                visit(definitionNode, {\n                    Directive: function (node, _, __, ___, ancestors) {\n                        if (node.name.value === \"client\") {\n                            ancestors.forEach(function (node) {\n                                if (isSingleASTNode(node) && isSelectionNode(node)) {\n                                    matches_1.add(node);\n                                }\n                            });\n                        }\n                    },\n                    FragmentSpread: function (spread, _, __, ___, ancestors) {\n                        var fragment = fragmentMap[spread.name.value];\n                        invariant(fragment, 19, spread.name.value);\n                        var fragmentSelections = collectByDefinition(fragment);\n                        if (fragmentSelections.size > 0) {\n                            // Fragment for this spread contains @client directive (either directly or transitively)\n                            // Collect selection nodes on paths from the root down to fields with the @client directive\n                            ancestors.forEach(function (node) {\n                                if (isSingleASTNode(node) && isSelectionNode(node)) {\n                                    matches_1.add(node);\n                                }\n                            });\n                            matches_1.add(spread);\n                            fragmentSelections.forEach(function (selection) {\n                                matches_1.add(selection);\n                            });\n                        }\n                    },\n                });\n            }\n            return selectionsToResolveCache.get(definitionNode);\n        }\n        return collectByDefinition(mainDefinition);\n    };\n    return LocalState;\n}());\nexport { LocalState };\n//# sourceMappingURL=LocalState.js.map","import { __assign } from \"tslib\";\nimport { equal } from \"@wry/equality\";\nimport { DeepMerger } from \"../utilities/index.js\";\nimport { mergeIncrementalData } from \"../utilities/index.js\";\nimport { reobserveCacheFirst } from \"./ObservableQuery.js\";\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, \n            // The %1e15 allows the count to wrap around to 0 safely every\n            // quadrillion evictions, so there's no risk of overflow. To be\n            // clear, this is more of a pedantic principle than something\n            // that matters in any conceivable practical scenario.\n            (destructiveMethodCounts.get(cache) + 1) % 1e15);\n            // @ts-expect-error this is just too generic to be typed correctly\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}\n// A QueryInfo object represents a single query managed by the\n// QueryManager, which tracks all QueryInfo objects by queryId in its\n// this.queries Map. QueryInfo objects store the latest results and errors\n// for the given query, and are responsible for reporting those results to\n// the corresponding ObservableQuery, via the QueryInfo.notify method.\n// Results are reported asynchronously whenever setDiff marks the\n// QueryInfo object as dirty, though a call to the QueryManager's\n// broadcastQueries method may trigger the notification before it happens\n// automatically. This class used to be a simple interface type without\n// any field privacy or meaningful methods, which is why it still has so\n// many public fields. The effort to lock down and simplify the QueryInfo\n// interface is ongoing, and further improvements are welcome.\nvar QueryInfo = /** @class */ (function () {\n    function QueryInfo(queryManager, queryId) {\n        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }\n        this.queryId = queryId;\n        this.listeners = new Set();\n        this.document = null;\n        this.lastRequestId = 1;\n        this.stopped = false;\n        this.dirty = false;\n        this.observableQuery = null;\n        var cache = (this.cache = queryManager.cache);\n        // Track how often cache.evict is called, since we want eviction to\n        // override the feud-stopping logic in the markResult method, by\n        // causing shouldWrite to return true. Wrapping the cache.evict method\n        // is a bit of a hack, but it saves us from having to make eviction\n        // counting an official part of the ApolloCache API.\n        if (!destructiveMethodCounts.has(cache)) {\n            destructiveMethodCounts.set(cache, 0);\n            wrapDestructiveCacheMethod(cache, \"evict\");\n            wrapDestructiveCacheMethod(cache, \"modify\");\n            wrapDestructiveCacheMethod(cache, \"reset\");\n        }\n    }\n    QueryInfo.prototype.init = function (query) {\n        var networkStatus = query.networkStatus || NetworkStatus.loading;\n        if (this.variables &&\n            this.networkStatus !== NetworkStatus.loading &&\n            !equal(this.variables, query.variables)) {\n            networkStatus = NetworkStatus.setVariables;\n        }\n        if (!equal(query.variables, this.variables)) {\n            this.lastDiff = void 0;\n        }\n        Object.assign(this, {\n            document: query.document,\n            variables: query.variables,\n            networkError: null,\n            graphQLErrors: this.graphQLErrors || [],\n            networkStatus: networkStatus,\n        });\n        if (query.observableQuery) {\n            this.setObservableQuery(query.observableQuery);\n        }\n        if (query.lastRequestId) {\n            this.lastRequestId = query.lastRequestId;\n        }\n        return this;\n    };\n    QueryInfo.prototype.reset = function () {\n        cancelNotifyTimeout(this);\n        this.dirty = false;\n    };\n    QueryInfo.prototype.getDiff = function () {\n        var options = this.getDiffOptions();\n        if (this.lastDiff && equal(options, this.lastDiff.options)) {\n            return this.lastDiff.diff;\n        }\n        this.updateWatch(this.variables);\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return { complete: false };\n        }\n        var diff = this.cache.diff(options);\n        this.updateLastDiff(diff, options);\n        return diff;\n    };\n    QueryInfo.prototype.updateLastDiff = function (diff, options) {\n        this.lastDiff =\n            diff ?\n                {\n                    diff: diff,\n                    options: options || this.getDiffOptions(),\n                }\n                : void 0;\n    };\n    QueryInfo.prototype.getDiffOptions = function (variables) {\n        var _a;\n        if (variables === void 0) { variables = this.variables; }\n        return {\n            query: this.document,\n            variables: variables,\n            returnPartialData: true,\n            optimistic: true,\n            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,\n        };\n    };\n    QueryInfo.prototype.setDiff = function (diff) {\n        var _this = this;\n        var oldDiff = this.lastDiff && this.lastDiff.diff;\n        this.updateLastDiff(diff);\n        if (!this.dirty && !equal(oldDiff && oldDiff.result, diff && diff.result)) {\n            this.dirty = true;\n            if (!this.notifyTimeout) {\n                this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);\n            }\n        }\n    };\n    QueryInfo.prototype.setObservableQuery = function (oq) {\n        var _this = this;\n        if (oq === this.observableQuery)\n            return;\n        if (this.oqListener) {\n            this.listeners.delete(this.oqListener);\n        }\n        this.observableQuery = oq;\n        if (oq) {\n            oq[\"queryInfo\"] = this;\n            this.listeners.add((this.oqListener = function () {\n                var diff = _this.getDiff();\n                if (diff.fromOptimisticTransaction) {\n                    // If this diff came from an optimistic transaction, deliver the\n                    // current cache data to the ObservableQuery, but don't perform a\n                    // reobservation, since oq.reobserveCacheFirst might make a network\n                    // request, and we never want to trigger network requests in the\n                    // middle of optimistic updates.\n                    oq[\"observe\"]();\n                }\n                else {\n                    // Otherwise, make the ObservableQuery \"reobserve\" the latest data\n                    // using a temporary fetch policy of \"cache-first\", so complete cache\n                    // results have a chance to be delivered without triggering additional\n                    // network requests, even when options.fetchPolicy is \"network-only\"\n                    // or \"cache-and-network\". All other fetch policies are preserved by\n                    // this method, and are handled by calling oq.reobserve(). If this\n                    // reobservation is spurious, isDifferentFromLastResult still has a\n                    // chance to catch it before delivery to ObservableQuery subscribers.\n                    reobserveCacheFirst(oq);\n                }\n            }));\n        }\n        else {\n            delete this.oqListener;\n        }\n    };\n    QueryInfo.prototype.notify = function () {\n        var _this = this;\n        cancelNotifyTimeout(this);\n        if (this.shouldNotify()) {\n            this.listeners.forEach(function (listener) { return listener(_this); });\n        }\n        this.dirty = false;\n    };\n    QueryInfo.prototype.shouldNotify = function () {\n        if (!this.dirty || !this.listeners.size) {\n            return false;\n        }\n        if (isNetworkRequestInFlight(this.networkStatus) && this.observableQuery) {\n            var fetchPolicy = this.observableQuery.options.fetchPolicy;\n            if (fetchPolicy !== \"cache-only\" && 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            // Cancel the pending notify timeout\n            this.reset();\n            this.cancel();\n            // Revert back to the no-op version of cancel inherited from\n            // QueryInfo.prototype.\n            this.cancel = QueryInfo.prototype.cancel;\n            var oq = this.observableQuery;\n            if (oq)\n                oq.stopPolling();\n        }\n    };\n    // This method is a no-op by default, until/unless overridden by the\n    // updateWatch method.\n    QueryInfo.prototype.cancel = function () { };\n    QueryInfo.prototype.updateWatch = function (variables) {\n        var _this = this;\n        if (variables === void 0) { variables = this.variables; }\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return;\n        }\n        var watchOptions = __assign(__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });\n        if (!this.lastWatch || !equal(watchOptions, this.lastWatch)) {\n            this.cancel();\n            this.cancel = this.cache.watch((this.lastWatch = watchOptions));\n        }\n    };\n    QueryInfo.prototype.resetLastWrite = function () {\n        this.lastWrite = void 0;\n    };\n    QueryInfo.prototype.shouldWrite = function (result, variables) {\n        var lastWrite = this.lastWrite;\n        return !(lastWrite &&\n            // If cache.evict has been called since the last time we wrote this\n            // data into the cache, there's a chance writing this result into\n            // the cache will repair what was evicted.\n            lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&\n            equal(variables, lastWrite.variables) &&\n            equal(result.data, lastWrite.result.data));\n    };\n    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {\n        var _this = this;\n        var merger = new DeepMerger();\n        var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];\n        // Cancel the pending notify timeout (if it exists) to prevent extraneous network\n        // requests. To allow future notify timeouts, diff and dirty are reset as well.\n        this.reset();\n        if (\"incremental\" in result && isNonEmptyArray(result.incremental)) {\n            var mergedData = mergeIncrementalData(this.getDiff().result, result);\n            result.data = mergedData;\n            // Detect the first chunk of a deferred query and merge it with existing\n            // cache data. This ensures a `cache-first` fetch policy that returns\n            // partial cache data or a `cache-and-network` fetch policy that already\n            // has full data in the cache does not complain when trying to merge the\n            // initial deferred server data with existing cache data.\n        }\n        else if (\"hasNext\" in result && result.hasNext) {\n            var diff = this.getDiff();\n            result.data = merger.merge(diff.result, result.data);\n        }\n        this.graphQLErrors = graphQLErrors;\n        if (options.fetchPolicy === \"no-cache\") {\n            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));\n        }\n        else if (cacheWriteBehavior !== 0 /* CacheWriteBehavior.FORBID */) {\n            if (shouldWriteResult(result, options.errorPolicy)) {\n                // Using a transaction here so we have a chance to read the result\n                // back from the cache before the watch callback fires as a result\n                // of writeQuery, so we can store the new diff quietly and ignore\n                // it when we receive it redundantly from the watch callback.\n                this.cache.performTransaction(function (cache) {\n                    if (_this.shouldWrite(result, options.variables)) {\n                        cache.writeQuery({\n                            query: document,\n                            data: result.data,\n                            variables: options.variables,\n                            overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,\n                        });\n                        _this.lastWrite = {\n                            result: result,\n                            variables: options.variables,\n                            dmCount: destructiveMethodCounts.get(_this.cache),\n                        };\n                    }\n                    else {\n                        // If result is the same as the last result we received from\n                        // the network (and the variables match too), avoid writing\n                        // result into the cache again. The wisdom of skipping this\n                        // cache write is far from obvious, since any cache write\n                        // could be the one that puts the cache back into a desired\n                        // state, fixing corruption or missing data. However, if we\n                        // always write every network result into the cache, we enable\n                        // feuds between queries competing to update the same data in\n                        // incompatible ways, which can lead to an endless cycle of\n                        // cache broadcasts and useless network requests. As with any\n                        // feud, eventually one side must step back from the brink,\n                        // letting the other side(s) have the last word(s). There may\n                        // be other points where we could break this cycle, such as\n                        // silencing the broadcast for cache.writeQuery (not a good\n                        // idea, since it just delays the feud a bit) or somehow\n                        // avoiding the network request that just happened (also bad,\n                        // because the server could return useful new data). All\n                        // options considered, skipping this cache write seems to be\n                        // the least damaging place to break the cycle, because it\n                        // reflects the intuition that we recently wrote this exact\n                        // result into the cache, so the cache *should* already/still\n                        // contain this data. If some other query has clobbered that\n                        // data in the meantime, that's too bad, but there will be no\n                        // winners if every query blindly reverts to its own version\n                        // of the data. This approach also gives the network a chance\n                        // to return new data, which will be written into the cache as\n                        // usual, notifying only those queries that are directly\n                        // affected by the cache updates, as usual. In the future, an\n                        // even more sophisticated cache could perhaps prevent or\n                        // mitigate the clobbering somehow, but that would make this\n                        // particular cache write even less important, and thus\n                        // skipping it would be even safer than it is today.\n                        if (_this.lastDiff && _this.lastDiff.diff.complete) {\n                            // Reuse data from the last good (complete) diff that we\n                            // received, when possible.\n                            result.data = _this.lastDiff.diff.result;\n                            return;\n                        }\n                        // If the previous this.diff was incomplete, fall through to\n                        // re-reading the latest data with cache.diff, below.\n                    }\n                    var diffOptions = _this.getDiffOptions(options.variables);\n                    var diff = cache.diff(diffOptions);\n                    // In case the QueryManager stops this QueryInfo before its\n                    // results are delivered, it's important to avoid restarting the\n                    // cache watch when markResult is called. We also avoid updating\n                    // the watch if we are writing a result that doesn't match the current\n                    // variables to avoid race conditions from broadcasting the wrong\n                    // result.\n                    if (!_this.stopped && equal(_this.variables, options.variables)) {\n                        // Any time we're about to update this.diff, we need to make\n                        // sure we've started watching the cache.\n                        _this.updateWatch(options.variables);\n                    }\n                    // If we're allowed to write to the cache, and we can read a\n                    // complete result from the cache, update result.data to be the\n                    // result from the cache, rather than the raw network result.\n                    // Set without setDiff to avoid triggering a notify call, since\n                    // we have other ways of notifying for this result.\n                    _this.updateLastDiff(diff, diffOptions);\n                    if (diff.complete) {\n                        result.data = diff.result;\n                    }\n                });\n            }\n            else {\n                this.lastWrite = void 0;\n            }\n        }\n    };\n    QueryInfo.prototype.markReady = function () {\n        this.networkError = null;\n        return (this.networkStatus = NetworkStatus.ready);\n    };\n    QueryInfo.prototype.markError = function (error) {\n        this.networkStatus = NetworkStatus.error;\n        this.lastWrite = void 0;\n        this.reset();\n        if (error.graphQLErrors) {\n            this.graphQLErrors = error.graphQLErrors;\n        }\n        if (error.networkError) {\n            this.networkError = error.networkError;\n        }\n        return error;\n    };\n    return QueryInfo;\n}());\nexport { QueryInfo };\nexport function shouldWriteResult(result, errorPolicy) {\n    if (errorPolicy === void 0) { errorPolicy = \"none\"; }\n    var ignoreErrors = errorPolicy === \"ignore\" || 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, newInvariantError } from \"../utilities/globals/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { execute } from \"../link/core/index.js\";\nimport { hasDirectives, isExecutionPatchIncrementalResult, isExecutionPatchResult, removeDirectivesFromDocument, } from \"../utilities/index.js\";\nimport { canonicalStringify } from \"../cache/index.js\";\nimport { getDefaultValues, getOperationDefinition, getOperationName, hasClientExports, graphQLResultHasError, getGraphQLErrorsFromResult, canUseWeakMap, Observable, asyncMap, isNonEmptyArray, Concast, makeUniqueId, isDocumentNode, isNonNullObject, DocumentTransform, } from \"../utilities/index.js\";\nimport { mergeIncrementalData } from \"../utilities/common/incrementalResult.js\";\nimport { ApolloError, isApolloError, graphQLResultHasProtocolErrors, } from \"../errors/index.js\";\nimport { ObservableQuery, logMissingFieldErrors } from \"./ObservableQuery.js\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { LocalState } from \"./LocalState.js\";\nimport { QueryInfo, shouldWriteResult, } from \"./QueryInfo.js\";\nimport { PROTOCOL_ERRORS_SYMBOL } from \"../errors/index.js\";\nimport { print } from \"../utilities/index.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar QueryManager = /** @class */ (function () {\n    function QueryManager(_a) {\n        var cache = _a.cache, link = _a.link, defaultOptions = _a.defaultOptions, documentTransform = _a.documentTransform, _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, _e = _a.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? !!cache.assumeImmutableResults : _e;\n        var _this = this;\n        this.clientAwareness = {};\n        // All the queries that the QueryManager is currently managing (not\n        // including mutations and subscriptions).\n        this.queries = new Map();\n        // Maps from queryId strings to Promise rejection functions for\n        // currently active queries and fetches.\n        // Use protected instead of private field so\n        // @apollo/experimental-nextjs-app-support can access type info.\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        // Use protected instead of private field so\n        // @apollo/experimental-nextjs-app-support can access type info.\n        this.inFlightLinkObservables = new Map();\n        var defaultDocumentTransform = new DocumentTransform(function (document) { return _this.cache.transformDocument(document); }, \n        // Allow the apollo cache to manage its own transform caches\n        { cache: false });\n        this.cache = cache;\n        this.link = link;\n        this.defaultOptions = defaultOptions || Object.create(null);\n        this.queryDeduplication = queryDeduplication;\n        this.clientAwareness = clientAwareness;\n        this.localState = localState || new LocalState({ cache: cache });\n        this.ssrMode = ssrMode;\n        this.assumeImmutableResults = assumeImmutableResults;\n        this.documentTransform =\n            documentTransform ?\n                defaultDocumentTransform\n                    .concat(documentTransform)\n                    // The custom document transform may add new fragment spreads or new\n                    // field selections, so we want to give the cache a chance to run\n                    // again. For example, the InMemoryCache adds __typename to field\n                    // selections and fragments from the fragment registry.\n                    .concat(defaultDocumentTransform)\n                : defaultDocumentTransform;\n        if ((this.onBroadcast = onBroadcast)) {\n            this.mutationStore = Object.create(null);\n        }\n    }\n    /**\n     * Call this method to terminate any active query processes, making it safe\n     * to dispose of this QueryManager instance.\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(newInvariantError(25));\n    };\n    QueryManager.prototype.cancelPendingFetches = function (error) {\n        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });\n        this.fetchCancelFns.clear();\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        var _b, _c;\n        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueries = _a.updateQueries, _d = _a.refetchQueries, refetchQueries = _d === void 0 ? [] : _d, _e = _a.awaitRefetchQueries, awaitRefetchQueries = _e === void 0 ? false : _e, updateWithProxyFn = _a.update, onQueryUpdated = _a.onQueryUpdated, _f = _a.fetchPolicy, fetchPolicy = _f === void 0 ? ((_b = this.defaultOptions.mutate) === null || _b === void 0 ? void 0 : _b.fetchPolicy) || \"network-only\" : _f, _g = _a.errorPolicy, errorPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.errorPolicy) || \"none\" : _g, keepRootFields = _a.keepRootFields, context = _a.context;\n        return __awaiter(this, void 0, void 0, function () {\n            var mutationId, hasClientExports, mutationStoreValue, self;\n            return __generator(this, function (_h) {\n                switch (_h.label) {\n                    case 0:\n                        invariant(mutation, 26);\n                        invariant(fetchPolicy === \"network-only\" || fetchPolicy === \"no-cache\", 27);\n                        mutationId = this.generateMutationId();\n                        mutation = this.cache.transformForLink(this.transform(mutation));\n                        hasClientExports = this.getDocumentInfo(mutation).hasClientExports;\n                        variables = this.getVariables(mutation, variables);\n                        if (!hasClientExports) return [3 /*break*/, 2];\n                        return [4 /*yield*/, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = (_h.sent());\n                        _h.label = 2;\n                    case 2:\n                        mutationStoreValue = this.mutationStore &&\n                            (this.mutationStore[mutationId] = {\n                                mutation: mutation,\n                                variables: variables,\n                                loading: true,\n                                error: null,\n                            });\n                        if (optimisticResponse) {\n                            this.markMutationOptimistic(optimisticResponse, {\n                                mutationId: mutationId,\n                                document: mutation,\n                                variables: variables,\n                                fetchPolicy: fetchPolicy,\n                                errorPolicy: errorPolicy,\n                                context: context,\n                                updateQueries: updateQueries,\n                                update: updateWithProxyFn,\n                                keepRootFields: keepRootFields,\n                            });\n                        }\n                        this.broadcastQueries();\n                        self = this;\n                        return [2 /*return*/, new Promise(function (resolve, reject) {\n                                return asyncMap(self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false), function (result) {\n                                    if (graphQLResultHasError(result) && errorPolicy === \"none\") {\n                                        throw new ApolloError({\n                                            graphQLErrors: getGraphQLErrorsFromResult(result),\n                                        });\n                                    }\n                                    if (mutationStoreValue) {\n                                        mutationStoreValue.loading = false;\n                                        mutationStoreValue.error = null;\n                                    }\n                                    var storeResult = __assign({}, result);\n                                    if (typeof refetchQueries === \"function\") {\n                                        refetchQueries = refetchQueries(storeResult);\n                                    }\n                                    if (errorPolicy === \"ignore\" && graphQLResultHasError(storeResult)) {\n                                        delete storeResult.errors;\n                                    }\n                                    return self.markMutationResult({\n                                        mutationId: mutationId,\n                                        result: storeResult,\n                                        document: mutation,\n                                        variables: variables,\n                                        fetchPolicy: fetchPolicy,\n                                        errorPolicy: errorPolicy,\n                                        context: context,\n                                        update: updateWithProxyFn,\n                                        updateQueries: updateQueries,\n                                        awaitRefetchQueries: awaitRefetchQueries,\n                                        refetchQueries: refetchQueries,\n                                        removeOptimistic: optimisticResponse ? mutationId : void 0,\n                                        onQueryUpdated: onQueryUpdated,\n                                        keepRootFields: keepRootFields,\n                                    });\n                                }).subscribe({\n                                    next: function (storeResult) {\n                                        self.broadcastQueries();\n                                        // Since mutations might receive multiple payloads from the\n                                        // ApolloLink chain (e.g. when used with @defer),\n                                        // we resolve with a SingleExecutionResult or after the final\n                                        // ExecutionPatchResult has arrived and we have assembled the\n                                        // multipart response into a single result.\n                                        if (!(\"hasNext\" in storeResult) || storeResult.hasNext === false) {\n                                            resolve(storeResult);\n                                        }\n                                    },\n                                    error: function (err) {\n                                        if (mutationStoreValue) {\n                                            mutationStoreValue.loading = false;\n                                            mutationStoreValue.error = err;\n                                        }\n                                        if (optimisticResponse) {\n                                            self.cache.removeOptimistic(mutationId);\n                                        }\n                                        self.broadcastQueries();\n                                        reject(err instanceof ApolloError ? err : (new ApolloError({\n                                            networkError: err,\n                                        })));\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.markMutationResult = function (mutation, cache) {\n        var _this = this;\n        if (cache === void 0) { cache = this.cache; }\n        var result = mutation.result;\n        var cacheWrites = [];\n        var skipCache = mutation.fetchPolicy === \"no-cache\";\n        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {\n            if (!isExecutionPatchIncrementalResult(result)) {\n                cacheWrites.push({\n                    result: result.data,\n                    dataId: \"ROOT_MUTATION\",\n                    query: mutation.document,\n                    variables: mutation.variables,\n                });\n            }\n            if (isExecutionPatchIncrementalResult(result) &&\n                isNonEmptyArray(result.incremental)) {\n                var diff = cache.diff({\n                    id: \"ROOT_MUTATION\",\n                    // The cache complains if passed a mutation where it expects a\n                    // query, so we transform mutations and subscriptions to queries\n                    // (only once, thanks to this.transformCache).\n                    query: this.getDocumentInfo(mutation.document).asQuery,\n                    variables: mutation.variables,\n                    optimistic: false,\n                    returnPartialData: true,\n                });\n                var mergedData = void 0;\n                if (diff.result) {\n                    mergedData = mergeIncrementalData(diff.result, result);\n                }\n                if (typeof mergedData !== \"undefined\") {\n                    // cast the ExecutionPatchResult to FetchResult here since\n                    // ExecutionPatchResult never has `data` when returned from the server\n                    result.data = mergedData;\n                    cacheWrites.push({\n                        result: mergedData,\n                        dataId: \"ROOT_MUTATION\",\n                        query: mutation.document,\n                        variables: mutation.variables,\n                    });\n                }\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                    // Read the current query result from the store.\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                        // Run our reducer using the current query result and the mutation result.\n                        var nextQueryResult = updater(currentQueryResult, {\n                            mutationResult: result,\n                            queryName: (document && getOperationName(document)) || void 0,\n                            queryVariables: variables,\n                        });\n                        // Write the modified result back into the store if we got a new result.\n                        if (nextQueryResult) {\n                            cacheWrites.push({\n                                result: nextQueryResult,\n                                dataId: \"ROOT_QUERY\",\n                                query: document,\n                                variables: variables,\n                            });\n                        }\n                    }\n                });\n            }\n        }\n        if (cacheWrites.length > 0 ||\n            mutation.refetchQueries ||\n            mutation.update ||\n            mutation.onQueryUpdated ||\n            mutation.removeOptimistic) {\n            var results_1 = [];\n            this.refetchQueries({\n                updateCache: function (cache) {\n                    if (!skipCache) {\n                        cacheWrites.forEach(function (write) { return cache.write(write); });\n                    }\n                    // If the mutation has some writes associated with it then we need to\n                    // apply those writes to the store by running this reducer again with\n                    // a write action.\n                    var update = mutation.update;\n                    // Determine whether result is a SingleExecutionResult,\n                    // or the final ExecutionPatchResult.\n                    var isFinalResult = !isExecutionPatchResult(result) ||\n                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);\n                    if (update) {\n                        if (!skipCache) {\n                            // Re-read the ROOT_MUTATION data we just wrote into the cache\n                            // (the first cache.write call in the cacheWrites.forEach loop\n                            // above), so field read functions have a chance to run for\n                            // fields within mutation result objects.\n                            var diff = cache.diff({\n                                id: \"ROOT_MUTATION\",\n                                // The cache complains if passed a mutation where it expects a\n                                // query, so we transform mutations and subscriptions to queries\n                                // (only once, thanks to this.transformCache).\n                                query: _this.getDocumentInfo(mutation.document).asQuery,\n                                variables: mutation.variables,\n                                optimistic: false,\n                                returnPartialData: true,\n                            });\n                            if (diff.complete) {\n                                result = __assign(__assign({}, result), { data: diff.result });\n                                if (\"incremental\" in result) {\n                                    delete result.incremental;\n                                }\n                                if (\"hasNext\" in result) {\n                                    delete result.hasNext;\n                                }\n                            }\n                        }\n                        // If we've received the whole response,\n                        // either a SingleExecutionResult or the final ExecutionPatchResult,\n                        // call the update function.\n                        if (isFinalResult) {\n                            update(cache, result, {\n                                context: mutation.context,\n                                variables: mutation.variables,\n                            });\n                        }\n                    }\n                    // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it\n                    // shallow to allow rolling back optimistic evictions.\n                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {\n                        cache.modify({\n                            id: \"ROOT_MUTATION\",\n                            fields: function (value, _a) {\n                                var fieldName = _a.fieldName, DELETE = _a.DELETE;\n                                return fieldName === \"__typename\" ? value : DELETE;\n                            },\n                        });\n                    }\n                },\n                include: mutation.refetchQueries,\n                // Write the final mutation.result to the root layer of the cache.\n                optimistic: false,\n                // Remove the corresponding optimistic layer at the same time as we\n                // write the final non-optimistic result.\n                removeOptimistic: mutation.removeOptimistic,\n                // Let the caller of client.mutate optionally determine the refetching\n                // behavior for watched queries after the mutation.update function runs.\n                // If no onQueryUpdated function was provided for this mutation, pass\n                // null instead of undefined to disable the default refetching behavior.\n                onQueryUpdated: mutation.onQueryUpdated || null,\n            }).forEach(function (result) { return results_1.push(result); });\n            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {\n                // Returning a promise here makes the mutation await that promise, so we\n                // include results in that promise's work if awaitRefetchQueries or an\n                // onQueryUpdated function was specified.\n                return Promise.all(results_1).then(function () { return result; });\n            }\n        }\n        return Promise.resolve(result);\n    };\n    QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {\n        var _this = this;\n        var data = typeof optimisticResponse === \"function\" ?\n            optimisticResponse(mutation.variables)\n            : optimisticResponse;\n        return this.cache.recordOptimisticTransaction(function (cache) {\n            try {\n                _this.markMutationResult(__assign(__assign({}, mutation), { result: { data: data } }), cache);\n            }\n            catch (error) {\n                globalThis.__DEV__ !== false && invariant.error(error);\n            }\n        }, mutation.mutationId);\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {\n        return this.fetchConcastWithInfo(queryId, options, networkStatus).concast\n            .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        return this.documentTransform.transformDocument(document);\n    };\n    QueryManager.prototype.getDocumentInfo = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var cacheEntry = {\n                // TODO These three calls (hasClientExports, shouldForceResolvers, and\n                // usesNonreactiveDirective) are performing independent full traversals\n                // of the transformed document. We should consider merging these\n                // traversals into a single pass in the future, though the work is\n                // cached after the first time.\n                hasClientExports: hasClientExports(document),\n                hasForcedResolvers: this.localState.shouldForceResolvers(document),\n                hasNonreactiveDirective: hasDirectives([\"nonreactive\"], document),\n                clientQuery: this.localState.clientQuery(document),\n                serverQuery: removeDirectivesFromDocument([\n                    { name: \"client\", remove: true },\n                    { name: \"connection\" },\n                    { name: \"nonreactive\" },\n                ], document),\n                defaultVars: getDefaultValues(getOperationDefinition(document)),\n                // Transform any mutation or subscription operations to query operations\n                // so we can read/write them from/to the cache.\n                asQuery: __assign(__assign({}, document), { definitions: document.definitions.map(function (def) {\n                        if (def.kind === \"OperationDefinition\" &&\n                            def.operation !== \"query\") {\n                            return __assign(__assign({}, def), { operation: \"query\" });\n                        }\n                        return def;\n                    }) }),\n            };\n            transformCache.set(document, cacheEntry);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return __assign(__assign({}, this.getDocumentInfo(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options) {\n        var query = this.transform(options.query);\n        // assign variable default values if supplied\n        // NOTE: We don't modify options.query here with the transformed query to\n        // ensure observable.options.query is set to the raw untransformed query.\n        options = __assign(__assign({}, options), { variables: this.getVariables(query, options.variables) });\n        if (typeof options.notifyOnNetworkStatusChange === \"undefined\") {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var queryInfo = new QueryInfo(this);\n        var observable = new ObservableQuery({\n            queryManager: this,\n            queryInfo: queryInfo,\n            options: options,\n        });\n        observable[\"lastQuery\"] = query;\n        this.queries.set(observable.queryId, queryInfo);\n        // We give queryInfo the transformed query to ensure the first cache diff\n        // uses the transformed query instead of the raw query\n        queryInfo.init({\n            document: query,\n            observableQuery: observable,\n            variables: observable.variables,\n        });\n        return observable;\n    };\n    QueryManager.prototype.query = function (options, queryId) {\n        var _this = this;\n        if (queryId === void 0) { queryId = this.generateQueryId(); }\n        invariant(options.query, 28);\n        invariant(options.query.kind === \"Document\", 29);\n        invariant(!options.returnPartialData, 30);\n        invariant(!options.pollInterval, 31);\n        return this.fetchQuery(queryId, __assign(__assign({}, options), { query: this.transform(options.query) })).finally(function () { return _this.stopQuery(queryId); });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.queryIdCounter++);\n    };\n    QueryManager.prototype.generateRequestId = function () {\n        return this.requestIdCounter++;\n    };\n    QueryManager.prototype.generateMutationId = function () {\n        return String(this.mutationIdCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo)\n            queryInfo.stop();\n    };\n    QueryManager.prototype.clearStore = function (options) {\n        if (options === void 0) { options = {\n            discardWatches: true,\n        }; }\n        // Before we have sent the reset action to the store, we can no longer\n        // rely on the results returned by in-flight requests since these may\n        // depend on values that previously existed in the data portion of the\n        // store. So, we cancel the promises and observers that we have issued\n        // so far and not yet resolved (in the case of queries).\n        this.cancelPendingFetches(newInvariantError(32));\n        this.queries.forEach(function (queryInfo) {\n            if (queryInfo.observableQuery) {\n                // Set loading to true so listeners don't trigger unless they want\n                // results with partial data.\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        // begin removing data from the store\n        return this.cache.reset(options);\n    };\n    QueryManager.prototype.getObservableQueries = function (include) {\n        var _this = this;\n        if (include === void 0) { include = \"active\"; }\n        var queries = new Map();\n        var queryNamesAndDocs = new Map();\n        var legacyQueryOptions = new Set();\n        if (Array.isArray(include)) {\n            include.forEach(function (desc) {\n                if (typeof desc === \"string\") {\n                    queryNamesAndDocs.set(desc, false);\n                }\n                else if (isDocumentNode(desc)) {\n                    queryNamesAndDocs.set(_this.transform(desc), false);\n                }\n                else if (isNonNullObject(desc) && desc.query) {\n                    legacyQueryOptions.add(desc);\n                }\n            });\n        }\n        this.queries.forEach(function (_a, queryId) {\n            var oq = _a.observableQuery, document = _a.document;\n            if (oq) {\n                if (include === \"all\") {\n                    queries.set(queryId, oq);\n                    return;\n                }\n                var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;\n                if (fetchPolicy === \"standby\" ||\n                    (include === \"active\" && !oq.hasObservers())) {\n                    return;\n                }\n                if (include === \"active\" ||\n                    (queryName && queryNamesAndDocs.has(queryName)) ||\n                    (document && queryNamesAndDocs.has(document))) {\n                    queries.set(queryId, oq);\n                    if (queryName)\n                        queryNamesAndDocs.set(queryName, true);\n                    if (document)\n                        queryNamesAndDocs.set(document, true);\n                }\n            }\n        });\n        if (legacyQueryOptions.size) {\n            legacyQueryOptions.forEach(function (options) {\n                // We will be issuing a fresh network request for this query, so we\n                // pre-allocate a new query ID here, using a special prefix to enable\n                // cleaning up these temporary queries later, after fetching.\n                var queryId = makeUniqueId(\"legacyOneTimeQuery\");\n                var queryInfo = _this.getQuery(queryId).init({\n                    document: options.query,\n                    variables: options.variables,\n                });\n                var oq = new ObservableQuery({\n                    queryManager: _this,\n                    queryInfo: queryInfo,\n                    options: __assign(__assign({}, options), { fetchPolicy: \"network-only\" }),\n                });\n                invariant(oq.queryId === queryId);\n                queryInfo.setObservableQuery(oq);\n                queries.set(queryId, oq);\n            });\n        }\n        if (globalThis.__DEV__ !== false && queryNamesAndDocs.size) {\n            queryNamesAndDocs.forEach(function (included, nameOrDoc) {\n                if (!included) {\n                    globalThis.__DEV__ !== false && invariant.warn(typeof nameOrDoc === \"string\" ? 33 : 34, nameOrDoc);\n                }\n            });\n        }\n        return queries;\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.getObservableQueries(includeStandby ? \"all\" : \"active\").forEach(function (observableQuery, queryId) {\n            var fetchPolicy = observableQuery.options.fetchPolicy;\n            observableQuery.resetLastResults();\n            if (includeStandby ||\n                (fetchPolicy !== \"standby\" && fetchPolicy !== \"cache-only\")) {\n                observableQueryPromises.push(observableQuery.refetch());\n            }\n            _this.getQuery(queryId).setDiff(null);\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.setObservableQuery = function (observableQuery) {\n        this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (_a) {\n        var _this = this;\n        var query = _a.query, fetchPolicy = _a.fetchPolicy, _b = _a.errorPolicy, errorPolicy = _b === void 0 ? \"none\" : _b, variables = _a.variables, _c = _a.context, context = _c === void 0 ? {} : _c;\n        query = this.transform(query);\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, context, variables).map(function (result) {\n                if (fetchPolicy !== \"no-cache\") {\n                    // the subscription interface should handle not sending us results we no longer subscribe to.\n                    // XXX I don't think we ever send in an object with errors, but we might in the future...\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                var hasErrors = graphQLResultHasError(result);\n                var hasProtocolErrors = graphQLResultHasProtocolErrors(result);\n                if (hasErrors || hasProtocolErrors) {\n                    var errors = {};\n                    if (hasErrors) {\n                        errors.graphQLErrors = result.errors;\n                    }\n                    if (hasProtocolErrors) {\n                        errors.protocolErrors = result.extensions[PROTOCOL_ERRORS_SYMBOL];\n                    }\n                    // `errorPolicy` is a mechanism for handling GraphQL errors, according\n                    // to our documentation, so we throw protocol errors regardless of the\n                    // set error policy.\n                    if (errorPolicy === \"none\" || hasProtocolErrors) {\n                        throw new ApolloError(errors);\n                    }\n                }\n                if (errorPolicy === \"ignore\") {\n                    delete result.errors;\n                }\n                return result;\n            });\n        };\n        if (this.getDocumentInfo(query).hasClientExports) {\n            var observablePromise_1 = this.localState\n                .addExportedVariables(query, variables, context)\n                .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        // teardown all links\n        // Both `QueryManager.fetchRequest` and `QueryManager.query` create separate promises\n        // that each add their reject functions to fetchCancelFns.\n        // A query created with `QueryManager.query()` could trigger a `QueryManager.fetchRequest`.\n        // The same queryId could have two rejection fns for two promises\n        this.fetchCancelFns.delete(queryId);\n        if (this.queries.has(queryId)) {\n            this.getQuery(queryId).stop();\n            this.queries.delete(queryId);\n        }\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        if (this.onBroadcast)\n            this.onBroadcast();\n        this.queries.forEach(function (info) { return info.notify(); });\n    };\n    QueryManager.prototype.getLocalState = function () {\n        return this.localState;\n    };\n    QueryManager.prototype.getObservableFromLink = function (query, context, variables, \n    // Prefer context.queryDeduplication if specified.\n    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 _b = this.getDocumentInfo(query), serverQuery = _b.serverQuery, clientQuery = _b.clientQuery;\n        if (serverQuery) {\n            var _c = this, inFlightLinkObservables_1 = _c.inFlightLinkObservables, link = _c.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 printedServerQuery_1 = print(serverQuery);\n                var byVariables_1 = inFlightLinkObservables_1.get(printedServerQuery_1) || new Map();\n                inFlightLinkObservables_1.set(printedServerQuery_1, byVariables_1);\n                var varJson_1 = canonicalStringify(variables);\n                observable = byVariables_1.get(varJson_1);\n                if (!observable) {\n                    var concast = new Concast([\n                        execute(link, operation),\n                    ]);\n                    byVariables_1.set(varJson_1, (observable = concast));\n                    concast.beforeNext(function () {\n                        if (byVariables_1.delete(varJson_1) && byVariables_1.size < 1) {\n                            inFlightLinkObservables_1.delete(printedServerQuery_1);\n                        }\n                    });\n                }\n            }\n            else {\n                observable = new Concast([\n                    execute(link, operation),\n                ]);\n            }\n        }\n        else {\n            observable = new Concast([Observable.of({ data: {} })]);\n            context = this.prepareContext(context);\n        }\n        if (clientQuery) {\n            observable = asyncMap(observable, function (result) {\n                return _this.localState.runResolvers({\n                    document: clientQuery,\n                    remoteResult: result,\n                    context: context,\n                    variables: variables,\n                });\n            });\n        }\n        return observable;\n    };\n    QueryManager.prototype.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {\n        var requestId = (queryInfo.lastRequestId = this.generateRequestId());\n        // Performing transformForLink here gives this.cache a chance to fill in\n        // missing fragment definitions (for example) before sending this document\n        // through the link chain.\n        var linkDocument = this.cache.transformForLink(options.query);\n        return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {\n            var graphQLErrors = getGraphQLErrorsFromResult(result);\n            var hasErrors = graphQLErrors.length > 0;\n            // If we interrupted this request by calling getResultsFromLink again\n            // with the same QueryInfo object, we ignore the old results.\n            if (requestId >= queryInfo.lastRequestId) {\n                if (hasErrors && options.errorPolicy === \"none\") {\n                    // Throwing here effectively calls observer.error.\n                    throw queryInfo.markError(new ApolloError({\n                        graphQLErrors: graphQLErrors,\n                    }));\n                }\n                // Use linkDocument rather than queryInfo.document so the\n                // operation/fragments used to write the result are the same as the\n                // ones used to obtain it from the link.\n                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);\n                queryInfo.markReady();\n            }\n            var aqr = {\n                data: result.data,\n                loading: false,\n                networkStatus: NetworkStatus.ready,\n            };\n            if (hasErrors && options.errorPolicy !== \"ignore\") {\n                aqr.errors = graphQLErrors;\n                aqr.networkStatus = NetworkStatus.error;\n            }\n            return aqr;\n        }, function (networkError) {\n            var error = isApolloError(networkError) ? networkError : (new ApolloError({ networkError: networkError }));\n            // Avoid storing errors from older interrupted queries.\n            if (requestId >= queryInfo.lastRequestId) {\n                queryInfo.markError(error);\n            }\n            throw error;\n        });\n    };\n    QueryManager.prototype.fetchConcastWithInfo = function (queryId, options, \n    // The initial networkStatus for this fetch, most often\n    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,\n    // or setVariables.\n    networkStatus, query) {\n        var _this = this;\n        if (networkStatus === void 0) { networkStatus = NetworkStatus.loading; }\n        if (query === void 0) { query = options.query; }\n        var variables = this.getVariables(query, options.variables);\n        var queryInfo = this.getQuery(queryId);\n        var defaults = this.defaultOptions.watchQuery;\n        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? (defaults && defaults.fetchPolicy) || \"cache-first\" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? (defaults && defaults.errorPolicy) || \"none\" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;\n        var normalized = Object.assign({}, options, {\n            query: query,\n            variables: variables,\n            fetchPolicy: fetchPolicy,\n            errorPolicy: errorPolicy,\n            returnPartialData: returnPartialData,\n            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,\n            context: context,\n        });\n        var fromVariables = function (variables) {\n            // Since normalized is always a fresh copy of options, it's safe to\n            // modify its properties here, rather than creating yet another new\n            // WatchQueryOptions object.\n            normalized.variables = variables;\n            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);\n            if (\n            // If we're in standby, postpone advancing options.fetchPolicy using\n            // applyNextFetchPolicy.\n            normalized.fetchPolicy !== \"standby\" &&\n                // The \"standby\" policy currently returns [] from fetchQueryByPolicy, so\n                // this is another way to detect when nothing was done/fetched.\n                sourcesWithInfo.sources.length > 0 &&\n                queryInfo.observableQuery) {\n                queryInfo.observableQuery[\"applyNextFetchPolicy\"](\"after-fetch\", options);\n            }\n            return sourcesWithInfo;\n        };\n        // This cancel function needs to be set before the concast is created,\n        // in case concast creation synchronously cancels the request.\n        var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };\n        this.fetchCancelFns.set(queryId, function (reason) {\n            cleanupCancelFn();\n            // This delay ensures the concast variable has been initialized.\n            setTimeout(function () { return concast.cancel(reason); });\n        });\n        var concast, containsDataFromLink;\n        // If the query has @export(as: ...) directives, then we need to\n        // process those directives asynchronously. When there are no\n        // @export directives (the common case), we deliberately avoid\n        // wrapping the result of this.fetchQueryByPolicy in a Promise,\n        // since the timing of result delivery is (unfortunately) important\n        // for backwards compatibility. TODO This code could be simpler if\n        // we deprecated and removed LocalState.\n        if (this.getDocumentInfo(normalized.query).hasClientExports) {\n            concast = new Concast(this.localState\n                .addExportedVariables(normalized.query, normalized.variables, normalized.context)\n                .then(fromVariables)\n                .then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));\n            // there is just no way we can synchronously get the *right* value here,\n            // so we will assume `true`, which is the behaviour before the bug fix in\n            // #10597. This means that bug is not fixed in that case, and is probably\n            // un-fixable with reasonable effort for the edge case of @export as\n            // directives.\n            containsDataFromLink = true;\n        }\n        else {\n            var sourcesWithInfo = fromVariables(normalized.variables);\n            containsDataFromLink = sourcesWithInfo.fromLink;\n            concast = new Concast(sourcesWithInfo.sources);\n        }\n        concast.promise.then(cleanupCancelFn, cleanupCancelFn);\n        return {\n            concast: concast,\n            fromLink: containsDataFromLink,\n        };\n    };\n    QueryManager.prototype.refetchQueries = function (_a) {\n        var _this = this;\n        var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? makeUniqueId(\"refetchQueries\") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;\n        var includedQueriesById = new Map();\n        if (include) {\n            this.getObservableQueries(include).forEach(function (oq, queryId) {\n                includedQueriesById.set(queryId, {\n                    oq: oq,\n                    lastDiff: _this.getQuery(queryId).getDiff(),\n                });\n            });\n        }\n        var results = new Map();\n        if (updateCache) {\n            this.cache.batch({\n                update: updateCache,\n                // Since you can perform any combination of cache reads and/or writes in\n                // the cache.batch update function, its optimistic option can be either\n                // a boolean or a string, representing three distinct modes of\n                // operation:\n                //\n                // * false: read/write only the root layer\n                // * true: read/write the topmost layer\n                // * string: read/write a fresh optimistic layer with that ID string\n                //\n                // When typeof optimistic === \"string\", a new optimistic layer will be\n                // temporarily created within cache.batch with that string as its ID. If\n                // we then pass that same string as the removeOptimistic option, we can\n                // make cache.batch immediately remove the optimistic layer after\n                // running the updateCache function, triggering only one broadcast.\n                //\n                // However, the refetchQueries method accepts only true or false for its\n                // optimistic option (not string). We interpret true to mean a temporary\n                // optimistic layer should be created, to allow efficiently rolling back\n                // the effect of the updateCache function, which involves passing a\n                // string instead of true as the optimistic option to cache.batch, when\n                // refetchQueries receives optimistic: true.\n                //\n                // In other words, we are deliberately not supporting the use case of\n                // writing to an *existing* optimistic layer (using the refetchQueries\n                // updateCache function), since that would potentially interfere with\n                // other optimistic updates in progress. Instead, you can read/write\n                // only the root layer by passing optimistic: false to refetchQueries,\n                // or you can read/write a brand new optimistic layer that will be\n                // automatically removed by passing optimistic: true.\n                optimistic: (optimistic && removeOptimistic) || false,\n                // The removeOptimistic option can also be provided by itself, even if\n                // optimistic === false, to remove some previously-added optimistic\n                // layer safely and efficiently, like we do in markMutationResult.\n                //\n                // If an explicit removeOptimistic string is provided with optimistic:\n                // true, the removeOptimistic string will determine the ID of the\n                // temporary optimistic layer, in case that ever matters.\n                removeOptimistic: removeOptimistic,\n                onWatchUpdated: function (watch, diff, lastDiff) {\n                    var oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;\n                    if (oq) {\n                        if (onQueryUpdated) {\n                            // Since we're about to handle this query now, remove it from\n                            // includedQueriesById, in case it was added earlier because of\n                            // options.include.\n                            includedQueriesById.delete(oq.queryId);\n                            var result = onQueryUpdated(oq, diff, lastDiff);\n                            if (result === true) {\n                                // The onQueryUpdated function requested the default refetching\n                                // behavior by returning true.\n                                result = oq.refetch();\n                            }\n                            // Record the result in the results Map, as long as onQueryUpdated\n                            // did not return false to skip/ignore this result.\n                            if (result !== false) {\n                                results.set(oq, result);\n                            }\n                            // Allow the default cache broadcast to happen, except when\n                            // onQueryUpdated returns false.\n                            return result;\n                        }\n                        if (onQueryUpdated !== null) {\n                            // If we don't have an onQueryUpdated function, and onQueryUpdated\n                            // was not disabled by passing null, make sure this query is\n                            // \"included\" like any other options.include-specified query.\n                            includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });\n                        }\n                    }\n                },\n            });\n        }\n        if (includedQueriesById.size) {\n            includedQueriesById.forEach(function (_a, queryId) {\n                var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;\n                var result;\n                // If onQueryUpdated is provided, we want to use it for all included\n                // queries, even the QueryOptions ones.\n                if (onQueryUpdated) {\n                    if (!diff) {\n                        var info = oq[\"queryInfo\"];\n                        info.reset(); // Force info.getDiff() to read from cache.\n                        diff = info.getDiff();\n                    }\n                    result = onQueryUpdated(oq, diff, lastDiff);\n                }\n                // Otherwise, we fall back to refetching.\n                if (!onQueryUpdated || result === true) {\n                    result = oq.refetch();\n                }\n                if (result !== false) {\n                    results.set(oq, result);\n                }\n                if (queryId.indexOf(\"legacyOneTimeQuery\") >= 0) {\n                    _this.stopQueryNoBroadcast(queryId);\n                }\n            });\n        }\n        if (removeOptimistic) {\n            // In case no updateCache callback was provided (so cache.batch was not\n            // called above, and thus did not already remove the optimistic layer),\n            // remove it here. Since this is a no-op when the layer has already been\n            // removed, we do it even if we called cache.batch above, since it's\n            // possible this.cache is an instance of some ApolloCache subclass other\n            // than InMemoryCache, and does not fully support the removeOptimistic\n            // option for cache.batch.\n            this.cache.removeOptimistic(removeOptimistic);\n        }\n        return results;\n    };\n    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a, \n    // The initial networkStatus for this fetch, most often\n    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,\n    // or setVariables.\n    networkStatus) {\n        var _this = this;\n        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;\n        var oldNetworkStatus = queryInfo.networkStatus;\n        queryInfo.init({\n            document: query,\n            variables: variables,\n            networkStatus: networkStatus,\n        });\n        var readCache = function () { return queryInfo.getDiff(); };\n        var resultsFromCache = function (diff, networkStatus) {\n            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || NetworkStatus.loading; }\n            var data = diff.result;\n            if (globalThis.__DEV__ !== false && !returnPartialData && !equal(data, {})) {\n                logMissingFieldErrors(diff.missing);\n            }\n            var fromData = function (data) {\n                return Observable.of(__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true })));\n            };\n            if (data && _this.getDocumentInfo(query).hasForcedResolvers) {\n                return _this.localState\n                    .runResolvers({\n                    document: query,\n                    remoteResult: { data: data },\n                    context: context,\n                    variables: variables,\n                    onlyRunForcedResolvers: true,\n                })\n                    .then(function (resolved) { return fromData(resolved.data || void 0); });\n            }\n            // Resolves https://github.com/apollographql/apollo-client/issues/10317.\n            // If errorPolicy is 'none' and notifyOnNetworkStatusChange is true,\n            // data was incorrectly returned from the cache on refetch:\n            // if diff.missing exists, we should not return cache data.\n            if (errorPolicy === \"none\" &&\n                networkStatus === NetworkStatus.refetch &&\n                Array.isArray(diff.missing)) {\n                return fromData(void 0);\n            }\n            return fromData(data);\n        };\n        var cacheWriteBehavior = fetchPolicy === \"no-cache\" ? 0 /* CacheWriteBehavior.FORBID */\n            // Watched queries must opt into overwriting existing data on refetch,\n            // by passing refetchWritePolicy: \"overwrite\" in their WatchQueryOptions.\n            : (networkStatus === NetworkStatus.refetch &&\n                refetchWritePolicy !== \"merge\") ?\n                1 /* CacheWriteBehavior.OVERWRITE */\n                : 2 /* CacheWriteBehavior.MERGE */;\n        var resultsFromLink = function () {\n            return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {\n                query: query,\n                variables: variables,\n                context: context,\n                fetchPolicy: fetchPolicy,\n                errorPolicy: errorPolicy,\n            });\n        };\n        var shouldNotify = notifyOnNetworkStatusChange &&\n            typeof oldNetworkStatus === \"number\" &&\n            oldNetworkStatus !== networkStatus &&\n            isNetworkRequestInFlight(networkStatus);\n        switch (fetchPolicy) {\n            default:\n            case \"cache-first\": {\n                var diff = readCache();\n                if (diff.complete) {\n                    return {\n                        fromLink: false,\n                        sources: [resultsFromCache(diff, queryInfo.markReady())],\n                    };\n                }\n                if (returnPartialData || shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(diff), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            }\n            case \"cache-and-network\": {\n                var diff = readCache();\n                if (diff.complete || returnPartialData || shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(diff), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            }\n            case \"cache-only\":\n                return {\n                    fromLink: false,\n                    sources: [resultsFromCache(readCache(), queryInfo.markReady())],\n                };\n            case \"network-only\":\n                if (shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(readCache()), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            case \"no-cache\":\n                if (shouldNotify) {\n                    return {\n                        fromLink: true,\n                        // Note that queryInfo.getDiff() for no-cache queries does not call\n                        // cache.diff, but instead returns a { complete: false } stub result\n                        // when there is no queryInfo.diff already defined.\n                        sources: [resultsFromCache(queryInfo.getDiff()), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            case \"standby\":\n                return { fromLink: false, sources: [] };\n        }\n    };\n    QueryManager.prototype.getQuery = function (queryId) {\n        if (queryId && !this.queries.has(queryId)) {\n            this.queries.set(queryId, new QueryInfo(this, queryId));\n        }\n        return this.queries.get(queryId);\n    };\n    QueryManager.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var newContext = this.localState.prepareContext(context);\n        return __assign(__assign({}, newContext), { clientAwareness: this.clientAwareness });\n    };\n    return QueryManager;\n}());\nexport { QueryManager };\n//# sourceMappingURL=QueryManager.js.map","import { __assign } from \"tslib\";\nimport { invariant, newInvariantError } from \"../utilities/globals/index.js\";\nimport { ApolloLink, execute } from \"../link/core/index.js\";\nimport { version } from \"../version.js\";\nimport { HttpLink } from \"../link/http/index.js\";\nimport { QueryManager } from \"./QueryManager.js\";\nimport { LocalState } from \"./LocalState.js\";\nvar hasSuggestedDevtools = false;\n// Though mergeOptions now resides in @apollo/client/utilities, it was\n// previously declared and exported from this module, and then reexported from\n// @apollo/client/core. Since we need to preserve that API anyway, the easiest\n// solution is to reexport mergeOptions where it was previously declared (here).\nimport { mergeOptions } from \"../utilities/index.js\";\nexport { mergeOptions };\n/**\n * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries\n * and mutations) to a GraphQL spec-compliant server over an {@link ApolloLink} instance,\n * receive results from the server and cache the results in a store. It also delivers updates\n * to GraphQL queries through {@link Observable} instances.\n */\nvar ApolloClient = /** @class */ (function () {\n    /**\n     * Constructs an instance of {@link ApolloClient}.\n     *\n     * @example\n     * ```js\n     * import { ApolloClient, InMemoryCache } from '@apollo/client';\n     *\n     * const cache = new InMemoryCache();\n     *\n     * const client = new ApolloClient({\n     *   // Provide required constructor fields\n     *   cache: cache,\n     *   uri: 'http://localhost:4000/',\n     *\n     *   // Provide some optional constructor fields\n     *   name: 'react-web-client',\n     *   version: '1.3',\n     *   queryDeduplication: false,\n     *   defaultOptions: {\n     *     watchQuery: {\n     *       fetchPolicy: 'cache-and-network',\n     *     },\n     *   },\n     * });\n     * ```\n     */\n    function ApolloClient(options) {\n        var _this = this;\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        if (!options.cache) {\n            throw newInvariantError(15);\n        }\n        var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, documentTransform = options.documentTransform, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, \n        // Expose the client instance as window.__APOLLO_CLIENT__ and call\n        // onBroadcast in queryManager.broadcastQueries to enable browser\n        // devtools, but disable them by default in production.\n        _c = options.connectToDevTools, \n        // Expose the client instance as window.__APOLLO_CLIENT__ and call\n        // onBroadcast in queryManager.broadcastQueries to enable browser\n        // devtools, but disable them by default in production.\n        connectToDevTools = _c === void 0 ? typeof window === \"object\" &&\n            !window.__APOLLO_CLIENT__ &&\n            globalThis.__DEV__ !== false : _c, _d = options.queryDeduplication, queryDeduplication = _d === void 0 ? true : _d, defaultOptions = options.defaultOptions, _e = options.assumeImmutableResults, assumeImmutableResults = _e === void 0 ? cache.assumeImmutableResults : _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 =\n                uri ? new HttpLink({ uri: uri, credentials: credentials, headers: headers }) : ApolloLink.empty();\n        }\n        this.link = link;\n        this.cache = cache;\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || Object.create(null);\n        this.typeDefs = typeDefs;\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        this.version = version;\n        this.localState = new LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager({\n            cache: this.cache,\n            link: this.link,\n            defaultOptions: this.defaultOptions,\n            documentTransform: documentTransform,\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 ?\n                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                }\n                : void 0,\n        });\n        if (connectToDevTools)\n            this.connectToDevTools();\n    }\n    ApolloClient.prototype.connectToDevTools = function () {\n        if (typeof window === \"object\") {\n            var windowWithDevTools = window;\n            var devtoolsSymbol = Symbol.for(\"apollo.devtools\");\n            (windowWithDevTools[devtoolsSymbol] =\n                windowWithDevTools[devtoolsSymbol] || []).push(this);\n            windowWithDevTools.__APOLLO_CLIENT__ = this;\n        }\n        /**\n         * Suggest installing the devtools for developers who don't have them\n         */\n        if (!hasSuggestedDevtools && globalThis.__DEV__ !== false) {\n            hasSuggestedDevtools = true;\n            setTimeout(function () {\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 =\n                                \"https://chrome.google.com/webstore/detail/\" +\n                                    \"apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm\";\n                        }\n                        else if (ua.indexOf(\"Firefox/\") > -1) {\n                            url =\n                                \"https://addons.mozilla.org/en-US/firefox/addon/apollo-developer-tools/\";\n                        }\n                    }\n                    if (url) {\n                        globalThis.__DEV__ !== false && invariant.log(\"Download the Apollo DevTools for a better development \" +\n                            \"experience: %s\", url);\n                    }\n                }\n            }, 10000);\n        }\n    };\n    Object.defineProperty(ApolloClient.prototype, \"documentTransform\", {\n        /**\n         * The `DocumentTransform` used to modify GraphQL documents before a request\n         * is made. If a custom `DocumentTransform` is not provided, this will be the\n         * default document transform.\n         */\n        get: function () {\n            return this.queryManager.documentTransform;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Call this method to terminate any active client processes, making it safe\n     * to dispose of this `ApolloClient` instance.\n     */\n    ApolloClient.prototype.stop = function () {\n        this.queryManager.stop();\n    };\n    /**\n     * This watches the cache store of the query according to the options specified and\n     * returns an {@link ObservableQuery}. We can subscribe to this {@link ObservableQuery} and\n     * receive updated results through a GraphQL observer when the cache store changes.\n     *\n     * Note that this method is not an implementation of GraphQL subscriptions. Rather,\n     * it uses Apollo's store in order to reactively deliver updates to your query results.\n     *\n     * For example, suppose you call watchQuery on a GraphQL query that fetches a person's\n     * first and last name and this person has a particular object identifier, provided by\n     * dataIdFromObject. Later, a different query fetches that same person's\n     * first and last name and the first name has now changed. Then, any observers associated\n     * with the results of the first query will be updated with a new result object.\n     *\n     * Note that if the cache does not change, the subscriber will *not* be notified.\n     *\n     * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for\n     * a description of store reactivity.\n     */\n    ApolloClient.prototype.watchQuery = function (options) {\n        if (this.defaultOptions.watchQuery) {\n            options = mergeOptions(this.defaultOptions.watchQuery, options);\n        }\n        // XXX Overwriting options is probably not the best way to do this long term...\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    /**\n     * This resolves a single query according to the options specified and\n     * returns a `Promise` which is either resolved with the resulting data\n     * or rejected with an error.\n     *\n     * @param options - An object of type {@link QueryOptions} that allows us to\n     * describe how this query should be treated e.g. whether it should hit the\n     * server at all or just resolve from the cache, etc.\n     */\n    ApolloClient.prototype.query = function (options) {\n        if (this.defaultOptions.query) {\n            options = mergeOptions(this.defaultOptions.query, options);\n        }\n        invariant(options.fetchPolicy !== \"cache-and-network\", 16);\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    /**\n     * This resolves a single mutation according to the options specified and returns a\n     * Promise which is either resolved with the resulting data or rejected with an\n     * error.\n     *\n     * It takes options as an object with the following keys and values:\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    /**\n     * This subscribes to a graphql subscription according to the options specified and returns an\n     * {@link Observable} which either emits received data or an error.\n     */\n    ApolloClient.prototype.subscribe = function (options) {\n        return this.queryManager.startGraphQLSubscription(options);\n    };\n    /**\n     * Tries to read some data from the store in the shape of the provided\n     * GraphQL query without making a network request. This method will start at\n     * the root query. To start at a specific id returned by `dataIdFromObject`\n     * use `readFragment`.\n     *\n     * @param optimistic - Set to `true` to allow `readQuery` to return\n     * optimistic results. Is `false` by default.\n     */\n    ApolloClient.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readQuery(options, optimistic);\n    };\n    /**\n     * Tries to read some data from the store in the shape of the provided\n     * GraphQL fragment without making a network request. This method will read a\n     * GraphQL fragment from any arbitrary id that is currently cached, unlike\n     * `readQuery` which will only read from the root query.\n     *\n     * You must pass in a GraphQL document with a single fragment or a document\n     * with multiple fragments that represent what you are reading. If you pass\n     * in a document with multiple fragments then you must also specify a\n     * `fragmentName`.\n     *\n     * @param optimistic - Set to `true` to allow `readFragment` to return\n     * optimistic results. Is `false` by default.\n     */\n    ApolloClient.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readFragment(options, optimistic);\n    };\n    /**\n     * Writes some data in the shape of the provided GraphQL query directly to\n     * the store. This method will start at the root query. To start at a\n     * specific id returned by `dataIdFromObject` then use `writeFragment`.\n     */\n    ApolloClient.prototype.writeQuery = function (options) {\n        var ref = this.cache.writeQuery(options);\n        if (options.broadcast !== false) {\n            this.queryManager.broadcastQueries();\n        }\n        return ref;\n    };\n    /**\n     * Writes some data in the shape of the provided GraphQL fragment directly to\n     * the store. This method will write to a GraphQL fragment from any arbitrary\n     * id that is currently cached, unlike `writeQuery` which will only write\n     * from the root query.\n     *\n     * You must pass in a GraphQL document with a single fragment or a document\n     * with multiple fragments that represent what you are writing. If you pass\n     * in a document with multiple fragments then you must also specify a\n     * `fragmentName`.\n     */\n    ApolloClient.prototype.writeFragment = function (options) {\n        var ref = this.cache.writeFragment(options);\n        if (options.broadcast !== false) {\n            this.queryManager.broadcastQueries();\n        }\n        return ref;\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    /**\n     * Resets your entire store by clearing out your cache and then re-executing\n     * all of your active queries. This makes it so that you may guarantee that\n     * there is no data left in your store from a time before you called this\n     * method.\n     *\n     * `resetStore()` is useful when your user just logged out. You’ve removed the\n     * user session, and you now want to make sure that any references to data you\n     * might have fetched while the user session was active is gone.\n     *\n     * It is important to remember that `resetStore()` *will* refetch any active\n     * queries. This means that any components that might be mounted will execute\n     * their queries again using your network interface. If you do not want to\n     * re-execute any queries then you should make sure to stop watching any\n     * active queries.\n     */\n    ApolloClient.prototype.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () {\n            return _this.queryManager.clearStore({\n                discardWatches: false,\n            });\n        })\n            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    /**\n     * Remove all data from the store. Unlike `resetStore`, `clearStore` will\n     * not refetch any active queries.\n     */\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () {\n            return _this.queryManager.clearStore({\n                discardWatches: true,\n            });\n        })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    /**\n     * Allows callbacks to be registered that are executed when the store is\n     * reset. `onResetStore` returns an unsubscribe function that can be used\n     * to remove registered callbacks.\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    /**\n     * Allows callbacks to be registered that are executed when the store is\n     * cleared. `onClearStore` returns an unsubscribe function that can be used\n     * to remove registered callbacks.\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    /**\n     * Refetches all of your active queries.\n     *\n     * `reFetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage\n     *\n     * It is important to remember that `reFetchObservableQueries()` *will* refetch any active\n     * queries. This means that any components that might be mounted will execute\n     * their queries again using your network interface. If you do not want to\n     * re-execute any queries then you should make sure to stop watching any\n     * active queries.\n     * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.\n     */\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    /**\n     * Refetches specified active queries. Similar to \"reFetchObservableQueries()\" but with a specific list of queries.\n     *\n     * `refetchQueries()` is useful for use cases to imperatively refresh a selection of queries.\n     *\n     * It is important to remember that `refetchQueries()` *will* refetch specified active\n     * queries. This means that any components that might be mounted will execute\n     * their queries again using your network interface. If you do not want to\n     * re-execute any queries then you should make sure to stop watching any\n     * active queries.\n     */\n    ApolloClient.prototype.refetchQueries = function (options) {\n        var map = this.queryManager.refetchQueries(options);\n        var queries = [];\n        var results = [];\n        map.forEach(function (result, obsQuery) {\n            queries.push(obsQuery);\n            results.push(result);\n        });\n        var result = Promise.all(results);\n        // In case you need the raw results immediately, without awaiting\n        // Promise.all(results):\n        result.queries = queries;\n        result.results = results;\n        // If you decide to ignore the result Promise because you're using\n        // result.queries and result.results instead, you shouldn't have to worry\n        // about preventing uncaught rejections for the Promise.all result.\n        result.catch(function (error) {\n            globalThis.__DEV__ !== false && invariant.debug(17, error);\n        });\n        return result;\n    };\n    /**\n     * Get all currently active `ObservableQuery` objects, in a `Map` keyed by\n     * query ID strings.\n     *\n     * An \"active\" query is one that has observers and a `fetchPolicy` other than\n     * \"standby\" or \"cache-only\".\n     *\n     * You can include all `ObservableQuery` objects (including the inactive ones)\n     * by passing \"all\" instead of \"active\", or you can include just a subset of\n     * active queries by passing an array of query names or DocumentNode objects.\n     */\n    ApolloClient.prototype.getObservableQueries = function (include) {\n        if (include === void 0) { include = \"active\"; }\n        return this.queryManager.getObservableQueries(include);\n    };\n    /**\n     * Exposes the cache's complete state, in a serializable format for later restoration.\n     */\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    /**\n     * Replaces existing state in the cache (if any) with the values expressed by\n     * `serializedState`.\n     *\n     * Called when hydrating a cache (server side rendering, or offline storage),\n     * and also (potentially) during hot reloads.\n     */\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    /**\n     * Add additional local resolvers.\n     */\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    /**\n     * Set (override existing) local resolvers.\n     */\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    /**\n     * Get all registered local resolvers.\n     */\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    /**\n     * Set a custom local state fragment matcher.\n     */\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    /**\n     * Define a new ApolloLink (or link chain) that Apollo Client will use.\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","/**\n * The current status of a query’s execution in our system.\n */\nexport var NetworkStatus;\n(function (NetworkStatus) {\n    /**\n     * The query has never been run before and the query is now currently running. A query will still\n     * have this network status even if a partial data result was returned from the cache, but a\n     * query was dispatched anyway.\n     */\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    /**\n     * If `setVariables` was called and a query was fired because of that then the network status\n     * will be `setVariables` until the result of that query comes back.\n     */\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    /**\n     * Indicates that `fetchMore` was called on this query and that the query created is currently in\n     * flight.\n     */\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    /**\n     * Similar to the `setVariables` network status. It means that `refetch` was called on a query\n     * and the refetch request is currently in flight.\n     */\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    /**\n     * Indicates that a polling query is currently in flight. So for example if you are polling a\n     * query every 10 seconds then the network status will switch to `poll` every 10 seconds whenever\n     * a poll request has been sent but not resolved.\n     */\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    /**\n     * No request is in flight for this query, and no errors happened. Everything is OK.\n     */\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    /**\n     * No request is in flight for this query, but one or more errors were detected.\n     */\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n})(NetworkStatus || (NetworkStatus = {}));\n/**\n * Returns true if there is currently a network request in flight according to a given network\n * status.\n */\nexport function isNetworkRequestInFlight(networkStatus) {\n    return networkStatus ? networkStatus < 7 : false;\n}\n/**\n * Returns true if the network request is in ready or error state according to a given network\n * status.\n */\nexport function isNetworkRequestSettled(networkStatus) {\n    return networkStatus === 7 || networkStatus === 8;\n}\n//# sourceMappingURL=networkStatus.js.map","import { devDebug, devError, devLog, devWarn } from \"../invariantErrorCodes.js\";\nimport { loadErrorMessageHandler } from \"./loadErrorMessageHandler.js\";\nexport function loadDevMessages() {\n    loadErrorMessageHandler(devDebug, devError, devLog, devWarn);\n}\n//# sourceMappingURL=loadDevMessages.js.map","import { global } from \"../utilities/globals/index.js\";\nimport { ApolloErrorMessageHandler } from \"../utilities/globals/invariantWrappers.js\";\nexport function loadErrorMessageHandler() {\n    var errorCodes = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        errorCodes[_i] = arguments[_i];\n    }\n    if (!global[ApolloErrorMessageHandler]) {\n        global[ApolloErrorMessageHandler] = handler;\n    }\n    for (var _a = 0, errorCodes_1 = errorCodes; _a < errorCodes_1.length; _a++) {\n        var codes = errorCodes_1[_a];\n        Object.assign(global[ApolloErrorMessageHandler], codes);\n    }\n    return global[ApolloErrorMessageHandler];\n    function handler(message, args) {\n        if (typeof message === \"number\") {\n            var definition = global[ApolloErrorMessageHandler][message];\n            if (!message || !(definition === null || definition === void 0 ? void 0 : definition.message))\n                return;\n            message = definition.message;\n        }\n        return args.reduce(function (msg, arg) { return msg.replace(/%[sdfo]/, String(arg)); }, String(message));\n    }\n}\n//# sourceMappingURL=loadErrorMessageHandler.js.map","import { errorCodes } from \"../invariantErrorCodes.js\";\nimport { loadErrorMessageHandler } from \"./loadErrorMessageHandler.js\";\nexport function loadErrorMessages() {\n    loadErrorMessageHandler(errorCodes);\n}\n//# sourceMappingURL=loadErrorMessages.js.map","import { __extends, __spreadArray } from \"tslib\";\nimport \"../utilities/globals/index.js\";\nimport { isNonNullObject } from \"../utilities/index.js\";\n// This Symbol allows us to pass transport-specific errors from the link chain\n// into QueryManager/client internals without risking a naming collision within\n// extensions (which implementers can use as they see fit).\nexport var PROTOCOL_ERRORS_SYMBOL = Symbol();\nexport function graphQLResultHasProtocolErrors(result) {\n    if (result.extensions) {\n        return Array.isArray(result.extensions[PROTOCOL_ERRORS_SYMBOL]);\n    }\n    return false;\n}\nexport function isApolloError(err) {\n    return err.hasOwnProperty(\"graphQLErrors\");\n}\n// Sets the error message on this error according to the\n// the GraphQL and network errors that are present.\n// If the error message has already been set through the\n// constructor or otherwise, this function is a nop.\nvar generateErrorMessage = function (err) {\n    var errors = __spreadArray(__spreadArray(__spreadArray([], err.graphQLErrors, true), err.clientErrors, true), err.protocolErrors, true);\n    if (err.networkError)\n        errors.push(err.networkError);\n    return (errors\n        // The rest of the code sometimes unsafely types non-Error objects as GraphQLErrors\n        .map(function (err) {\n        return (isNonNullObject(err) && err.message) || \"Error message not found.\";\n    })\n        .join(\"\\n\"));\n};\nvar ApolloError = /** @class */ (function (_super) {\n    __extends(ApolloError, _super);\n    // Constructs an instance of ApolloError given a GraphQLError\n    // or a network error. Note that one of these has to be a valid\n    // value or the constructed error will be meaningless.\n    function ApolloError(_a) {\n        var graphQLErrors = _a.graphQLErrors, protocolErrors = _a.protocolErrors, clientErrors = _a.clientErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;\n        var _this = _super.call(this, errorMessage) || this;\n        _this.name = \"ApolloError\";\n        _this.graphQLErrors = graphQLErrors || [];\n        _this.protocolErrors = protocolErrors || [];\n        _this.clientErrors = clientErrors || [];\n        _this.networkError = networkError || null;\n        _this.message = errorMessage || generateErrorMessage(_this);\n        _this.extraInfo = extraInfo;\n        // We're not using `Object.setPrototypeOf` here as it isn't fully\n        // supported on Android (see issue #3236).\n        _this.__proto__ = ApolloError.prototype;\n        return _this;\n    }\n    return ApolloError;\n}(Error));\nexport { ApolloError };\n//# sourceMappingURL=index.js.map","export const errorCodes = // This file is used by the error message display website and the\n// @apollo/client/includeErrors entry point.\n// This file is not meant to be imported manually.\n{\n  1: {\n    file: \"@apollo/client/cache/inmemory/entityStore.js\",\n    condition: \"typeof dataId === \\\"string\\\"\",\n    message: \"store.merge expects a string ID\"\n  },\n\n  4: {\n    file: \"@apollo/client/cache/inmemory/key-extractor.js\",\n    condition: \"extracted !== void 0\",\n    message: \"Missing field '%s' while extracting keyFields from %s\"\n  },\n\n  5: {\n    file: \"@apollo/client/cache/inmemory/policies.js\",\n    condition: \"!old || old === which\",\n    message: \"Cannot change root %s __typename more than once\"\n  },\n\n  8: {\n    file: \"@apollo/client/cache/inmemory/policies.js\",\n    message: \"Cannot automatically merge arrays\"\n  },\n\n  9: {\n    file: \"@apollo/client/cache/inmemory/readFromStore.js\",\n    message: \"No fragment named %s\"\n  },\n\n  10: {\n    file: \"@apollo/client/cache/inmemory/readFromStore.js\",\n    condition: \"!isReference(value)\",\n    message: \"Missing selection set for object of type %s returned for query field %s\"\n  },\n\n  11: {\n    file: \"@apollo/client/cache/inmemory/writeToStore.js\",\n    message: \"Could not identify object %s\"\n  },\n\n  13: {\n    file: \"@apollo/client/cache/inmemory/writeToStore.js\",\n    message: \"No fragment named %s\"\n  },\n\n  15: {\n    file: \"@apollo/client/core/ApolloClient.js\",\n\n    message: \"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\n  16: {\n    file: \"@apollo/client/core/ApolloClient.js\",\n    condition: \"options.fetchPolicy !== \\\"cache-and-network\\\"\",\n\n    message: \"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  },\n\n  18: {\n    file: \"@apollo/client/core/LocalState.js\",\n    condition: \"fragment\",\n    message: \"No fragment named %s\"\n  },\n\n  19: {\n    file: \"@apollo/client/core/LocalState.js\",\n    condition: \"fragment\",\n    message: \"No fragment named %s\"\n  },\n\n  22: {\n    file: \"@apollo/client/core/ObservableQuery.js\",\n    condition: \"pollInterval\",\n    message: \"Attempted to start a polling query without a polling interval.\"\n  },\n\n  25: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    message: \"QueryManager stopped while query was in flight\"\n  },\n\n  26: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    condition: \"mutation\",\n    message: \"mutation option is required. You must specify your GraphQL document in the mutation option.\"\n  },\n\n  27: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    condition: \"fetchPolicy === \\\"network-only\\\" || fetchPolicy === \\\"no-cache\\\"\",\n    message: \"Mutations support only 'network-only' or 'no-cache' fetchPolicy strings. The default `network-only` behavior automatically writes mutation results to the cache. Passing `no-cache` skips the cache write.\"\n  },\n\n  28: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    condition: \"options.query\",\n\n    message: \"query option is required. You must specify your GraphQL document \" +\n        \"in the query option.\"\n  },\n\n  29: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    condition: \"options.query.kind === \\\"Document\\\"\",\n    message: 'You must wrap the query string in a \"gql\" tag.'\n  },\n\n  30: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    condition: \"!options.returnPartialData\",\n    message: \"returnPartialData option only supported on watchQuery.\"\n  },\n\n  31: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    condition: \"!options.pollInterval\",\n    message: \"pollInterval option only supported on watchQuery.\"\n  },\n\n  32: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    message: \"Store reset while query was in flight (not completed in link chain)\"\n  },\n\n  36: {\n    file: \"@apollo/client/link/core/ApolloLink.js\",\n    message: \"request is not implemented\"\n  },\n\n  37: {\n    file: \"@apollo/client/link/http/checkFetcher.js\",\n    message: \"\\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  39: {\n    file: \"@apollo/client/link/http/serializeFetchParameter.js\",\n    message: \"Network request failed. %s is not serializable: %s\"\n  },\n\n  40: {\n    file: \"@apollo/client/link/persisted-queries/index.js\",\n    condition: \"options &&\\n    (typeof options.sha256 === \\\"function\\\" ||\\n        typeof options.generateHash === \\\"function\\\")\",\n\n    message: 'Missing/invalid \"sha256\" or \"generateHash\" function. Please ' +\n        'configure one using the \"createPersistedQueryLink(options)\" options ' +\n        \"parameter.\"\n  },\n\n  41: {\n    file: \"@apollo/client/link/persisted-queries/index.js\",\n    condition: \"forward\",\n    message: \"PersistedQueryLink cannot be the last link in the chain.\"\n  },\n\n  43: {\n    file: \"@apollo/client/link/utils/validateOperation.js\",\n    message: \"illegal argument: %s\"\n  },\n\n  44: {\n    file: \"@apollo/client/react/context/ApolloConsumer.js\",\n    condition: \"context && context.client\",\n\n    message: 'Could not find \"client\" in the context of ApolloConsumer. ' +\n        \"Wrap the root component in an <ApolloProvider>.\"\n  },\n\n  45: {\n    file: \"@apollo/client/react/context/ApolloContext.js\",\n    condition: \"\\\"createContext\\\" in React\",\n\n    message: \"Invoking `getApolloContext` in an environment where `React.createContext` is not available.\\n\" +\n        \"The Apollo Client functionality you are trying to use is only available in React Client Components.\\n\" +\n        'Please make sure to add \"use client\" at the top of your file.\\n' +\n        // TODO: change to React documentation once React documentation contains information about Client Components\n        \"For more information, see https://nextjs.org/docs/getting-started/react-essentials#client-components\"\n  },\n\n  46: {\n    file: \"@apollo/client/react/context/ApolloProvider.js\",\n    condition: \"context.client\",\n\n    message: \"ApolloProvider was not passed a client instance. Make \" +\n        'sure you pass in your client via the \"client\" prop.'\n  },\n\n  47: {\n    file: \"@apollo/client/react/hoc/hoc-utils.js\",\n    condition: \"this.withRef\",\n\n    message: \"To access the wrapped instance, you need to specify \" +\n        \"{ withRef: true } in the options\"\n  },\n\n  48: {\n    file: \"@apollo/client/react/hoc/withApollo.js\",\n    condition: \"operationOptions.withRef\",\n\n    message: \"To access the wrapped instance, you need to specify \" +\n        \"{ withRef: true } in the options\"\n  },\n\n  49: {\n    file: \"@apollo/client/react/hooks/useApolloClient.js\",\n    condition: \"!!client\",\n\n    message: 'Could not find \"client\" in the context or passed in as an option. ' +\n        \"Wrap the root component in an <ApolloProvider>, or pass an ApolloClient \" +\n        \"instance in via options.\"\n  },\n\n  51: {\n    file: \"@apollo/client/react/hooks/useReadQuery.js\",\n    condition: \"internalQueryRef.promiseCache\",\n\n    message: \"It appears that `useReadQuery` was used outside of `useBackgroundQuery`. \" +\n        \"`useReadQuery` is only supported for use with `useBackgroundQuery`. \" +\n        \"Please ensure you are passing the `queryRef` returned from `useBackgroundQuery`.\"\n  },\n\n  56: {\n    file: \"@apollo/client/react/hooks/useSuspenseQuery.js\",\n    condition: \"supportedFetchPolicies.includes(fetchPolicy)\",\n    message: \"The fetch policy `%s` is not supported with suspense.\"\n  },\n\n  59: {\n    file: \"@apollo/client/react/parser/index.js\",\n    condition: \"!!document && !!document.kind\",\n\n    message: \"Argument of %s 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  },\n\n  60: {\n    file: \"@apollo/client/react/parser/index.js\",\n    condition: \"!fragments.length ||\\n    queries.length ||\\n    mutations.length ||\\n    subscriptions.length\",\n\n    message: \"Passing only a fragment to 'graphql' is not yet supported. \" +\n        \"You must include a query, subscription or mutation as well\"\n  },\n\n  61: {\n    file: \"@apollo/client/react/parser/index.js\",\n    condition: \"queries.length + mutations.length + subscriptions.length <= 1\",\n\n    message: \"react-apollo only supports a query, subscription, or a mutation per HOC. \" +\n        \"%s had %s queries, %s \" +\n        \"subscriptions and %s mutations. \" +\n        \"You can use 'compose' to join multiple operation types to a component\"\n  },\n\n  62: {\n    file: \"@apollo/client/react/parser/index.js\",\n    condition: \"definitions.length === 1\",\n\n    message: \"react-apollo only supports one definition per HOC. %s had \" +\n        \"%s definitions. \" +\n        \"You can use 'compose' to join multiple operation types to a component\"\n  },\n\n  63: {\n    file: \"@apollo/client/react/parser/index.js\",\n    condition: \"operation.type === type\",\n    message: \"Running a %s requires a graphql \" + \"%s, but a %s was used instead.\"\n  },\n\n  64: {\n    file: \"@apollo/client/testing/core/mocking/mockLink.js\",\n    condition: \"queryWithoutConnection\",\n    message: \"query is required\"\n  },\n\n  65: {\n    file: \"@apollo/client/utilities/graphql/DocumentTransform.js\",\n    condition: \"Array.isArray(cacheKeys)\",\n    message: \"`getCacheKey` must return an array or undefined\"\n  },\n\n  66: {\n    file: \"@apollo/client/utilities/graphql/directives.js\",\n    condition: \"evaledValue !== void 0\",\n    message: \"Invalid variable referenced in @%s directive.\"\n  },\n\n  67: {\n    file: \"@apollo/client/utilities/graphql/directives.js\",\n    condition: \"directiveArguments && directiveArguments.length === 1\",\n    message: \"Incorrect number of arguments for the @%s directive.\"\n  },\n\n  68: {\n    file: \"@apollo/client/utilities/graphql/directives.js\",\n    condition: \"ifArgument.name && ifArgument.name.value === \\\"if\\\"\",\n    message: \"Invalid argument for the @%s directive.\"\n  },\n\n  69: {\n    file: \"@apollo/client/utilities/graphql/directives.js\",\n    condition: \"ifValue &&\\n    (ifValue.kind === \\\"Variable\\\" || ifValue.kind === \\\"BooleanValue\\\")\",\n    message: \"Argument for the @%s directive must be a variable or a boolean value.\"\n  },\n\n  70: {\n    file: \"@apollo/client/utilities/graphql/fragments.js\",\n\n    message: \"Found a %s operation%s. \" +\n        \"No operations are allowed when using a fragment as a query. Only fragments are allowed.\"\n  },\n\n  71: {\n    file: \"@apollo/client/utilities/graphql/fragments.js\",\n    condition: \"fragments.length === 1\",\n    message: \"Found %s fragments. `fragmentName` must be provided when there is not exactly 1 fragment.\"\n  },\n\n  72: {\n    file: \"@apollo/client/utilities/graphql/fragments.js\",\n    condition: \"fragment\",\n    message: \"No fragment named %s\"\n  },\n\n  73: {\n    file: \"@apollo/client/utilities/graphql/getFromAST.js\",\n    condition: \"doc && doc.kind === \\\"Document\\\"\",\n    message: \"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  },\n\n  74: {\n    file: \"@apollo/client/utilities/graphql/getFromAST.js\",\n    message: \"Schema type definitions not allowed in queries. Found: \\\"%s\\\"\"\n  },\n\n  75: {\n    file: \"@apollo/client/utilities/graphql/getFromAST.js\",\n    condition: \"operations.length <= 1\",\n    message: \"Ambiguous GraphQL document: contains %s operations\"\n  },\n\n  76: {\n    file: \"@apollo/client/utilities/graphql/getFromAST.js\",\n    condition: \"queryDef && queryDef.operation === \\\"query\\\"\",\n    message: \"Must contain a query definition.\"\n  },\n\n  77: {\n    file: \"@apollo/client/utilities/graphql/getFromAST.js\",\n    condition: \"doc.kind === \\\"Document\\\"\",\n    message: \"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  },\n\n  78: {\n    file: \"@apollo/client/utilities/graphql/getFromAST.js\",\n    condition: \"doc.definitions.length <= 1\",\n    message: \"Fragment must have exactly one definition.\"\n  },\n\n  79: {\n    file: \"@apollo/client/utilities/graphql/getFromAST.js\",\n    condition: \"fragmentDef.kind === \\\"FragmentDefinition\\\"\",\n    message: \"Must be a fragment definition.\"\n  },\n\n  80: {\n    file: \"@apollo/client/utilities/graphql/getFromAST.js\",\n    message: \"Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.\"\n  },\n\n  81: {\n    file: \"@apollo/client/utilities/graphql/storeUtils.js\",\n\n    message: \"The inline argument \\\"%s\\\" of kind \\\"%s\\\"\" +\n        \"is not supported. Use variables instead of inline arguments to \" +\n        \"overcome this limitation.\"\n  }\n};\n\nexport const devDebug = {\n  17: {\n    file: \"@apollo/client/core/ApolloClient.js\",\n    message: \"In client.refetchQueries, Promise.all promise rejected with error %o\"\n  },\n\n  24: {\n    file: \"@apollo/client/core/ObservableQuery.js\",\n    message: \"Missing cache result fields: %o\"\n  }\n};\n\nexport const devLog = {};\n\nexport const devWarn = {\n  2: {\n    file: \"@apollo/client/cache/inmemory/entityStore.js\",\n\n    message: \"cache.modify: You are trying to write a Reference that is not part of the store: %o\\n\" +\n        \"Please make sure to set the `mergeIntoStore` parameter to `true` when creating a Reference that is not part of the store yet:\\n\" +\n        \"`toReference(object, true)`\"\n  },\n\n  3: {\n    file: \"@apollo/client/cache/inmemory/entityStore.js\",\n\n    message: \"cache.modify: Writing an array with a mix of both References and Objects will not result in the Objects being normalized correctly.\\n\" +\n        \"Please convert the object instance %o to a Reference before writing it to the cache by calling `toReference(object, true)`.\"\n  },\n\n  6: {\n    file: \"@apollo/client/cache/inmemory/policies.js\",\n    message: \"Inferring subtype %s of supertype %s\"\n  },\n\n  7: {\n    file: \"@apollo/client/cache/inmemory/policies.js\",\n    message: \"Undefined 'from' passed to readField with arguments %s\"\n  },\n\n  14: {\n    file: \"@apollo/client/cache/inmemory/writeToStore.js\",\n    message: \"Cache data may be lost when replacing the %s field of a %s object.\\n\\nThis could cause additional (usually avoidable) network requests to fetch data that were otherwise cached.\\n\\nTo address this problem (which is not a bug in Apollo Client), %sdefine a custom merge function for the %s field, so InMemoryCache can safely merge these objects:\\n\\n  existing: %o\\n  incoming: %o\\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\n  20: {\n    file: \"@apollo/client/core/ObservableQuery.js\",\n    message: \"Called refetch(%o) for query %o, which does not declare a $variables variable.\\nDid you mean to call refetch(variables) instead of refetch({ variables })?\"\n  },\n\n  33: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    message: \"Unknown query named \\\"%s\\\" requested in refetchQueries options.include array\"\n  },\n\n  34: {\n    file: \"@apollo/client/core/QueryManager.js\",\n    message: \"Unknown query %s requested in refetchQueries options.include array\"\n  },\n\n  35: {\n    file: \"@apollo/client/link/core/ApolloLink.js\",\n    message: \"You are calling concat on a terminating link, which will have no effect %o\"\n  },\n\n  38: {\n    file: \"@apollo/client/link/http/createHttpLink.js\",\n    message: \"Multipart-subscriptions do not support @defer\"\n  },\n\n  42: {\n    file: \"@apollo/client/link/utils/toPromise.js\",\n    message: \"Promise Wrapper does not support multiple results from Observable\"\n  },\n\n  50: {\n    file: \"@apollo/client/react/hooks/useQuery.js\",\n    message: \"Calling default no-op implementation of InternalState#forceUpdate\"\n  },\n\n  52: {\n    file: \"@apollo/client/react/hooks/useSubscription.js\",\n    message: \"'useSubscription' supports only the 'onSubscriptionData' or 'onData' option, but not both. Only the 'onData' option will be used.\"\n  },\n\n  53: {\n    file: \"@apollo/client/react/hooks/useSubscription.js\",\n    message: \"'onSubscriptionData' is deprecated and will be removed in a future major version. Please use the 'onData' option instead.\"\n  },\n\n  54: {\n    file: \"@apollo/client/react/hooks/useSubscription.js\",\n    message: \"'useSubscription' supports only the 'onSubscriptionComplete' or 'onComplete' option, but not both. Only the 'onComplete' option will be used.\"\n  },\n\n  55: {\n    file: \"@apollo/client/react/hooks/useSubscription.js\",\n    message: \"'onSubscriptionComplete' is deprecated and will be removed in a future major version. Please use the 'onComplete' option instead.\"\n  },\n\n  57: {\n    file: \"@apollo/client/react/hooks/useSuspenseQuery.js\",\n    message: \"Using `returnPartialData` with a `no-cache` fetch policy has no effect. To read partial data from the cache, consider using an alternate fetch policy.\"\n  },\n\n  83: {\n    file: \"@apollo/client/utilities/graphql/transform.js\",\n\n    message: \"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\nexport const devError = {\n  12: {\n    file: \"@apollo/client/cache/inmemory/writeToStore.js\",\n    message: \"Missing field '%s' while writing result %o\"\n  },\n\n  21: {\n    file: \"@apollo/client/core/ObservableQuery.js\",\n    message: \"Unhandled GraphQL subscription error\"\n  },\n\n  23: {\n    file: \"@apollo/client/core/ObservableQuery.js\",\n    message: \"Unhandled error\"\n  },\n\n  58: {\n    file: \"@apollo/client/react/hooks/useSyncExternalStore.js\",\n    message: \"The result of getSnapshot should be cached to avoid an infinite loop\"\n  },\n\n  82: {\n    file: \"@apollo/client/utilities/graphql/transform.js\",\n    message: \"Could not find operation or fragment\"\n  }\n};\n","import { __rest } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nexport function setContext(setter) {\n    return new ApolloLink(function (operation, forward) {\n        var request = __rest(operation, []);\n        return new Observable(function (observer) {\n            var handle;\n            var closed = false;\n            Promise.resolve(request)\n                .then(function (req) { return setter(req, operation.getContext()); })\n                .then(operation.setContext)\n                .then(function () {\n                // if the observer is already closed, no need to subscribe.\n                if (closed)\n                    return;\n                handle = forward(operation).subscribe({\n                    next: observer.next.bind(observer),\n                    error: observer.error.bind(observer),\n                    complete: observer.complete.bind(observer),\n                });\n            })\n                .catch(observer.error.bind(observer));\n            return function () {\n                closed = true;\n                if (handle)\n                    handle.unsubscribe();\n            };\n        });\n    });\n}\n//# sourceMappingURL=index.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    // Best guess at an operation name\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 { newInvariantError } from \"../../utilities/globals/index.js\";\nexport function validateOperation(operation) {\n    var OPERATION_FIELDS = [\n        \"query\",\n        \"operationName\",\n        \"variables\",\n        \"extensions\",\n        \"context\",\n    ];\n    for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (OPERATION_FIELDS.indexOf(key) < 0) {\n            throw newInvariantError(43, key);\n        }\n    }\n    return operation;\n}\n//# sourceMappingURL=validateOperation.js.map","import { newInvariantError, invariant } from \"../../utilities/globals/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { validateOperation, createOperation, transformOperation, } from \"../utils/index.js\";\nfunction passthrough(op, forward) {\n    return (forward ? forward(op) : Observable.of());\n}\nfunction toLink(handler) {\n    return typeof handler === \"function\" ? new ApolloLink(handler) : handler;\n}\nfunction isTerminating(link) {\n    return link.request.length <= 1;\n}\nvar ApolloLink = /** @class */ (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            globalThis.__DEV__ !== false && invariant.warn(35, 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 newInvariantError(36);\n    };\n    ApolloLink.prototype.onError = function (error, observer) {\n        if (observer && observer.error) {\n            observer.error(error);\n            // Returning false indicates that observer.error does not need to be\n            // called again, since it was already called (on the previous line).\n            // Calling observer.error again would not cause any real problems,\n            // since only the first call matters, but custom onError functions\n            // might have other reasons for wanting to prevent the default\n            // behavior by returning false.\n            return false;\n        }\n        // Throw errors will be passed to observer.error.\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 from = ApolloLink.from;\n//# sourceMappingURL=from.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var split = ApolloLink.split;\n//# sourceMappingURL=split.js.map","import { __extends } from \"tslib\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { ApolloLink } from \"../core/index.js\";\nexport function onError(errorHandler) {\n    return new ApolloLink(function (operation, forward) {\n        return new Observable(function (observer) {\n            var sub;\n            var retriedSub;\n            var retriedResult;\n            try {\n                sub = forward(operation).subscribe({\n                    next: function (result) {\n                        if (result.errors) {\n                            retriedResult = errorHandler({\n                                graphQLErrors: result.errors,\n                                response: result,\n                                operation: operation,\n                                forward: forward,\n                            });\n                            if (retriedResult) {\n                                retriedSub = retriedResult.subscribe({\n                                    next: observer.next.bind(observer),\n                                    error: observer.error.bind(observer),\n                                    complete: observer.complete.bind(observer),\n                                });\n                                return;\n                            }\n                        }\n                        observer.next(result);\n                    },\n                    error: function (networkError) {\n                        retriedResult = errorHandler({\n                            operation: operation,\n                            networkError: networkError,\n                            //Network errors can return GraphQL errors on for example a 403\n                            graphQLErrors: networkError &&\n                                networkError.result &&\n                                networkError.result.errors,\n                            forward: forward,\n                        });\n                        if (retriedResult) {\n                            retriedSub = retriedResult.subscribe({\n                                next: observer.next.bind(observer),\n                                error: observer.error.bind(observer),\n                                complete: observer.complete.bind(observer),\n                            });\n                            return;\n                        }\n                        observer.error(networkError);\n                    },\n                    complete: function () {\n                        // disable the previous sub from calling complete on observable\n                        // if retry is in flight.\n                        if (!retriedResult) {\n                            observer.complete.bind(observer)();\n                        }\n                    },\n                });\n            }\n            catch (e) {\n                errorHandler({ networkError: e, operation: operation, forward: forward });\n                observer.error(e);\n            }\n            return function () {\n                if (sub)\n                    sub.unsubscribe();\n                if (retriedSub)\n                    sub.unsubscribe();\n            };\n        });\n    });\n}\nvar ErrorLink = /** @class */ (function (_super) {\n    __extends(ErrorLink, _super);\n    function ErrorLink(errorHandler) {\n        var _this = _super.call(this) || this;\n        _this.link = onError(errorHandler);\n        return _this;\n    }\n    ErrorLink.prototype.request = function (operation, forward) {\n        return this.link.request(operation, forward);\n    };\n    return ErrorLink;\n}(ApolloLink));\nexport { ErrorLink };\n//# sourceMappingURL=index.js.map","import { newInvariantError } from \"../../utilities/globals/index.js\";\nexport var serializeFetchParameter = function (p, label) {\n    var serialized;\n    try {\n        serialized = JSON.stringify(p);\n    }\n    catch (e) {\n        var parseError = newInvariantError(39, label, e.message);\n        parseError.parseError = e;\n        throw parseError;\n    }\n    return serialized;\n};\n//# sourceMappingURL=serializeFetchParameter.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","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/async.ts\n */\nexport default function asyncIterator(source) {\n    var _a;\n    var iterator = source[Symbol.asyncIterator]();\n    return _a = {\n            next: function () {\n                return iterator.next();\n            }\n        },\n        _a[Symbol.asyncIterator] = function () {\n            return this;\n        },\n        _a;\n}\n//# sourceMappingURL=async.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/nodeStream.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function nodeStreamIterator(stream) {\n    var cleanup = null;\n    var error = null;\n    var done = false;\n    var data = [];\n    var waiting = [];\n    function onData(chunk) {\n        if (error)\n            return;\n        if (waiting.length) {\n            var shiftedArr = waiting.shift();\n            if (Array.isArray(shiftedArr) && shiftedArr[0]) {\n                return shiftedArr[0]({ value: chunk, done: false });\n            }\n        }\n        data.push(chunk);\n    }\n    function onError(err) {\n        error = err;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[1](err);\n        });\n        !cleanup || cleanup();\n    }\n    function onEnd() {\n        done = true;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[0]({ value: undefined, done: true });\n        });\n        !cleanup || cleanup();\n    }\n    cleanup = function () {\n        cleanup = null;\n        stream.removeListener(\"data\", onData);\n        stream.removeListener(\"error\", onError);\n        stream.removeListener(\"end\", onEnd);\n        stream.removeListener(\"finish\", onEnd);\n        stream.removeListener(\"close\", onEnd);\n    };\n    stream.on(\"data\", onData);\n    stream.on(\"error\", onError);\n    stream.on(\"end\", onEnd);\n    stream.on(\"finish\", onEnd);\n    stream.on(\"close\", onEnd);\n    function getNext() {\n        return new Promise(function (resolve, reject) {\n            if (error)\n                return reject(error);\n            if (data.length)\n                return resolve({ value: data.shift(), done: false });\n            if (done)\n                return resolve({ value: undefined, done: true });\n            waiting.push([resolve, reject]);\n        });\n    }\n    var iterator = {\n        next: function () {\n            return getNext();\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=nodeStream.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/promise.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function promiseIterator(promise) {\n    var resolved = false;\n    var iterator = {\n        next: function () {\n            if (resolved)\n                return Promise.resolve({\n                    value: undefined,\n                    done: true,\n                });\n            resolved = true;\n            return new Promise(function (resolve, reject) {\n                promise\n                    .then(function (value) {\n                    resolve({ value: value, done: false });\n                })\n                    .catch(reject);\n            });\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=promise.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/reader.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function readerIterator(reader) {\n    var iterator = {\n        next: function () {\n            return reader.read();\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=reader.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/index.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../utilities/index.js\";\nimport asyncIterator from \"./iterators/async.js\";\nimport nodeStreamIterator from \"./iterators/nodeStream.js\";\nimport promiseIterator from \"./iterators/promise.js\";\nimport readerIterator from \"./iterators/reader.js\";\nfunction isNodeResponse(value) {\n    return !!value.body;\n}\nfunction isReadableStream(value) {\n    return !!value.getReader;\n}\nfunction isAsyncIterableIterator(value) {\n    return !!(canUseAsyncIteratorSymbol &&\n        value[Symbol.asyncIterator]);\n}\nfunction isStreamableBlob(value) {\n    return !!value.stream;\n}\nfunction isBlob(value) {\n    return !!value.arrayBuffer;\n}\nfunction isNodeReadableStream(value) {\n    return !!value.pipe;\n}\nexport function responseIterator(response) {\n    var body = response;\n    if (isNodeResponse(response))\n        body = response.body;\n    if (isAsyncIterableIterator(body))\n        return asyncIterator(body);\n    if (isReadableStream(body))\n        return readerIterator(body.getReader());\n    // this errors without casting to ReadableStream<T>\n    // because Blob.stream() returns a NodeJS ReadableStream\n    if (isStreamableBlob(body)) {\n        return readerIterator(body.stream().getReader());\n    }\n    if (isBlob(body))\n        return promiseIterator(body.arrayBuffer());\n    if (isNodeReadableStream(body))\n        return nodeStreamIterator(body);\n    throw new Error(\"Unknown body type for responseIterator. Please pass a streamable response.\");\n}\n//# sourceMappingURL=responseIterator.js.map","export var throwServerError = function (response, result, message) {\n    var error = new Error(message);\n    error.name = \"ServerError\";\n    error.response = response;\n    error.statusCode = response.status;\n    error.result = result;\n    throw error;\n};\n//# sourceMappingURL=throwServerError.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { responseIterator } from \"./responseIterator.js\";\nimport { throwServerError } from \"../utils/index.js\";\nimport { PROTOCOL_ERRORS_SYMBOL } from \"../../errors/index.js\";\nimport { isApolloPayloadResult } from \"../../utilities/common/incrementalResult.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function readMultipartBody(response, nextValue) {\n    var _a;\n    return __awaiter(this, void 0, void 0, function () {\n        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _b, value, done, chunk, searchFrom, bi, message, i, headers, contentType_1, body, result, next;\n        var _c, _d;\n        return __generator(this, function (_e) {\n            switch (_e.label) {\n                case 0:\n                    if (TextDecoder === undefined) {\n                        throw new Error(\"TextDecoder must be defined in the environment: please import a polyfill.\");\n                    }\n                    decoder = new TextDecoder(\"utf-8\");\n                    contentType = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get(\"content-type\");\n                    delimiter = \"boundary=\";\n                    boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter)) ?\n                        contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['\"]/g, \"\").replace(/\\;(.*)/gm, \"\").trim()\n                        : \"-\";\n                    boundary = \"\\r\\n--\".concat(boundaryVal);\n                    buffer = \"\";\n                    iterator = responseIterator(response);\n                    running = true;\n                    _e.label = 1;\n                case 1:\n                    if (!running) return [3 /*break*/, 3];\n                    return [4 /*yield*/, iterator.next()];\n                case 2:\n                    _b = _e.sent(), value = _b.value, done = _b.done;\n                    chunk = typeof value === \"string\" ? value : decoder.decode(value);\n                    searchFrom = buffer.length - boundary.length + 1;\n                    running = !done;\n                    buffer += chunk;\n                    bi = buffer.indexOf(boundary, searchFrom);\n                    while (bi > -1) {\n                        message = void 0;\n                        _c = [\n                            buffer.slice(0, bi),\n                            buffer.slice(bi + boundary.length),\n                        ], message = _c[0], buffer = _c[1];\n                        i = message.indexOf(\"\\r\\n\\r\\n\");\n                        headers = parseHeaders(message.slice(0, i));\n                        contentType_1 = headers[\"content-type\"];\n                        if (contentType_1 &&\n                            contentType_1.toLowerCase().indexOf(\"application/json\") === -1) {\n                            throw new Error(\"Unsupported patch content type: application/json is required.\");\n                        }\n                        body = message.slice(i);\n                        if (body) {\n                            result = parseJsonBody(response, body);\n                            if (Object.keys(result).length > 1 ||\n                                \"data\" in result ||\n                                \"incremental\" in result ||\n                                \"errors\" in result ||\n                                \"payload\" in result) {\n                                if (isApolloPayloadResult(result)) {\n                                    next = {};\n                                    if (\"payload\" in result) {\n                                        next = __assign({}, result.payload);\n                                    }\n                                    if (\"errors\" in result) {\n                                        next = __assign(__assign({}, next), { extensions: __assign(__assign({}, (\"extensions\" in next ? next.extensions : null)), (_d = {}, _d[PROTOCOL_ERRORS_SYMBOL] = result.errors, _d)) });\n                                    }\n                                    nextValue(next);\n                                }\n                                else {\n                                    // for the last chunk with only `hasNext: false`\n                                    // we don't need to call observer.next as there is no data/errors\n                                    nextValue(result);\n                                }\n                            }\n                            else if (\n                            // If the chunk contains only a \"hasNext: false\", we can call\n                            // observer.complete() immediately.\n                            Object.keys(result).length === 1 &&\n                                \"hasNext\" in result &&\n                                !result.hasNext) {\n                                return [2 /*return*/];\n                            }\n                        }\n                        bi = buffer.indexOf(boundary);\n                    }\n                    return [3 /*break*/, 1];\n                case 3: return [2 /*return*/];\n            }\n        });\n    });\n}\nexport function parseHeaders(headerText) {\n    var headersInit = {};\n    headerText.split(\"\\n\").forEach(function (line) {\n        var i = line.indexOf(\":\");\n        if (i > -1) {\n            // normalize headers to lowercase\n            var name_1 = line.slice(0, i).trim().toLowerCase();\n            var value = line.slice(i + 1).trim();\n            headersInit[name_1] = value;\n        }\n    });\n    return headersInit;\n}\nexport function parseJsonBody(response, bodyText) {\n    if (response.status >= 300) {\n        // Network error\n        var getResult = function () {\n            try {\n                return JSON.parse(bodyText);\n            }\n            catch (err) {\n                return bodyText;\n            }\n        };\n        throwServerError(response, getResult(), \"Response not successful: Received status code \".concat(response.status));\n    }\n    try {\n        return JSON.parse(bodyText);\n    }\n    catch (err) {\n        var parseError = err;\n        parseError.name = \"ServerParseError\";\n        parseError.response = response;\n        parseError.statusCode = response.status;\n        parseError.bodyText = bodyText;\n        throw parseError;\n    }\n}\nexport function handleError(err, observer) {\n    // if it is a network error, BUT there is graphql result info fire\n    // the next observer before calling error this gives apollo-client\n    // (and react-apollo) the `graphqlErrors` and `networkErrors` to\n    // pass to UI this should only happen if we *also* have data as\n    // part of the response key per the spec\n    if (err.result && err.result.errors && err.result.data) {\n        // if we don't call next, the UI can only show networkError\n        // because AC didn't get any graphqlErrors this is graphql\n        // execution result info (i.e errors and possibly data) this is\n        // because there is no formal spec how errors should translate to\n        // http status codes. So an auth error (401) could have both data\n        // from a public field, errors from a private field, and a status\n        // of 401\n        // {\n        //  user { // this will have errors\n        //    firstName\n        //  }\n        //  products { // this is public so will have data\n        //    cost\n        //  }\n        // }\n        //\n        // the result of above *could* look like this:\n        // {\n        //   data: { products: [{ cost: \"$10\" }] },\n        //   errors: [{\n        //      message: 'your session has timed out',\n        //      path: []\n        //   }]\n        // }\n        // status code of above would be a 401\n        // in the UI you want to show data where you can, errors as data where you can\n        // and use correct http status codes\n        observer.next(err.result);\n    }\n    observer.error(err);\n}\nexport function parseAndCheckHttpResponse(operations) {\n    return function (response) {\n        return response\n            .text()\n            .then(function (bodyText) { return parseJsonBody(response, bodyText); })\n            .then(function (result) {\n            if (!Array.isArray(result) &&\n                !hasOwnProperty.call(result, \"data\") &&\n                !hasOwnProperty.call(result, \"errors\")) {\n                // Data error\n                throwServerError(response, result, \"Server response was missing for query '\".concat(Array.isArray(operations) ?\n                    operations.map(function (op) { return op.operationName; })\n                    : operations.operationName, \"'.\"));\n            }\n            return result;\n        });\n    };\n}\n//# sourceMappingURL=parseAndCheckHttpResponse.js.map","import { newInvariantError } from \"../../utilities/globals/index.js\";\nexport var checkFetcher = function (fetcher) {\n    if (!fetcher && typeof fetch === \"undefined\") {\n        throw newInvariantError(37);\n    }\n};\n//# sourceMappingURL=checkFetcher.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { print } from \"../../utilities/index.js\";\nvar defaultHttpOptions = {\n    includeQuery: true,\n    includeExtensions: false,\n    preserveHeaderCase: false,\n};\nvar defaultHeaders = {\n    // headers are case insensitive (https://stackoverflow.com/a/5259004)\n    accept: \"*/*\",\n    // The content-type header describes the type of the body of the request, and\n    // so it typically only is sent with requests that actually have bodies. One\n    // could imagine that Apollo Client would remove this header when constructing\n    // a GET request (which has no body), but we historically have not done that.\n    // This means that browsers will preflight all Apollo Client requests (even\n    // GET requests). Apollo Server's CSRF prevention feature (introduced in\n    // AS3.7) takes advantage of this fact and does not block requests with this\n    // header. If you want to drop this header from GET requests, then you should\n    // probably replace it with a `apollo-require-preflight` header, or servers\n    // with CSRF prevention enabled might block your GET request. See\n    // https://www.apollographql.com/docs/apollo-server/security/cors/#preventing-cross-site-request-forgery-csrf\n    // for more details.\n    \"content-type\": \"application/json\",\n};\nvar defaultOptions = {\n    method: \"POST\",\n};\nexport var fallbackHttpConfig = {\n    http: defaultHttpOptions,\n    headers: defaultHeaders,\n    options: defaultOptions,\n};\nexport var defaultPrinter = function (ast, printer) { return printer(ast); };\nexport function selectHttpOptionsAndBody(operation, fallbackConfig) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    configs.unshift(fallbackConfig);\n    return selectHttpOptionsAndBodyInternal.apply(void 0, __spreadArray([operation,\n        defaultPrinter], configs, false));\n}\nexport function selectHttpOptionsAndBodyInternal(operation, printer) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    var options = {};\n    var http = {};\n    configs.forEach(function (config) {\n        options = __assign(__assign(__assign({}, options), config.options), { headers: __assign(__assign({}, options.headers), config.headers) });\n        if (config.credentials) {\n            options.credentials = config.credentials;\n        }\n        http = __assign(__assign({}, http), config.http);\n    });\n    if (options.headers) {\n        options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);\n    }\n    //The body depends on the http options\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    // not sending the query (i.e persisted queries)\n    if (http.includeQuery)\n        body.query = printer(query, print);\n    return {\n        options: options,\n        body: body,\n    };\n}\n// Remove potential duplicate header names, preserving last (by insertion order).\n// This is done to prevent unintentionally duplicating a header instead of\n// overwriting it (See #8447 and #8449).\nfunction removeDuplicateHeaders(headers, preserveHeaderCase) {\n    // If we're not preserving the case, just remove duplicates w/ normalization.\n    if (!preserveHeaderCase) {\n        var normalizedHeaders_1 = Object.create(null);\n        Object.keys(Object(headers)).forEach(function (name) {\n            normalizedHeaders_1[name.toLowerCase()] = headers[name];\n        });\n        return normalizedHeaders_1;\n    }\n    // If we are preserving the case, remove duplicates w/ normalization,\n    // preserving the original name.\n    // This allows for non-http-spec-compliant servers that expect intentionally\n    // capitalized header names (See #6741).\n    var headerData = Object.create(null);\n    Object.keys(Object(headers)).forEach(function (name) {\n        headerData[name.toLowerCase()] = {\n            originalName: name,\n            value: headers[name],\n        };\n    });\n    var normalizedHeaders = Object.create(null);\n    Object.keys(headerData).forEach(function (name) {\n        normalizedHeaders[headerData[name].originalName] = headerData[name].value;\n    });\n    return normalizedHeaders;\n}\n//# sourceMappingURL=selectHttpOptionsAndBody.js.map","import { serializeFetchParameter } from \"./serializeFetchParameter.js\";\n// For GET operations, returns the given URI rewritten with parameters, or a\n// parse error.\nexport function rewriteURIForGET(chosenURI, body) {\n    // Implement the standard HTTP GET serialization, plus 'extensions'. Note\n    // the extra level of JSON serialization!\n    var queryParams = [];\n    var addQueryParam = function (key, value) {\n        queryParams.push(\"\".concat(key, \"=\").concat(encodeURIComponent(value)));\n    };\n    if (\"query\" in body) {\n        addQueryParam(\"query\", body.query);\n    }\n    if (body.operationName) {\n        addQueryParam(\"operationName\", body.operationName);\n    }\n    if (body.variables) {\n        var serializedVariables = void 0;\n        try {\n            serializedVariables = serializeFetchParameter(body.variables, \"Variables map\");\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam(\"variables\", serializedVariables);\n    }\n    if (body.extensions) {\n        var serializedExtensions = void 0;\n        try {\n            serializedExtensions = serializeFetchParameter(body.extensions, \"Extensions map\");\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam(\"extensions\", serializedExtensions);\n    }\n    // Reconstruct the URI with added query params.\n    // XXX This assumes that the URI is well-formed and that it doesn't\n    //     already contain any of these query params. We could instead use the\n    //     URL API and take a polyfill (whatwg-url@6) for older browsers that\n    //     don't support URLSearchParams. Note that some browsers (and\n    //     versions of whatwg-url) support URL but not URLSearchParams!\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","import { __assign } from \"tslib\";\nimport { visit } from \"graphql\";\nexport function filterOperationVariables(variables, query) {\n    var result = __assign({}, variables);\n    var unusedNames = new Set(Object.keys(variables));\n    visit(query, {\n        Variable: function (node, _key, parent) {\n            // A variable type definition at the top level of a query is not\n            // enough to silence server-side errors about the variable being\n            // unused, so variable definitions do not count as usage.\n            // https://spec.graphql.org/draft/#sec-All-Variables-Used\n            if (parent &&\n                parent.kind !== \"VariableDefinition\") {\n                unusedNames.delete(node.name.value);\n            }\n        },\n    });\n    unusedNames.forEach(function (name) {\n        delete result[name];\n    });\n    return result;\n}\n//# sourceMappingURL=filterOperationVariables.js.map","import { __assign, __rest } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable, hasDirectives } from \"../../utilities/index.js\";\nimport { serializeFetchParameter } from \"./serializeFetchParameter.js\";\nimport { selectURI } from \"./selectURI.js\";\nimport { handleError, readMultipartBody, parseAndCheckHttpResponse, } from \"./parseAndCheckHttpResponse.js\";\nimport { checkFetcher } from \"./checkFetcher.js\";\nimport { selectHttpOptionsAndBodyInternal, defaultPrinter, fallbackHttpConfig, } from \"./selectHttpOptionsAndBody.js\";\nimport { rewriteURIForGET } from \"./rewriteURIForGET.js\";\nimport { fromError, filterOperationVariables } from \"../utils/index.js\";\nimport { maybe, getMainDefinition, removeClientSetsFromDocument, } from \"../../utilities/index.js\";\nvar backupFetch = maybe(function () { return fetch; });\nexport var createHttpLink = function (linkOptions) {\n    if (linkOptions === void 0) { linkOptions = {}; }\n    var _a = linkOptions.uri, uri = _a === void 0 ? \"/graphql\" : _a, \n    // use default global fetch if nothing passed in\n    preferredFetch = linkOptions.fetch, _b = linkOptions.print, print = _b === void 0 ? defaultPrinter : _b, includeExtensions = linkOptions.includeExtensions, preserveHeaderCase = linkOptions.preserveHeaderCase, useGETForQueries = linkOptions.useGETForQueries, _c = linkOptions.includeUnusedVariables, includeUnusedVariables = _c === void 0 ? false : _c, requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"print\", \"includeExtensions\", \"preserveHeaderCase\", \"useGETForQueries\", \"includeUnusedVariables\"]);\n    if (globalThis.__DEV__ !== false) {\n        // Make sure at least one of preferredFetch, window.fetch, or backupFetch is\n        // defined, so requests won't fail at runtime.\n        checkFetcher(preferredFetch || backupFetch);\n    }\n    var linkConfig = {\n        http: { includeExtensions: includeExtensions, preserveHeaderCase: preserveHeaderCase },\n        options: requestOptions.fetchOptions,\n        credentials: requestOptions.credentials,\n        headers: requestOptions.headers,\n    };\n    return new ApolloLink(function (operation) {\n        var chosenURI = selectURI(operation, uri);\n        var context = operation.getContext();\n        // `apollographql-client-*` headers are automatically set if a\n        // `clientAwareness` object is found in the context. These headers are\n        // set first, followed by the rest of the headers pulled from\n        // `context.headers`. If desired, `apollographql-client-*` headers set by\n        // the `clientAwareness` object can be overridden by\n        // `apollographql-client-*` headers set in `context.headers`.\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        if (hasDirectives([\"client\"], operation.query)) {\n            var transformedQuery = removeClientSetsFromDocument(operation.query);\n            if (!transformedQuery) {\n                return fromError(new Error(\"HttpLink: Trying to send a client-only query to the server. To send to the server, ensure a non-client field is added to the query or set the `transformOptions.removeClientFields` option to `true`.\"));\n            }\n            operation.query = transformedQuery;\n        }\n        //uses fallback, link, and then context to build options\n        var _b = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;\n        if (body.variables && !includeUnusedVariables) {\n            body.variables = filterOperationVariables(body.variables, operation.query);\n        }\n        var controller;\n        if (!options.signal && typeof AbortController !== \"undefined\") {\n            controller = new AbortController();\n            options.signal = controller.signal;\n        }\n        // If requested, set method to GET if there are no mutations.\n        var definitionIsMutation = function (d) {\n            return d.kind === \"OperationDefinition\" && d.operation === \"mutation\";\n        };\n        var definitionIsSubscription = function (d) {\n            return d.kind === \"OperationDefinition\" && d.operation === \"subscription\";\n        };\n        var isSubscription = definitionIsSubscription(getMainDefinition(operation.query));\n        // does not match custom directives beginning with @defer\n        var hasDefer = hasDirectives([\"defer\"], operation.query);\n        if (useGETForQueries &&\n            !operation.query.definitions.some(definitionIsMutation)) {\n            options.method = \"GET\";\n        }\n        if (hasDefer || isSubscription) {\n            options.headers = options.headers || {};\n            var acceptHeader = \"multipart/mixed;\";\n            // Omit defer-specific headers if the user attempts to defer a selection\n            // set on a subscription and log a warning.\n            if (isSubscription && hasDefer) {\n                globalThis.__DEV__ !== false && invariant.warn(38);\n            }\n            if (isSubscription) {\n                acceptHeader +=\n                    \"boundary=graphql;subscriptionSpec=1.0,application/json\";\n            }\n            else if (hasDefer) {\n                acceptHeader += \"deferSpec=20220824,application/json\";\n            }\n            options.headers.accept = acceptHeader;\n        }\n        if (options.method === \"GET\") {\n            var _c = rewriteURIForGET(chosenURI, body), newURI = _c.newURI, parseError = _c.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            // Prefer linkOptions.fetch (preferredFetch) if provided, and otherwise\n            // fall back to the *current* global window.fetch function (see issue\n            // #7832), or (if all else fails) the backupFetch function we saved when\n            // this module was first evaluated. This last option protects against the\n            // removal of window.fetch, which is unlikely but not impossible.\n            var currentFetch = preferredFetch || maybe(function () { return fetch; }) || backupFetch;\n            var observerNext = observer.next.bind(observer);\n            currentFetch(chosenURI, options)\n                .then(function (response) {\n                var _a;\n                operation.setContext({ response: response });\n                var ctype = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get(\"content-type\");\n                if (ctype !== null && /^multipart\\/mixed/i.test(ctype)) {\n                    return readMultipartBody(response, observerNext);\n                }\n                else {\n                    return parseAndCheckHttpResponse(operation)(response).then(observerNext);\n                }\n            })\n                .then(function () {\n                controller = undefined;\n                observer.complete();\n            })\n                .catch(function (err) {\n                controller = undefined;\n                handleError(err, observer);\n            });\n            return function () {\n                // XXX support canceling this request\n                // https://developers.google.com/web/updates/2017/09/abortable-fetch\n                if (controller)\n                    controller.abort();\n            };\n        });\n    });\n};\n//# sourceMappingURL=createHttpLink.js.map","export function buildDelayFunction(delayOptions) {\n    var _a = delayOptions || {}, _b = _a.initial, initial = _b === void 0 ? 300 : _b, _c = _a.jitter, jitter = _c === void 0 ? true : _c, _d = _a.max, max = _d === void 0 ? Infinity : _d;\n    // If we're jittering, baseDelay is half of the maximum delay for that\n    // attempt (and is, on average, the delay we will encounter).\n    // If we're not jittering, adjust baseDelay so that the first attempt\n    // lines up with initialDelay, for everyone's sanity.\n    var baseDelay = jitter ? initial : initial / 2;\n    return function delayFunction(count) {\n        var delay = Math.min(max, baseDelay * Math.pow(2, count));\n        if (jitter) {\n            // We opt for a full jitter approach for a mostly uniform distribution,\n            // but bound it within initialDelay and delay for everyone's sanity.\n            delay = Math.random() * delay;\n        }\n        return delay;\n    };\n}\n//# sourceMappingURL=delayFunction.js.map","export function buildRetryFunction(retryOptions) {\n    var _a = retryOptions || {}, retryIf = _a.retryIf, _b = _a.max, max = _b === void 0 ? 5 : _b;\n    return function retryFunction(count, operation, error) {\n        if (count >= max)\n            return false;\n        return retryIf ? retryIf(error, operation) : !!error;\n    };\n}\n//# sourceMappingURL=retryFunction.js.map","import { __awaiter, __extends, __generator } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { buildDelayFunction } from \"./delayFunction.js\";\nimport { buildRetryFunction } from \"./retryFunction.js\";\n/**\n * Tracking and management of operations that may be (or currently are) retried.\n */\nvar RetryableOperation = /** @class */ (function () {\n    function RetryableOperation(operation, nextLink, delayFor, retryIf) {\n        var _this = this;\n        this.operation = operation;\n        this.nextLink = nextLink;\n        this.delayFor = delayFor;\n        this.retryIf = retryIf;\n        this.retryCount = 0;\n        this.values = [];\n        this.complete = false;\n        this.canceled = false;\n        this.observers = [];\n        this.currentSubscription = null;\n        this.onNext = function (value) {\n            _this.values.push(value);\n            for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {\n                var observer = _a[_i];\n                if (!observer)\n                    continue;\n                observer.next(value);\n            }\n        };\n        this.onComplete = function () {\n            _this.complete = true;\n            for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {\n                var observer = _a[_i];\n                if (!observer)\n                    continue;\n                observer.complete();\n            }\n        };\n        this.onError = function (error) { return __awaiter(_this, void 0, void 0, function () {\n            var shouldRetry, _i, _a, observer;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0:\n                        this.retryCount += 1;\n                        return [4 /*yield*/, this.retryIf(this.retryCount, this.operation, error)];\n                    case 1:\n                        shouldRetry = _b.sent();\n                        if (shouldRetry) {\n                            this.scheduleRetry(this.delayFor(this.retryCount, this.operation, error));\n                            return [2 /*return*/];\n                        }\n                        this.error = error;\n                        for (_i = 0, _a = this.observers; _i < _a.length; _i++) {\n                            observer = _a[_i];\n                            if (!observer)\n                                continue;\n                            observer.error(error);\n                        }\n                        return [2 /*return*/];\n                }\n            });\n        }); };\n    }\n    /**\n     * Register a new observer for this operation.\n     *\n     * If the operation has previously emitted other events, they will be\n     * immediately triggered for the observer.\n     */\n    RetryableOperation.prototype.subscribe = function (observer) {\n        if (this.canceled) {\n            throw new Error(\"Subscribing to a retryable link that was canceled is not supported\");\n        }\n        this.observers.push(observer);\n        // If we've already begun, catch this observer up.\n        for (var _i = 0, _a = this.values; _i < _a.length; _i++) {\n            var value = _a[_i];\n            observer.next(value);\n        }\n        if (this.complete) {\n            observer.complete();\n        }\n        else if (this.error) {\n            observer.error(this.error);\n        }\n    };\n    /**\n     * Remove a previously registered observer from this operation.\n     *\n     * If no observers remain, the operation will stop retrying, and unsubscribe\n     * from its downstream link.\n     */\n    RetryableOperation.prototype.unsubscribe = function (observer) {\n        var index = this.observers.indexOf(observer);\n        if (index < 0) {\n            throw new Error(\"RetryLink BUG! Attempting to unsubscribe unknown observer!\");\n        }\n        // Note that we are careful not to change the order of length of the array,\n        // as we are often mid-iteration when calling this method.\n        this.observers[index] = null;\n        // If this is the last observer, we're done.\n        if (this.observers.every(function (o) { return o === null; })) {\n            this.cancel();\n        }\n    };\n    /**\n     * Start the initial request.\n     */\n    RetryableOperation.prototype.start = function () {\n        if (this.currentSubscription)\n            return; // Already started.\n        this.try();\n    };\n    /**\n     * Stop retrying for the operation, and cancel any in-progress requests.\n     */\n    RetryableOperation.prototype.cancel = function () {\n        if (this.currentSubscription) {\n            this.currentSubscription.unsubscribe();\n        }\n        clearTimeout(this.timerId);\n        this.timerId = undefined;\n        this.currentSubscription = null;\n        this.canceled = true;\n    };\n    RetryableOperation.prototype.try = function () {\n        this.currentSubscription = this.nextLink(this.operation).subscribe({\n            next: this.onNext,\n            error: this.onError,\n            complete: this.onComplete,\n        });\n    };\n    RetryableOperation.prototype.scheduleRetry = function (delay) {\n        var _this = this;\n        if (this.timerId) {\n            throw new Error(\"RetryLink BUG! Encountered overlapping retries\");\n        }\n        this.timerId = setTimeout(function () {\n            _this.timerId = undefined;\n            _this.try();\n        }, delay);\n    };\n    return RetryableOperation;\n}());\nvar RetryLink = /** @class */ (function (_super) {\n    __extends(RetryLink, _super);\n    function RetryLink(options) {\n        var _this = _super.call(this) || this;\n        var _a = options || {}, attempts = _a.attempts, delay = _a.delay;\n        _this.delayFor =\n            typeof delay === \"function\" ? delay : buildDelayFunction(delay);\n        _this.retryIf =\n            typeof attempts === \"function\" ? attempts : buildRetryFunction(attempts);\n        return _this;\n    }\n    RetryLink.prototype.request = function (operation, nextLink) {\n        var retryable = new RetryableOperation(operation, nextLink, this.delayFor, this.retryIf);\n        retryable.start();\n        return new Observable(function (observer) {\n            retryable.subscribe(observer);\n            return function () {\n                retryable.unsubscribe(observer);\n            };\n        });\n    };\n    return RetryLink;\n}(ApolloLink));\nexport { RetryLink };\n//# sourceMappingURL=retryLink.js.map","// This file is adapted from the graphql-ws npm package:\n// https://github.com/enisdenjo/graphql-ws\n//\n// Most of the file comes from that package's README; some other parts (such as\n// isLikeCloseEvent) come from its source.\n//\n// Here's the license of the original code:\n//\n// The MIT License (MIT)\n//\n// Copyright (c) 2020-2021 Denis Badurina\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\nimport { __assign, __extends } from \"tslib\";\nimport { print } from \"../../utilities/index.js\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { isNonNullObject, Observable } from \"../../utilities/index.js\";\nimport { ApolloError } from \"../../errors/index.js\";\n// https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close_event\nfunction isLikeCloseEvent(val) {\n    return isNonNullObject(val) && \"code\" in val && \"reason\" in val;\n}\n// https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/error_event\nfunction isLikeErrorEvent(err) {\n    var _a;\n    return isNonNullObject(err) && ((_a = err.target) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.CLOSED;\n}\nvar GraphQLWsLink = /** @class */ (function (_super) {\n    __extends(GraphQLWsLink, _super);\n    function GraphQLWsLink(client) {\n        var _this = _super.call(this) || this;\n        _this.client = client;\n        return _this;\n    }\n    GraphQLWsLink.prototype.request = function (operation) {\n        var _this = this;\n        return new Observable(function (observer) {\n            return _this.client.subscribe(__assign(__assign({}, operation), { query: print(operation.query) }), {\n                next: observer.next.bind(observer),\n                complete: observer.complete.bind(observer),\n                error: function (err) {\n                    if (err instanceof Error) {\n                        return observer.error(err);\n                    }\n                    var likeClose = isLikeCloseEvent(err);\n                    if (likeClose || isLikeErrorEvent(err)) {\n                        return observer.error(\n                        // reason will be available on clean closes\n                        new Error(\"Socket closed\".concat(likeClose ? \" with event \".concat(err.code) : \"\").concat(likeClose ? \" \".concat(err.reason) : \"\")));\n                    }\n                    return observer.error(new ApolloError({\n                        graphQLErrors: Array.isArray(err) ? err : [err],\n                    }));\n                },\n            });\n        });\n    };\n    return GraphQLWsLink;\n}(ApolloLink));\nexport { GraphQLWsLink };\n//# sourceMappingURL=index.js.map","import * as React from \"react\";\nimport { canUseSymbol } from \"../../utilities/index.js\";\nimport { invariant } from \"../../utilities/globals/index.js\";\n// To make sure Apollo Client doesn't create more than one React context\n// (which can lead to problems like having an Apollo Client instance added\n// in one context, then attempting to retrieve it from another different\n// context), a single Apollo context is created and tracked in global state.\nvar contextKey = canUseSymbol ? Symbol.for(\"__APOLLO_CONTEXT__\") : \"__APOLLO_CONTEXT__\";\nexport function getApolloContext() {\n    invariant(\"createContext\" in React, 45);\n    var context = React.createContext[contextKey];\n    if (!context) {\n        Object.defineProperty(React.createContext, contextKey, {\n            value: (context = React.createContext({})),\n            enumerable: false,\n            writable: false,\n            configurable: true,\n        });\n        context.displayName = \"ApolloContext\";\n    }\n    return context;\n}\n/**\n * @deprecated This function has no \"resetting\" effect since Apollo Client 3.4.12,\n * and will be removed in the next major version of Apollo Client.\n * If you want to get the Apollo Context, use `getApolloContext` instead.\n */\nexport var resetApolloContext = getApolloContext;\n//# sourceMappingURL=ApolloContext.js.map","import { __assign } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from \"react\";\nimport { getApolloContext } from \"./ApolloContext.js\";\nexport var ApolloProvider = function (_a) {\n    var client = _a.client, children = _a.children;\n    var ApolloContext = getApolloContext();\n    var parentContext = React.useContext(ApolloContext);\n    var context = React.useMemo(function () {\n        return __assign(__assign({}, parentContext), { client: client || parentContext.client });\n    }, [parentContext, client]);\n    invariant(context.client, 46);\n    return (React.createElement(ApolloContext.Provider, { value: context }, children));\n};\n//# sourceMappingURL=ApolloProvider.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from \"react\";\nimport { getApolloContext } from \"../context/index.js\";\nexport function useApolloClient(override) {\n    var context = React.useContext(getApolloContext());\n    var client = override || context.client;\n    invariant(!!client, 49);\n    return client;\n}\n//# sourceMappingURL=useApolloClient.js.map","import { __assign } from \"tslib\";\nimport * as React from \"react\";\nimport { mergeOptions } from \"../../utilities/index.js\";\nimport { useInternalState } from \"./useQuery.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\n// The following methods, when called will execute the query, regardless of\n// whether the useLazyQuery execute function was called before.\nvar EAGER_METHODS = [\n    \"refetch\",\n    \"reobserve\",\n    \"fetchMore\",\n    \"updateQuery\",\n    \"startPolling\",\n    \"subscribeToMore\",\n];\nexport function useLazyQuery(query, options) {\n    var _a;\n    var execOptionsRef = React.useRef();\n    var optionsRef = React.useRef();\n    var queryRef = React.useRef();\n    var merged = mergeOptions(options, execOptionsRef.current || {});\n    var document = (_a = merged === null || merged === void 0 ? void 0 : merged.query) !== null && _a !== void 0 ? _a : query;\n    // Use refs to track options and the used query to ensure the `execute`\n    // function remains referentially stable between renders.\n    optionsRef.current = merged;\n    queryRef.current = document;\n    var internalState = useInternalState(useApolloClient(options && options.client), document);\n    var useQueryResult = internalState.useQuery(__assign(__assign({}, merged), { skip: !execOptionsRef.current }));\n    var initialFetchPolicy = useQueryResult.observable.options.initialFetchPolicy ||\n        internalState.getDefaultFetchPolicy();\n    var result = Object.assign(useQueryResult, {\n        called: !!execOptionsRef.current,\n    });\n    // We use useMemo here to make sure the eager methods have a stable identity.\n    var eagerMethods = React.useMemo(function () {\n        var eagerMethods = {};\n        var _loop_1 = function (key) {\n            var method = result[key];\n            eagerMethods[key] = function () {\n                if (!execOptionsRef.current) {\n                    execOptionsRef.current = Object.create(null);\n                    // Only the first time populating execOptionsRef.current matters here.\n                    internalState.forceUpdateState();\n                }\n                // @ts-expect-error this is just too generic to type\n                return method.apply(this, arguments);\n            };\n        };\n        for (var _i = 0, EAGER_METHODS_1 = EAGER_METHODS; _i < EAGER_METHODS_1.length; _i++) {\n            var key = EAGER_METHODS_1[_i];\n            _loop_1(key);\n        }\n        return eagerMethods;\n    }, []);\n    Object.assign(result, eagerMethods);\n    var execute = React.useCallback(function (executeOptions) {\n        execOptionsRef.current =\n            executeOptions ? __assign(__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {\n                fetchPolicy: initialFetchPolicy,\n            };\n        var options = mergeOptions(optionsRef.current, __assign({ query: queryRef.current }, execOptionsRef.current));\n        var promise = internalState\n            .executeQuery(__assign(__assign({}, options), { skip: false }))\n            .then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });\n        // Because the return value of `useLazyQuery` is usually floated, we need\n        // to catch the promise to prevent unhandled rejections.\n        promise.catch(function () { });\n        return promise;\n    }, []);\n    return [execute, result];\n}\n//# sourceMappingURL=useLazyQuery.js.map","import { __assign } from \"tslib\";\nimport * as React from \"react\";\nimport { mergeOptions } from \"../../utilities/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { DocumentType, verifyDocumentType } from \"../parser/index.js\";\nimport { ApolloError } from \"../../errors/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nexport function useMutation(mutation, options) {\n    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);\n    verifyDocumentType(mutation, DocumentType.Mutation);\n    var _a = React.useState({\n        called: false,\n        loading: false,\n        client: client,\n    }), result = _a[0], setResult = _a[1];\n    var ref = React.useRef({\n        result: result,\n        mutationId: 0,\n        isMounted: true,\n        client: client,\n        mutation: mutation,\n        options: options,\n    });\n    // TODO: Trying to assign these in a useEffect or useLayoutEffect breaks\n    // higher-order components.\n    {\n        Object.assign(ref.current, { client: client, options: options, mutation: mutation });\n    }\n    var execute = React.useCallback(function (executeOptions) {\n        if (executeOptions === void 0) { executeOptions = {}; }\n        var _a = ref.current, options = _a.options, mutation = _a.mutation;\n        var baseOptions = __assign(__assign({}, options), { mutation: mutation });\n        var client = executeOptions.client || ref.current.client;\n        if (!ref.current.result.loading &&\n            !baseOptions.ignoreResults &&\n            ref.current.isMounted) {\n            setResult((ref.current.result = {\n                loading: true,\n                error: void 0,\n                data: void 0,\n                called: true,\n                client: client,\n            }));\n        }\n        var mutationId = ++ref.current.mutationId;\n        var clientOptions = mergeOptions(baseOptions, executeOptions);\n        return client\n            .mutate(clientOptions)\n            .then(function (response) {\n            var _a, _b;\n            var data = response.data, errors = response.errors;\n            var error = errors && errors.length > 0 ?\n                new ApolloError({ graphQLErrors: errors })\n                : void 0;\n            var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);\n            if (error && onError) {\n                onError(error, clientOptions);\n            }\n            if (mutationId === ref.current.mutationId &&\n                !clientOptions.ignoreResults) {\n                var result_1 = {\n                    called: true,\n                    loading: false,\n                    data: data,\n                    error: error,\n                    client: client,\n                };\n                if (ref.current.isMounted && !equal(ref.current.result, result_1)) {\n                    setResult((ref.current.result = result_1));\n                }\n            }\n            var onCompleted = executeOptions.onCompleted || ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onCompleted);\n            if (!error) {\n                onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response.data, clientOptions);\n            }\n            return response;\n        })\n            .catch(function (error) {\n            var _a;\n            if (mutationId === ref.current.mutationId && ref.current.isMounted) {\n                var result_2 = {\n                    loading: false,\n                    error: error,\n                    data: void 0,\n                    called: true,\n                    client: client,\n                };\n                if (!equal(ref.current.result, result_2)) {\n                    setResult((ref.current.result = result_2));\n                }\n            }\n            var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);\n            if (onError) {\n                onError(error, clientOptions);\n                // TODO(brian): why are we returning this here???\n                return { data: void 0, errors: error };\n            }\n            throw error;\n        });\n    }, []);\n    var reset = React.useCallback(function () {\n        if (ref.current.isMounted) {\n            var result_3 = { called: false, loading: false, client: client };\n            Object.assign(ref.current, { mutationId: 0, result: result_3 });\n            setResult(result_3);\n        }\n    }, []);\n    React.useEffect(function () {\n        ref.current.isMounted = true;\n        return function () {\n            ref.current.isMounted = false;\n        };\n    }, []);\n    return [execute, __assign({ reset: reset }, result)];\n}\n//# sourceMappingURL=useMutation.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from \"react\";\nimport { canUseLayoutEffect } from \"../../utilities/index.js\";\nvar didWarnUncachedGetSnapshot = false;\n// Prevent webpack from complaining about our feature detection of the\n// useSyncExternalStore property of the React namespace, which is expected not\n// to exist when using React 17 and earlier, and that's fine.\nvar uSESKey = \"useSyncExternalStore\";\nvar realHook = React[uSESKey];\n// Adapted from https://www.npmjs.com/package/use-sync-external-store, with\n// Apollo Client deviations called out by \"// DEVIATION ...\" comments.\n// When/if React.useSyncExternalStore is defined, delegate fully to it.\nexport var useSyncExternalStore = realHook ||\n    (function (subscribe, getSnapshot, getServerSnapshot) {\n        // Read the current snapshot from the store on every render. Again, this\n        // breaks the rules of React, and only works here because of specific\n        // implementation details, most importantly that updates are\n        // always synchronous.\n        var value = getSnapshot();\n        if (\n        // DEVIATION: Using __DEV__\n        globalThis.__DEV__ !== false &&\n            !didWarnUncachedGetSnapshot &&\n            // DEVIATION: Not using Object.is because we know our snapshots will never\n            // be exotic primitive values like NaN, which is !== itself.\n            value !== getSnapshot()) {\n            didWarnUncachedGetSnapshot = true;\n            // DEVIATION: Using invariant.error instead of console.error directly.\n            globalThis.__DEV__ !== false && invariant.error(58);\n        }\n        // Because updates are synchronous, we don't queue them. Instead we force a\n        // re-render whenever the subscribed state changes by updating an some\n        // arbitrary useState hook. Then, during render, we call getSnapshot to read\n        // the current value.\n        //\n        // Because we don't actually use the state returned by the useState hook, we\n        // can save a bit of memory by storing other stuff in that slot.\n        //\n        // To implement the early bailout, we need to track some things on a mutable\n        // object. Usually, we would put that in a useRef hook, but we can stash it in\n        // our useState hook instead.\n        //\n        // To force a re-render, we call forceUpdate({inst}). That works because the\n        // new object always fails an equality check.\n        var _a = React.useState({\n            inst: { value: value, getSnapshot: getSnapshot },\n        }), inst = _a[0].inst, forceUpdate = _a[1];\n        // Track the latest getSnapshot function with a ref. This needs to be updated\n        // in the layout phase so we can access it during the tearing check that\n        // happens on subscribe.\n        if (canUseLayoutEffect) {\n            // DEVIATION: We avoid calling useLayoutEffect when !canUseLayoutEffect,\n            // which may seem like a conditional hook, but this code ends up behaving\n            // unconditionally (one way or the other) because canUseLayoutEffect is\n            // constant.\n            React.useLayoutEffect(function () {\n                Object.assign(inst, { value: value, getSnapshot: getSnapshot });\n                // Whenever getSnapshot or subscribe changes, we need to check in the\n                // commit phase if there was an interleaved mutation. In concurrent mode\n                // this can happen all the time, but even in synchronous mode, an earlier\n                // effect may have mutated the store.\n                if (checkIfSnapshotChanged(inst)) {\n                    // Force a re-render.\n                    forceUpdate({ inst: inst });\n                }\n            }, [subscribe, value, getSnapshot]);\n        }\n        else {\n            Object.assign(inst, { value: value, getSnapshot: getSnapshot });\n        }\n        React.useEffect(function () {\n            // Check for changes right before subscribing. Subsequent changes will be\n            // detected in the subscription handler.\n            if (checkIfSnapshotChanged(inst)) {\n                // Force a re-render.\n                forceUpdate({ inst: inst });\n            }\n            // Subscribe to the store and return a clean-up function.\n            return subscribe(function handleStoreChange() {\n                // TODO: Because there is no cross-renderer API for batching updates, it's\n                // up to the consumer of this library to wrap their subscription event\n                // with unstable_batchedUpdates. Should we try to detect when this isn't\n                // the case and print a warning in development?\n                // The store changed. Check if the snapshot changed since the last time we\n                // read from the store.\n                if (checkIfSnapshotChanged(inst)) {\n                    // Force a re-render.\n                    forceUpdate({ inst: inst });\n                }\n            });\n        }, [subscribe]);\n        return value;\n    });\nfunction checkIfSnapshotChanged(_a) {\n    var value = _a.value, getSnapshot = _a.getSnapshot;\n    try {\n        return value !== getSnapshot();\n    }\n    catch (_b) {\n        return true;\n    }\n}\n//# sourceMappingURL=useSyncExternalStore.js.map","import { __assign, __rest } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from \"react\";\nimport { useSyncExternalStore } from \"./useSyncExternalStore.js\";\nimport { equal } from \"@wry/equality\";\nimport { mergeOptions } from \"../../utilities/index.js\";\nimport { getApolloContext } from \"../context/index.js\";\nimport { ApolloError } from \"../../errors/index.js\";\nimport { NetworkStatus } from \"../../core/index.js\";\nimport { DocumentType, verifyDocumentType } from \"../parser/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nimport { canUseWeakMap, compact, isNonEmptyArray, maybeDeepFreeze, } from \"../../utilities/index.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function useQuery(query, options) {\n    if (options === void 0) { options = Object.create(null); }\n    return useInternalState(useApolloClient(options.client), query).useQuery(options);\n}\nexport function useInternalState(client, query) {\n    var stateRef = React.useRef();\n    if (!stateRef.current ||\n        client !== stateRef.current.client ||\n        query !== stateRef.current.query) {\n        stateRef.current = new InternalState(client, query, stateRef.current);\n    }\n    var state = stateRef.current;\n    // By default, InternalState.prototype.forceUpdate is an empty function, but\n    // we replace it here (before anyone has had a chance to see this state yet)\n    // with a function that unconditionally forces an update, using the latest\n    // setTick function. Updating this state by calling state.forceUpdate is the\n    // only way we trigger React component updates (no other useState calls within\n    // the InternalState class).\n    state.forceUpdateState = React.useReducer(function (tick) { return tick + 1; }, 0)[1];\n    return state;\n}\nvar InternalState = /** @class */ (function () {\n    function InternalState(client, query, previous) {\n        var _this = this;\n        this.client = client;\n        this.query = query;\n        /**\n         * Will be overwritten by the `useSyncExternalStore` \"force update\" method\n         * whenever it is available and reset to `forceUpdateState` when it isn't.\n         */\n        this.forceUpdate = function () { return _this.forceUpdateState(); };\n        this.ssrDisabledResult = maybeDeepFreeze({\n            loading: true,\n            data: void 0,\n            error: void 0,\n            networkStatus: NetworkStatus.loading,\n        });\n        this.skipStandbyResult = maybeDeepFreeze({\n            loading: false,\n            data: void 0,\n            error: void 0,\n            networkStatus: NetworkStatus.ready,\n        });\n        // This cache allows the referential stability of this.result (as returned by\n        // getCurrentResult) to translate into referential stability of the resulting\n        // QueryResult object returned by toQueryResult.\n        this.toQueryResultCache = new (canUseWeakMap ? WeakMap : Map)();\n        verifyDocumentType(query, DocumentType.Query);\n        // Reuse previousData from previous InternalState (if any) to provide\n        // continuity of previousData even if/when the query or client changes.\n        var previousResult = previous && previous.result;\n        var previousData = previousResult && previousResult.data;\n        if (previousData) {\n            this.previousData = previousData;\n        }\n    }\n    /**\n     * Forces an update using local component state.\n     * As this is not batched with `useSyncExternalStore` updates,\n     * this is only used as a fallback if the `useSyncExternalStore` \"force update\"\n     * method is not registered at the moment.\n     * See https://github.com/facebook/react/issues/25191\n     *  */\n    InternalState.prototype.forceUpdateState = function () {\n        // Replaced (in useInternalState) with a method that triggers an update.\n        globalThis.__DEV__ !== false && invariant.warn(50);\n    };\n    InternalState.prototype.executeQuery = function (options) {\n        var _this = this;\n        var _a;\n        if (options.query) {\n            Object.assign(this, { query: options.query });\n        }\n        this.watchQueryOptions = this.createWatchQueryOptions((this.queryHookOptions = options));\n        var concast = this.observable.reobserveAsConcast(this.getObsQueryOptions());\n        // Make sure getCurrentResult returns a fresh ApolloQueryResult<TData>,\n        // but save the current data as this.previousData, just like setResult\n        // usually does.\n        this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;\n        this.result = void 0;\n        this.forceUpdate();\n        return new Promise(function (resolve) {\n            var result;\n            // Subscribe to the concast independently of the ObservableQuery in case\n            // the component gets unmounted before the promise resolves. This prevents\n            // the concast from terminating early and resolving with `undefined` when\n            // there are no more subscribers for the concast.\n            concast.subscribe({\n                next: function (value) {\n                    result = value;\n                },\n                error: function () {\n                    resolve(_this.toQueryResult(_this.observable.getCurrentResult()));\n                },\n                complete: function () {\n                    resolve(_this.toQueryResult(result));\n                },\n            });\n        });\n    };\n    // Methods beginning with use- should be called according to the standard\n    // rules of React hooks: only at the top level of the calling function, and\n    // without any dynamic conditional logic.\n    InternalState.prototype.useQuery = function (options) {\n        var _this = this;\n        // The renderPromises field gets initialized here in the useQuery method, at\n        // the beginning of everything (for a given component rendering, at least),\n        // so we can safely use this.renderPromises in other/later InternalState\n        // methods without worrying it might be uninitialized. Even after\n        // initialization, this.renderPromises is usually undefined (unless SSR is\n        // happening), but that's fine as long as it has been initialized that way,\n        // rather than left uninitialized.\n        this.renderPromises = React.useContext(getApolloContext()).renderPromises;\n        this.useOptions(options);\n        var obsQuery = this.useObservableQuery();\n        var result = useSyncExternalStore(React.useCallback(function (handleStoreChange) {\n            if (_this.renderPromises) {\n                return function () { };\n            }\n            _this.forceUpdate = handleStoreChange;\n            var onNext = function () {\n                var previousResult = _this.result;\n                // We use `getCurrentResult()` instead of the onNext argument because\n                // the values differ slightly. Specifically, loading results will have\n                // an empty object for data instead of `undefined` for some reason.\n                var result = obsQuery.getCurrentResult();\n                // Make sure we're not attempting to re-render similar results\n                if (previousResult &&\n                    previousResult.loading === result.loading &&\n                    previousResult.networkStatus === result.networkStatus &&\n                    equal(previousResult.data, result.data)) {\n                    return;\n                }\n                _this.setResult(result);\n            };\n            var onError = function (error) {\n                subscription.unsubscribe();\n                subscription = obsQuery.resubscribeAfterError(onNext, onError);\n                if (!hasOwnProperty.call(error, \"graphQLErrors\")) {\n                    // The error is not a GraphQL error\n                    throw error;\n                }\n                var previousResult = _this.result;\n                if (!previousResult ||\n                    (previousResult && previousResult.loading) ||\n                    !equal(error, previousResult.error)) {\n                    _this.setResult({\n                        data: (previousResult && previousResult.data),\n                        error: error,\n                        loading: false,\n                        networkStatus: NetworkStatus.error,\n                    });\n                }\n            };\n            var subscription = obsQuery.subscribe(onNext, onError);\n            // Do the \"unsubscribe\" with a short delay.\n            // This way, an existing subscription can be reused without an additional\n            // request if \"unsubscribe\"  and \"resubscribe\" to the same ObservableQuery\n            // happen in very fast succession.\n            return function () {\n                setTimeout(function () { return subscription.unsubscribe(); });\n                _this.forceUpdate = function () { return _this.forceUpdateState(); };\n            };\n        }, [\n            // We memoize the subscribe function using useCallback and the following\n            // dependency keys, because the subscribe function reference is all that\n            // useSyncExternalStore uses internally as a dependency key for the\n            // useEffect ultimately responsible for the subscription, so we are\n            // effectively passing this dependency array to that useEffect buried\n            // inside useSyncExternalStore, as desired.\n            obsQuery,\n            this.renderPromises,\n            this.client.disableNetworkFetches,\n        ]), function () { return _this.getCurrentResult(); }, function () { return _this.getCurrentResult(); });\n        // TODO Remove this method when we remove support for options.partialRefetch.\n        this.unsafeHandlePartialRefetch(result);\n        return this.toQueryResult(result);\n    };\n    InternalState.prototype.useOptions = function (options) {\n        var _a;\n        var watchQueryOptions = this.createWatchQueryOptions((this.queryHookOptions = options));\n        // Update this.watchQueryOptions, but only when they have changed, which\n        // allows us to depend on the referential stability of\n        // this.watchQueryOptions elsewhere.\n        var currentWatchQueryOptions = this.watchQueryOptions;\n        if (!equal(watchQueryOptions, currentWatchQueryOptions)) {\n            this.watchQueryOptions = watchQueryOptions;\n            if (currentWatchQueryOptions && this.observable) {\n                // Though it might be tempting to postpone this reobserve call to the\n                // useEffect block, we need getCurrentResult to return an appropriate\n                // loading:true result synchronously (later within the same call to\n                // useQuery). Since we already have this.observable here (not true for\n                // the very first call to useQuery), we are not initiating any new\n                // subscriptions, though it does feel less than ideal that reobserve\n                // (potentially) kicks off a network request (for example, when the\n                // variables have changed), which is technically a side-effect.\n                this.observable.reobserve(this.getObsQueryOptions());\n                // Make sure getCurrentResult returns a fresh ApolloQueryResult<TData>,\n                // but save the current data as this.previousData, just like setResult\n                // usually does.\n                this.previousData = ((_a = this.result) === null || _a === void 0 ? void 0 : _a.data) || this.previousData;\n                this.result = void 0;\n            }\n        }\n        // Make sure state.onCompleted and state.onError always reflect the latest\n        // options.onCompleted and options.onError callbacks provided to useQuery,\n        // since those functions are often recreated every time useQuery is called.\n        // Like the forceUpdate method, the versions of these methods inherited from\n        // InternalState.prototype are empty no-ops, but we can override them on the\n        // base state object (without modifying the prototype).\n        this.onCompleted =\n            options.onCompleted || InternalState.prototype.onCompleted;\n        this.onError = options.onError || InternalState.prototype.onError;\n        if ((this.renderPromises || this.client.disableNetworkFetches) &&\n            this.queryHookOptions.ssr === false &&\n            !this.queryHookOptions.skip) {\n            // If SSR has been explicitly disabled, and this function has been called\n            // on the server side, return the default loading state.\n            this.result = this.ssrDisabledResult;\n        }\n        else if (this.queryHookOptions.skip ||\n            this.watchQueryOptions.fetchPolicy === \"standby\") {\n            // When skipping a query (ie. we're not querying for data but still want to\n            // render children), make sure the `data` is cleared out and `loading` is\n            // set to `false` (since we aren't loading anything).\n            //\n            // NOTE: We no longer think this is the correct behavior. Skipping should\n            // not automatically set `data` to `undefined`, but instead leave the\n            // previous data in place. In other words, skipping should not mandate that\n            // previously received data is all of a sudden removed. Unfortunately,\n            // changing this is breaking, so we'll have to wait until Apollo Client 4.0\n            // to address this.\n            this.result = this.skipStandbyResult;\n        }\n        else if (this.result === this.ssrDisabledResult ||\n            this.result === this.skipStandbyResult) {\n            this.result = void 0;\n        }\n    };\n    InternalState.prototype.getObsQueryOptions = function () {\n        var toMerge = [];\n        var globalDefaults = this.client.defaultOptions.watchQuery;\n        if (globalDefaults)\n            toMerge.push(globalDefaults);\n        if (this.queryHookOptions.defaultOptions) {\n            toMerge.push(this.queryHookOptions.defaultOptions);\n        }\n        // We use compact rather than mergeOptions for this part of the merge,\n        // because we want watchQueryOptions.variables (if defined) to replace\n        // this.observable.options.variables whole. This replacement allows\n        // removing variables by removing them from the variables input to\n        // useQuery. If the variables were always merged together (rather than\n        // replaced), there would be no way to remove existing variables.\n        // However, the variables from options.defaultOptions and globalDefaults\n        // (if provided) should be merged, to ensure individual defaulted\n        // variables always have values, if not otherwise defined in\n        // observable.options or watchQueryOptions.\n        toMerge.push(compact(this.observable && this.observable.options, this.watchQueryOptions));\n        return toMerge.reduce(mergeOptions);\n    };\n    // A function to massage options before passing them to ObservableQuery.\n    InternalState.prototype.createWatchQueryOptions = function (_a) {\n        var _b;\n        if (_a === void 0) { _a = {}; }\n        var skip = _a.skip, ssr = _a.ssr, onCompleted = _a.onCompleted, onError = _a.onError, defaultOptions = _a.defaultOptions, \n        // The above options are useQuery-specific, so this ...otherOptions spread\n        // makes otherOptions almost a WatchQueryOptions object, except for the\n        // query property that we add below.\n        otherOptions = __rest(_a, [\"skip\", \"ssr\", \"onCompleted\", \"onError\", \"defaultOptions\"]);\n        // This Object.assign is safe because otherOptions is a fresh ...rest object\n        // that did not exist until just now, so modifications are still allowed.\n        var watchQueryOptions = Object.assign(otherOptions, { query: this.query });\n        if (this.renderPromises &&\n            (watchQueryOptions.fetchPolicy === \"network-only\" ||\n                watchQueryOptions.fetchPolicy === \"cache-and-network\")) {\n            // this behavior was added to react-apollo without explanation in this PR\n            // https://github.com/apollographql/react-apollo/pull/1579\n            watchQueryOptions.fetchPolicy = \"cache-first\";\n        }\n        if (!watchQueryOptions.variables) {\n            watchQueryOptions.variables = {};\n        }\n        if (skip) {\n            var _c = watchQueryOptions.fetchPolicy, fetchPolicy = _c === void 0 ? this.getDefaultFetchPolicy() : _c, _d = watchQueryOptions.initialFetchPolicy, initialFetchPolicy = _d === void 0 ? fetchPolicy : _d;\n            // When skipping, we set watchQueryOptions.fetchPolicy initially to\n            // \"standby\", but we also need/want to preserve the initial non-standby\n            // fetchPolicy that would have been used if not skipping.\n            Object.assign(watchQueryOptions, {\n                initialFetchPolicy: initialFetchPolicy,\n                fetchPolicy: \"standby\",\n            });\n        }\n        else if (!watchQueryOptions.fetchPolicy) {\n            watchQueryOptions.fetchPolicy =\n                ((_b = this.observable) === null || _b === void 0 ? void 0 : _b.options.initialFetchPolicy) ||\n                    this.getDefaultFetchPolicy();\n        }\n        return watchQueryOptions;\n    };\n    InternalState.prototype.getDefaultFetchPolicy = function () {\n        var _a, _b;\n        return (((_a = this.queryHookOptions.defaultOptions) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||\n            ((_b = this.client.defaultOptions.watchQuery) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||\n            \"cache-first\");\n    };\n    // Defining these methods as no-ops on the prototype allows us to call\n    // state.onCompleted and/or state.onError without worrying about whether a\n    // callback was provided.\n    InternalState.prototype.onCompleted = function (data) { };\n    InternalState.prototype.onError = function (error) { };\n    InternalState.prototype.useObservableQuery = function () {\n        // See if there is an existing observable that was used to fetch the same\n        // data and if so, use it instead since it will contain the proper queryId\n        // to fetch the result set. This is used during SSR.\n        var obsQuery = (this.observable =\n            (this.renderPromises &&\n                this.renderPromises.getSSRObservable(this.watchQueryOptions)) ||\n                this.observable || // Reuse this.observable if possible (and not SSR)\n                this.client.watchQuery(this.getObsQueryOptions()));\n        this.obsQueryFields = React.useMemo(function () { return ({\n            refetch: obsQuery.refetch.bind(obsQuery),\n            reobserve: obsQuery.reobserve.bind(obsQuery),\n            fetchMore: obsQuery.fetchMore.bind(obsQuery),\n            updateQuery: obsQuery.updateQuery.bind(obsQuery),\n            startPolling: obsQuery.startPolling.bind(obsQuery),\n            stopPolling: obsQuery.stopPolling.bind(obsQuery),\n            subscribeToMore: obsQuery.subscribeToMore.bind(obsQuery),\n        }); }, [obsQuery]);\n        var ssrAllowed = !(this.queryHookOptions.ssr === false || this.queryHookOptions.skip);\n        if (this.renderPromises && ssrAllowed) {\n            this.renderPromises.registerSSRObservable(obsQuery);\n            if (obsQuery.getCurrentResult().loading) {\n                // TODO: This is a legacy API which could probably be cleaned up\n                this.renderPromises.addObservableQueryPromise(obsQuery);\n            }\n        }\n        return obsQuery;\n    };\n    InternalState.prototype.setResult = function (nextResult) {\n        var previousResult = this.result;\n        if (previousResult && previousResult.data) {\n            this.previousData = previousResult.data;\n        }\n        this.result = nextResult;\n        // Calling state.setResult always triggers an update, though some call sites\n        // perform additional equality checks before committing to an update.\n        this.forceUpdate();\n        this.handleErrorOrCompleted(nextResult, previousResult);\n    };\n    InternalState.prototype.handleErrorOrCompleted = function (result, previousResult) {\n        var _this = this;\n        if (!result.loading) {\n            var error_1 = this.toApolloError(result);\n            // wait a tick in case we are in the middle of rendering a component\n            Promise.resolve()\n                .then(function () {\n                if (error_1) {\n                    _this.onError(error_1);\n                }\n                else if (result.data &&\n                    (previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus) !== result.networkStatus &&\n                    result.networkStatus === NetworkStatus.ready) {\n                    _this.onCompleted(result.data);\n                }\n            })\n                .catch(function (error) {\n                globalThis.__DEV__ !== false && invariant.warn(error);\n            });\n        }\n    };\n    InternalState.prototype.toApolloError = function (result) {\n        return isNonEmptyArray(result.errors) ?\n            new ApolloError({ graphQLErrors: result.errors })\n            : result.error;\n    };\n    InternalState.prototype.getCurrentResult = function () {\n        // Using this.result as a cache ensures getCurrentResult continues returning\n        // the same (===) result object, unless state.setResult has been called, or\n        // we're doing server rendering and therefore override the result below.\n        if (!this.result) {\n            this.handleErrorOrCompleted((this.result = this.observable.getCurrentResult()));\n        }\n        return this.result;\n    };\n    InternalState.prototype.toQueryResult = function (result) {\n        var queryResult = this.toQueryResultCache.get(result);\n        if (queryResult)\n            return queryResult;\n        var data = result.data, partial = result.partial, resultWithoutPartial = __rest(result, [\"data\", \"partial\"]);\n        this.toQueryResultCache.set(result, (queryResult = __assign(__assign(__assign({ data: data }, resultWithoutPartial), this.obsQueryFields), { client: this.client, observable: this.observable, variables: this.observable.variables, called: !this.queryHookOptions.skip, previousData: this.previousData })));\n        if (!queryResult.error && isNonEmptyArray(result.errors)) {\n            // Until a set naming convention for networkError and graphQLErrors is\n            // decided upon, we map errors (graphQLErrors) to the error options.\n            // TODO: Is it possible for both result.error and result.errors to be\n            // defined here?\n            queryResult.error = new ApolloError({ graphQLErrors: result.errors });\n        }\n        return queryResult;\n    };\n    InternalState.prototype.unsafeHandlePartialRefetch = function (result) {\n        // WARNING: SIDE-EFFECTS IN THE RENDER FUNCTION\n        //\n        // TODO: This code should be removed when the partialRefetch option is\n        // removed. I was unable to get this hook to behave reasonably in certain\n        // edge cases when this block was put in an effect.\n        if (result.partial &&\n            this.queryHookOptions.partialRefetch &&\n            !result.loading &&\n            (!result.data || Object.keys(result.data).length === 0) &&\n            this.observable.options.fetchPolicy !== \"cache-only\") {\n            Object.assign(result, {\n                loading: true,\n                networkStatus: NetworkStatus.refetch,\n            });\n            this.observable.refetch();\n        }\n    };\n    return InternalState;\n}());\n//# sourceMappingURL=useQuery.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from \"react\";\nimport { equal } from \"@wry/equality\";\nimport { DocumentType, verifyDocumentType } from \"../parser/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nexport function useSubscription(subscription, options) {\n    var hasIssuedDeprecationWarningRef = React.useRef(false);\n    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);\n    verifyDocumentType(subscription, DocumentType.Subscription);\n    var _a = React.useState({\n        loading: !(options === null || options === void 0 ? void 0 : options.skip),\n        error: void 0,\n        data: void 0,\n        variables: options === null || options === void 0 ? void 0 : options.variables,\n    }), result = _a[0], setResult = _a[1];\n    if (!hasIssuedDeprecationWarningRef.current) {\n        hasIssuedDeprecationWarningRef.current = true;\n        if (options === null || options === void 0 ? void 0 : options.onSubscriptionData) {\n            globalThis.__DEV__ !== false && invariant.warn(options.onData ? 52 : 53);\n        }\n        if (options === null || options === void 0 ? void 0 : options.onSubscriptionComplete) {\n            globalThis.__DEV__ !== false && invariant.warn(options.onComplete ? 54 : 55);\n        }\n    }\n    var _b = React.useState(function () {\n        if (options === null || options === void 0 ? void 0 : options.skip) {\n            return null;\n        }\n        return client.subscribe({\n            query: subscription,\n            variables: options === null || options === void 0 ? void 0 : options.variables,\n            fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,\n            context: options === null || options === void 0 ? void 0 : options.context,\n        });\n    }), observable = _b[0], setObservable = _b[1];\n    var canResetObservableRef = React.useRef(false);\n    React.useEffect(function () {\n        return function () {\n            canResetObservableRef.current = true;\n        };\n    }, []);\n    var ref = React.useRef({ client: client, subscription: subscription, options: options });\n    React.useEffect(function () {\n        var _a, _b, _c, _d;\n        var shouldResubscribe = options === null || options === void 0 ? void 0 : options.shouldResubscribe;\n        if (typeof shouldResubscribe === \"function\") {\n            shouldResubscribe = !!shouldResubscribe(options);\n        }\n        if (options === null || options === void 0 ? void 0 : options.skip) {\n            if (!(options === null || options === void 0 ? void 0 : options.skip) !== !((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.skip) ||\n                canResetObservableRef.current) {\n                setResult({\n                    loading: false,\n                    data: void 0,\n                    error: void 0,\n                    variables: options === null || options === void 0 ? void 0 : options.variables,\n                });\n                setObservable(null);\n                canResetObservableRef.current = false;\n            }\n        }\n        else if ((shouldResubscribe !== false &&\n            (client !== ref.current.client ||\n                subscription !== ref.current.subscription ||\n                (options === null || options === void 0 ? void 0 : options.fetchPolicy) !== ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.fetchPolicy) ||\n                !(options === null || options === void 0 ? void 0 : options.skip) !== !((_c = ref.current.options) === null || _c === void 0 ? void 0 : _c.skip) ||\n                !equal(options === null || options === void 0 ? void 0 : options.variables, (_d = ref.current.options) === null || _d === void 0 ? void 0 : _d.variables))) ||\n            canResetObservableRef.current) {\n            setResult({\n                loading: true,\n                data: void 0,\n                error: void 0,\n                variables: options === null || options === void 0 ? void 0 : options.variables,\n            });\n            setObservable(client.subscribe({\n                query: subscription,\n                variables: options === null || options === void 0 ? void 0 : options.variables,\n                fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,\n                context: options === null || options === void 0 ? void 0 : options.context,\n            }));\n            canResetObservableRef.current = false;\n        }\n        Object.assign(ref.current, { client: client, subscription: subscription, options: options });\n    }, [client, subscription, options, canResetObservableRef.current]);\n    React.useEffect(function () {\n        if (!observable) {\n            return;\n        }\n        var subscriptionStopped = false;\n        var subscription = observable.subscribe({\n            next: function (fetchResult) {\n                var _a, _b;\n                if (subscriptionStopped) {\n                    return;\n                }\n                var result = {\n                    loading: false,\n                    // TODO: fetchResult.data can be null but SubscriptionResult.data\n                    // expects TData | undefined only\n                    data: fetchResult.data,\n                    error: void 0,\n                    variables: options === null || options === void 0 ? void 0 : options.variables,\n                };\n                setResult(result);\n                if ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onData) {\n                    ref.current.options.onData({\n                        client: client,\n                        data: result,\n                    });\n                }\n                else if ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onSubscriptionData) {\n                    ref.current.options.onSubscriptionData({\n                        client: client,\n                        subscriptionData: result,\n                    });\n                }\n            },\n            error: function (error) {\n                var _a, _b;\n                if (!subscriptionStopped) {\n                    setResult({\n                        loading: false,\n                        data: void 0,\n                        error: error,\n                        variables: options === null || options === void 0 ? void 0 : options.variables,\n                    });\n                    (_b = (_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);\n                }\n            },\n            complete: function () {\n                var _a, _b;\n                if (!subscriptionStopped) {\n                    if ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onComplete) {\n                        ref.current.options.onComplete();\n                    }\n                    else if ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onSubscriptionComplete) {\n                        ref.current.options.onSubscriptionComplete();\n                    }\n                }\n            },\n        });\n        return function () {\n            // immediately stop receiving subscription values, but do not unsubscribe\n            // until after a short delay in case another useSubscription hook is\n            // reusing the same underlying observable and is about to subscribe\n            subscriptionStopped = true;\n            setTimeout(function () {\n                subscription.unsubscribe();\n            });\n        };\n    }, [observable]);\n    return result;\n}\n//# sourceMappingURL=useSubscription.js.map","export function createFulfilledPromise(value) {\n    var promise = Promise.resolve(value);\n    promise.status = \"fulfilled\";\n    promise.value = value;\n    return promise;\n}\nexport function createRejectedPromise(reason) {\n    var promise = Promise.reject(reason);\n    // prevent potential edge cases leaking unhandled error rejections\n    promise.catch(function () { });\n    promise.status = \"rejected\";\n    promise.reason = reason;\n    return promise;\n}\nexport function isStatefulPromise(promise) {\n    return \"status\" in promise;\n}\nexport function wrapPromiseWithState(promise) {\n    if (isStatefulPromise(promise)) {\n        return promise;\n    }\n    var pendingPromise = promise;\n    pendingPromise.status = \"pending\";\n    pendingPromise.then(function (value) {\n        if (pendingPromise.status === \"pending\") {\n            var fulfilledPromise = pendingPromise;\n            fulfilledPromise.status = \"fulfilled\";\n            fulfilledPromise.value = value;\n        }\n    }, function (reason) {\n        if (pendingPromise.status === \"pending\") {\n            var rejectedPromise = pendingPromise;\n            rejectedPromise.status = \"rejected\";\n            rejectedPromise.reason = reason;\n        }\n    });\n    return promise;\n}\n//# sourceMappingURL=decoration.js.map","import { wrapPromiseWithState } from \"../../../utilities/index.js\";\nimport * as React from \"react\";\n// Prevent webpack from complaining about our feature detection of the\n// use property of the React namespace, which is expected not\n// to exist when using current stable versions, and that's fine.\nvar useKey = \"use\";\nvar realHook = React[useKey];\n// This is named with two underscores to allow this hook to evade typical rules of\n// hooks (i.e. it can be used conditionally)\nexport var __use = realHook ||\n    function __use(promise) {\n        var statefulPromise = wrapPromiseWithState(promise);\n        switch (statefulPromise.status) {\n            case \"pending\":\n                throw statefulPromise;\n            case \"rejected\":\n                throw statefulPromise.reason;\n            case \"fulfilled\":\n                return statefulPromise.value;\n        }\n    };\n//# sourceMappingURL=__use.js.map","import * as React from \"react\";\nimport { equal } from \"@wry/equality\";\nexport function useDeepMemo(memoFn, deps) {\n    var ref = React.useRef();\n    if (!ref.current || !equal(ref.current.deps, deps)) {\n        ref.current = { value: memoFn(), deps: deps };\n    }\n    return ref.current.value;\n}\n//# sourceMappingURL=useDeepMemo.js.map","import { __assign } from \"tslib\";\nimport { equal } from \"@wry/equality\";\nimport { isNetworkRequestSettled } from \"../../core/index.js\";\nimport { createFulfilledPromise, createRejectedPromise, } from \"../../utilities/index.js\";\nvar QUERY_REFERENCE_SYMBOL = Symbol();\nexport function wrapQueryRef(internalQueryRef) {\n    var _a;\n    return _a = {}, _a[QUERY_REFERENCE_SYMBOL] = internalQueryRef, _a;\n}\nexport function unwrapQueryRef(queryRef) {\n    return queryRef[QUERY_REFERENCE_SYMBOL];\n}\nvar OBSERVED_CHANGED_OPTIONS = [\n    \"canonizeResults\",\n    \"context\",\n    \"errorPolicy\",\n    \"fetchPolicy\",\n    \"refetchWritePolicy\",\n    \"returnPartialData\",\n];\nvar InternalQueryReference = /** @class */ (function () {\n    function InternalQueryReference(observable, options) {\n        var _this = this;\n        this.listeners = new Set();\n        this.status = \"loading\";\n        this.references = 0;\n        this.handleNext = this.handleNext.bind(this);\n        this.handleError = this.handleError.bind(this);\n        this.dispose = this.dispose.bind(this);\n        this.observable = observable;\n        // Don't save this result as last result to prevent delivery of last result\n        // when first subscribing\n        this.result = observable.getCurrentResult(false);\n        this.key = options.key;\n        if (options.onDispose) {\n            this.onDispose = options.onDispose;\n        }\n        if (isNetworkRequestSettled(this.result.networkStatus) ||\n            (this.result.data &&\n                (!this.result.partial || this.watchQueryOptions.returnPartialData))) {\n            this.promise = createFulfilledPromise(this.result);\n            this.status = \"idle\";\n        }\n        else {\n            this.promise = new Promise(function (resolve, reject) {\n                _this.resolve = resolve;\n                _this.reject = reject;\n            });\n        }\n        this.subscription = observable\n            .filter(function (_a) {\n            var data = _a.data;\n            return !equal(data, {});\n        })\n            .subscribe({\n            next: this.handleNext,\n            error: this.handleError,\n        });\n        // Start a timer that will automatically dispose of the query if the\n        // suspended resource does not use this queryRef in the given time. This\n        // helps prevent memory leaks when a component has unmounted before the\n        // query has finished loading.\n        var startDisposeTimer = function () {\n            var _a;\n            if (!_this.references) {\n                _this.autoDisposeTimeoutId = setTimeout(_this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);\n            }\n        };\n        // We wait until the request has settled to ensure we don't dispose of the\n        // query ref before the request finishes, otherwise we would leave the\n        // promise in a pending state rendering the suspense boundary indefinitely.\n        this.promise.then(startDisposeTimer, startDisposeTimer);\n    }\n    Object.defineProperty(InternalQueryReference.prototype, \"watchQueryOptions\", {\n        get: function () {\n            return this.observable.options;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    InternalQueryReference.prototype.retain = function () {\n        var _this = this;\n        this.references++;\n        clearTimeout(this.autoDisposeTimeoutId);\n        var disposed = false;\n        return function () {\n            if (disposed) {\n                return;\n            }\n            disposed = true;\n            _this.references--;\n            // Wait before fully disposing in case the app is running in strict mode.\n            setTimeout(function () {\n                if (!_this.references) {\n                    _this.dispose();\n                }\n            });\n        };\n    };\n    InternalQueryReference.prototype.didChangeOptions = function (watchQueryOptions) {\n        var _this = this;\n        return OBSERVED_CHANGED_OPTIONS.some(function (option) {\n            return !equal(_this.watchQueryOptions[option], watchQueryOptions[option]);\n        });\n    };\n    InternalQueryReference.prototype.applyOptions = function (watchQueryOptions) {\n        var _a = this.watchQueryOptions, currentFetchPolicy = _a.fetchPolicy, currentCanonizeResults = _a.canonizeResults;\n        // \"standby\" is used when `skip` is set to `true`. Detect when we've\n        // enabled the query (i.e. `skip` is `false`) to execute a network request.\n        if (currentFetchPolicy === \"standby\" &&\n            currentFetchPolicy !== watchQueryOptions.fetchPolicy) {\n            this.initiateFetch(this.observable.reobserve(watchQueryOptions));\n        }\n        else {\n            this.observable.silentSetOptions(watchQueryOptions);\n            if (currentCanonizeResults !== watchQueryOptions.canonizeResults) {\n                this.result = __assign(__assign({}, this.result), this.observable.getCurrentResult());\n                this.promise = createFulfilledPromise(this.result);\n            }\n        }\n        return this.promise;\n    };\n    InternalQueryReference.prototype.listen = function (listener) {\n        var _this = this;\n        this.listeners.add(listener);\n        return function () {\n            _this.listeners.delete(listener);\n        };\n    };\n    InternalQueryReference.prototype.refetch = function (variables) {\n        return this.initiateFetch(this.observable.refetch(variables));\n    };\n    InternalQueryReference.prototype.fetchMore = function (options) {\n        return this.initiateFetch(this.observable.fetchMore(options));\n    };\n    InternalQueryReference.prototype.dispose = function () {\n        this.subscription.unsubscribe();\n        this.onDispose();\n    };\n    InternalQueryReference.prototype.onDispose = function () {\n        // noop. overridable by options\n    };\n    InternalQueryReference.prototype.handleNext = function (result) {\n        var _a;\n        switch (this.status) {\n            case \"loading\": {\n                // Maintain the last successful `data` value if the next result does not\n                // have one.\n                if (result.data === void 0) {\n                    result.data = this.result.data;\n                }\n                this.status = \"idle\";\n                this.result = result;\n                (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, result);\n                break;\n            }\n            case \"idle\": {\n                // This occurs when switching to a result that is fully cached when this\n                // class is instantiated. ObservableQuery will run reobserve when\n                // subscribing, which delivers a result from the cache.\n                if (result.data === this.result.data &&\n                    result.networkStatus === this.result.networkStatus) {\n                    return;\n                }\n                // Maintain the last successful `data` value if the next result does not\n                // have one.\n                if (result.data === void 0) {\n                    result.data = this.result.data;\n                }\n                this.result = result;\n                this.promise = createFulfilledPromise(result);\n                this.deliver(this.promise);\n                break;\n            }\n        }\n    };\n    InternalQueryReference.prototype.handleError = function (error) {\n        var _a;\n        this.subscription.unsubscribe();\n        this.subscription = this.observable.resubscribeAfterError(this.handleNext, this.handleError);\n        switch (this.status) {\n            case \"loading\": {\n                this.status = \"idle\";\n                (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, error);\n                break;\n            }\n            case \"idle\": {\n                this.promise = createRejectedPromise(error);\n                this.deliver(this.promise);\n            }\n        }\n    };\n    InternalQueryReference.prototype.deliver = function (promise) {\n        this.listeners.forEach(function (listener) { return listener(promise); });\n    };\n    InternalQueryReference.prototype.initiateFetch = function (returnedPromise) {\n        var _this = this;\n        this.status = \"loading\";\n        this.promise = new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        });\n        this.promise.catch(function () { });\n        // If the data returned from the fetch is deeply equal to the data already\n        // in the cache, `handleNext` will not be triggered leaving the promise we\n        // created in a pending state forever. To avoid this situtation, we attempt\n        // to resolve the promise if `handleNext` hasn't been run to ensure the\n        // promise is resolved correctly.\n        returnedPromise\n            .then(function (result) {\n            var _a;\n            if (_this.status === \"loading\") {\n                _this.status = \"idle\";\n                _this.result = result;\n                (_a = _this.resolve) === null || _a === void 0 ? void 0 : _a.call(_this, result);\n            }\n        })\n            .catch(function () { });\n        return returnedPromise;\n    };\n    return InternalQueryReference;\n}());\nexport { InternalQueryReference };\n//# sourceMappingURL=QueryReference.js.map","import { Trie } from \"@wry/trie\";\nimport { canUseWeakMap } from \"../../utilities/index.js\";\nimport { InternalQueryReference } from \"./QueryReference.js\";\nvar SuspenseCache = /** @class */ (function () {\n    function SuspenseCache(options) {\n        if (options === void 0) { options = Object.create(null); }\n        this.queryRefs = new Trie(canUseWeakMap);\n        this.options = options;\n    }\n    SuspenseCache.prototype.getQueryRef = function (cacheKey, createObservable) {\n        var ref = this.queryRefs.lookupArray(cacheKey);\n        if (!ref.current) {\n            ref.current = new InternalQueryReference(createObservable(), {\n                key: cacheKey,\n                autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs,\n                onDispose: function () {\n                    delete ref.current;\n                },\n            });\n        }\n        return ref.current;\n    };\n    return SuspenseCache;\n}());\nexport { SuspenseCache };\n//# sourceMappingURL=SuspenseCache.js.map","import { SuspenseCache } from \"./SuspenseCache.js\";\nvar suspenseCacheSymbol = Symbol.for(\"apollo.suspenseCache\");\nexport function getSuspenseCache(client) {\n    var _a;\n    if (!client[suspenseCacheSymbol]) {\n        client[suspenseCacheSymbol] = new SuspenseCache((_a = client.defaultOptions.react) === null || _a === void 0 ? void 0 : _a.suspense);\n    }\n    return client[suspenseCacheSymbol];\n}\n//# sourceMappingURL=getSuspenseCache.js.map","export var skipToken = Symbol.for(\"apollo.skipToken\");\n//# sourceMappingURL=constants.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport * as React from \"react\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { ApolloError, NetworkStatus } from \"../../core/index.js\";\nimport { isNonEmptyArray } from \"../../utilities/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nimport { DocumentType, verifyDocumentType } from \"../parser/index.js\";\nimport { __use, useDeepMemo } from \"./internal/index.js\";\nimport { getSuspenseCache } from \"../cache/index.js\";\nimport { canonicalStringify } from \"../../cache/index.js\";\nimport { skipToken } from \"./constants.js\";\nexport function useSuspenseQuery(query, options) {\n    if (options === void 0) { options = Object.create(null); }\n    var client = useApolloClient(options.client);\n    var suspenseCache = getSuspenseCache(client);\n    var watchQueryOptions = useWatchQueryOptions({\n        client: client,\n        query: query,\n        options: options,\n    });\n    var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;\n    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;\n    var cacheKey = __spreadArray([\n        query,\n        canonicalStringify(variables)\n    ], [].concat(queryKey), true);\n    var queryRef = suspenseCache.getQueryRef(cacheKey, function () {\n        return client.watchQuery(watchQueryOptions);\n    });\n    var _b = React.useState(function () { return new Map([[queryRef.key, queryRef.promise]]); }), promiseCache = _b[0], setPromiseCache = _b[1];\n    var promise = promiseCache.get(queryRef.key);\n    if (queryRef.didChangeOptions(watchQueryOptions)) {\n        promise = queryRef.applyOptions(watchQueryOptions);\n        promiseCache.set(queryRef.key, promise);\n    }\n    if (!promise) {\n        promise = queryRef.promise;\n        promiseCache.set(queryRef.key, promise);\n    }\n    React.useEffect(function () {\n        var dispose = queryRef.retain();\n        var removeListener = queryRef.listen(function (promise) {\n            setPromiseCache(function (promiseCache) {\n                return new Map(promiseCache).set(queryRef.key, promise);\n            });\n        });\n        return function () {\n            removeListener();\n            dispose();\n        };\n    }, [queryRef]);\n    var skipResult = React.useMemo(function () {\n        var error = toApolloError(queryRef.result);\n        return {\n            loading: false,\n            data: queryRef.result.data,\n            networkStatus: error ? NetworkStatus.error : NetworkStatus.ready,\n            error: error,\n        };\n    }, [queryRef.result]);\n    var result = fetchPolicy === \"standby\" ? skipResult : __use(promise);\n    var fetchMore = React.useCallback((function (options) {\n        var promise = queryRef.fetchMore(options);\n        setPromiseCache(function (previousPromiseCache) {\n            return new Map(previousPromiseCache).set(queryRef.key, queryRef.promise);\n        });\n        return promise;\n    }), [queryRef]);\n    var refetch = React.useCallback(function (variables) {\n        var promise = queryRef.refetch(variables);\n        setPromiseCache(function (previousPromiseCache) {\n            return new Map(previousPromiseCache).set(queryRef.key, queryRef.promise);\n        });\n        return promise;\n    }, [queryRef]);\n    var subscribeToMore = React.useCallback(function (options) { return queryRef.observable.subscribeToMore(options); }, [queryRef]);\n    return React.useMemo(function () {\n        return {\n            client: client,\n            data: result.data,\n            error: toApolloError(result),\n            networkStatus: result.networkStatus,\n            fetchMore: fetchMore,\n            refetch: refetch,\n            subscribeToMore: subscribeToMore,\n        };\n    }, [client, fetchMore, refetch, result, subscribeToMore]);\n}\nfunction validateOptions(options) {\n    var query = options.query, fetchPolicy = options.fetchPolicy, returnPartialData = options.returnPartialData;\n    verifyDocumentType(query, DocumentType.Query);\n    validateFetchPolicy(fetchPolicy);\n    validatePartialDataReturn(fetchPolicy, returnPartialData);\n}\nfunction validateFetchPolicy(fetchPolicy) {\n    if (fetchPolicy === void 0) { fetchPolicy = \"cache-first\"; }\n    var supportedFetchPolicies = [\n        \"cache-first\",\n        \"network-only\",\n        \"no-cache\",\n        \"cache-and-network\",\n    ];\n    invariant(supportedFetchPolicies.includes(fetchPolicy), 56, fetchPolicy);\n}\nfunction validatePartialDataReturn(fetchPolicy, returnPartialData) {\n    if (fetchPolicy === \"no-cache\" && returnPartialData) {\n        globalThis.__DEV__ !== false && invariant.warn(57);\n    }\n}\nexport function toApolloError(result) {\n    return isNonEmptyArray(result.errors) ?\n        new ApolloError({ graphQLErrors: result.errors })\n        : result.error;\n}\nexport function useWatchQueryOptions(_a) {\n    var client = _a.client, query = _a.query, options = _a.options;\n    return useDeepMemo(function () {\n        var _a;\n        if (options === skipToken) {\n            return { query: query, fetchPolicy: \"standby\" };\n        }\n        var fetchPolicy = options.fetchPolicy ||\n            ((_a = client.defaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||\n            \"cache-first\";\n        var watchQueryOptions = __assign(__assign({}, options), { fetchPolicy: fetchPolicy, query: query, notifyOnNetworkStatusChange: false, nextFetchPolicy: void 0 });\n        if (globalThis.__DEV__ !== false) {\n            validateOptions(watchQueryOptions);\n        }\n        // Assign the updated fetch policy after our validation since `standby` is\n        // not a supported fetch policy on its own without the use of `skip`.\n        if (options.skip) {\n            watchQueryOptions.fetchPolicy = \"standby\";\n        }\n        return watchQueryOptions;\n    }, [client, options, query]);\n}\n//# sourceMappingURL=useSuspenseQuery.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nexport var DocumentType;\n(function (DocumentType) {\n    DocumentType[DocumentType[\"Query\"] = 0] = \"Query\";\n    DocumentType[DocumentType[\"Mutation\"] = 1] = \"Mutation\";\n    DocumentType[DocumentType[\"Subscription\"] = 2] = \"Subscription\";\n})(DocumentType || (DocumentType = {}));\nvar cache = new Map();\nexport function operationName(type) {\n    var name;\n    switch (type) {\n        case DocumentType.Query:\n            name = \"Query\";\n            break;\n        case DocumentType.Mutation:\n            name = \"Mutation\";\n            break;\n        case DocumentType.Subscription:\n            name = \"Subscription\";\n            break;\n    }\n    return name;\n}\n// This parser is mostly used to safety check incoming documents.\nexport function parser(document) {\n    var cached = cache.get(document);\n    if (cached)\n        return cached;\n    var variables, type, name;\n    invariant(!!document && !!document.kind, 59, document);\n    var fragments = [];\n    var queries = [];\n    var mutations = [];\n    var subscriptions = [];\n    for (var _i = 0, _a = document.definitions; _i < _a.length; _i++) {\n        var x = _a[_i];\n        if (x.kind === \"FragmentDefinition\") {\n            fragments.push(x);\n            continue;\n        }\n        if (x.kind === \"OperationDefinition\") {\n            switch (x.operation) {\n                case \"query\":\n                    queries.push(x);\n                    break;\n                case \"mutation\":\n                    mutations.push(x);\n                    break;\n                case \"subscription\":\n                    subscriptions.push(x);\n                    break;\n            }\n        }\n    }\n    invariant(!fragments.length ||\n        queries.length ||\n        mutations.length ||\n        subscriptions.length, 60);\n    invariant(\n        queries.length + mutations.length + subscriptions.length <= 1,\n        61,\n        document,\n        queries.length,\n        subscriptions.length,\n        mutations.length\n    );\n    type = queries.length ? DocumentType.Query : DocumentType.Mutation;\n    if (!queries.length && !mutations.length)\n        type = DocumentType.Subscription;\n    var definitions = queries.length ? queries\n        : mutations.length ? mutations\n            : subscriptions;\n    invariant(definitions.length === 1, 62, document, definitions.length);\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\"; // fallback to using data if no name\n    }\n    var payload = { name: name, type: type, variables: variables };\n    cache.set(document, payload);\n    return payload;\n}\nexport function verifyDocumentType(document, type) {\n    var operation = parser(document);\n    var requiredOperationName = operationName(type);\n    var usedOperationName = operationName(operation.type);\n    invariant(\n        operation.type === type,\n        63,\n        requiredOperationName,\n        requiredOperationName,\n        usedOperationName\n    );\n}\n//# sourceMappingURL=index.js.map","// A version of Array.isArray that works better with readonly arrays.\nexport var isArray = Array.isArray;\nexport function isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n//# sourceMappingURL=arrays.js.map","import { maybe } from \"../globals/index.js\";\nexport var canUseWeakMap = typeof WeakMap === \"function\" &&\n    maybe(function () { return navigator.product; }) !== \"ReactNative\";\nexport var canUseWeakSet = typeof WeakSet === \"function\";\nexport var canUseSymbol = typeof Symbol === \"function\" && typeof Symbol.for === \"function\";\nexport var canUseAsyncIteratorSymbol = canUseSymbol && Symbol.asyncIterator;\nexport var canUseDOM = typeof maybe(function () { return window.document.createElement; }) === \"function\";\nvar usingJSDOM = \n// Following advice found in this comment from @domenic (maintainer of jsdom):\n// https://github.com/jsdom/jsdom/issues/1537#issuecomment-229405327\n//\n// Since we control the version of Jest and jsdom used when running Apollo\n// Client tests, and that version is recent enought to include \" jsdom/x.y.z\"\n// at the end of the user agent string, I believe this case is all we need to\n// check. Testing for \"Node.js\" was recommended for backwards compatibility\n// with older version of jsdom, but we don't have that problem.\nmaybe(function () { return navigator.userAgent.indexOf(\"jsdom\") >= 0; }) || false;\n// Our tests should all continue to pass if we remove this !usingJSDOM\n// condition, thereby allowing useLayoutEffect when using jsdom. Unfortunately,\n// if we allow useLayoutEffect, then useSyncExternalStore generates many\n// warnings about useLayoutEffect doing nothing on the server. While these\n// warnings are harmless, this !usingJSDOM condition seems to be the best way to\n// prevent them (i.e. skipping useLayoutEffect when using jsdom).\nexport var canUseLayoutEffect = canUseDOM && !usingJSDOM;\n//# sourceMappingURL=canUse.js.map","var toString = Object.prototype.toString;\n/**\n * Deeply clones a value to create a new instance.\n */\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            // High fidelity polyfills of Object.create and Object.getPrototypeOf are\n            // possible in all JS environments, so we will assume they exist/work.\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","/**\n * Merges the provided objects shallowly and removes\n * all properties with an `undefined` value\n */\nexport 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","import { isNonNullObject } from \"./objects.js\";\nimport { isNonEmptyArray } from \"./arrays.js\";\nimport { DeepMerger } from \"./mergeDeep.js\";\nexport function isExecutionPatchIncrementalResult(value) {\n    return \"incremental\" in value;\n}\nexport function isExecutionPatchInitialResult(value) {\n    return \"hasNext\" in value && \"data\" in value;\n}\nexport function isExecutionPatchResult(value) {\n    return (isExecutionPatchIncrementalResult(value) ||\n        isExecutionPatchInitialResult(value));\n}\n// This function detects an Apollo payload result before it is transformed\n// into a FetchResult via HttpLink; it cannot detect an ApolloPayloadResult\n// once it leaves the link chain.\nexport function isApolloPayloadResult(value) {\n    return isNonNullObject(value) && \"payload\" in value;\n}\nexport function mergeIncrementalData(prevResult, result) {\n    var mergedData = prevResult;\n    var merger = new DeepMerger();\n    if (isExecutionPatchIncrementalResult(result) &&\n        isNonEmptyArray(result.incremental)) {\n        result.incremental.forEach(function (_a) {\n            var data = _a.data, path = _a.path;\n            for (var i = path.length - 1; i >= 0; --i) {\n                var key = path[i];\n                var isNumericKey = !isNaN(+key);\n                var parent_1 = isNumericKey ? [] : {};\n                parent_1[key] = data;\n                data = parent_1;\n            }\n            mergedData = merger.merge(mergedData, data);\n        });\n    }\n    return mergedData;\n}\n//# sourceMappingURL=incrementalResult.js.map","var prefixCounts = new Map();\n// These IDs won't be globally unique, but they will be unique within this\n// process, thanks to the counter, and unguessable thanks to the random suffix.\nexport function makeUniqueId(prefix) {\n    var count = prefixCounts.get(prefix) || 1;\n    prefixCounts.set(prefix, count + 1);\n    return \"\".concat(prefix, \":\").concat(count, \":\").concat(Math.random().toString(36).slice(2));\n}\n//# sourceMappingURL=makeUniqueId.js.map","import { isNonNullObject } from \"./objects.js\";\nfunction deepFreeze(value) {\n    var workSet = new Set([value]);\n    workSet.forEach(function (obj) {\n        if (isNonNullObject(obj) && shallowFreeze(obj) === obj) {\n            Object.getOwnPropertyNames(obj).forEach(function (name) {\n                if (isNonNullObject(obj[name]))\n                    workSet.add(obj[name]);\n            });\n        }\n    });\n    return value;\n}\nfunction shallowFreeze(obj) {\n    if (globalThis.__DEV__ !== false && !Object.isFrozen(obj)) {\n        try {\n            Object.freeze(obj);\n        }\n        catch (e) {\n            // Some types like Uint8Array and Node.js's Buffer cannot be frozen, but\n            // they all throw a TypeError when you try, so we re-throw any exceptions\n            // that are not TypeErrors, since that would be unexpected.\n            if (e instanceof TypeError)\n                return null;\n            throw e;\n        }\n    }\n    return obj;\n}\nexport function maybeDeepFreeze(obj) {\n    if (globalThis.__DEV__ !== false) {\n        deepFreeze(obj);\n    }\n    return obj;\n}\n//# sourceMappingURL=maybeDeepFreeze.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { isNonNullObject } from \"./objects.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\n// In almost any situation where you could succeed in getting the\n// TypeScript compiler to infer a tuple type for the sources array, you\n// could just use mergeDeep instead of mergeDeepArray, so instead of\n// trying to convert T[] to an intersection type we just infer the array\n// element type, which works perfectly when the sources array has a\n// consistent element type.\nexport function mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var merger = new DeepMerger();\n        for (var i = 1; i < count; ++i) {\n            target = merger.merge(target, sources[i]);\n        }\n    }\n    return target;\n}\nvar defaultReconciler = function (target, source, property) {\n    return this.merge(target[property], source[property]);\n};\nvar DeepMerger = /** @class */ (function () {\n    function DeepMerger(reconciler) {\n        if (reconciler === void 0) { reconciler = defaultReconciler; }\n        this.reconciler = reconciler;\n        this.isObject = isNonNullObject;\n        this.pastCopies = new Set();\n    }\n    DeepMerger.prototype.merge = function (target, source) {\n        var _this = this;\n        var context = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            context[_i - 2] = arguments[_i];\n        }\n        if (isNonNullObject(source) && isNonNullObject(target)) {\n            Object.keys(source).forEach(function (sourceKey) {\n                if (hasOwnProperty.call(target, sourceKey)) {\n                    var targetValue = target[sourceKey];\n                    if (source[sourceKey] !== targetValue) {\n                        var result = _this.reconciler.apply(_this, __spreadArray([target,\n                            source,\n                            sourceKey], context, false));\n                        // A well-implemented reconciler may return targetValue to indicate\n                        // the merge changed nothing about the structure of the target.\n                        if (result !== targetValue) {\n                            target = _this.shallowCopyForMerge(target);\n                            target[sourceKey] = result;\n                        }\n                    }\n                }\n                else {\n                    // If there is no collision, the target can safely share memory with\n                    // the source, and the recursion can terminate here.\n                    target = _this.shallowCopyForMerge(target);\n                    target[sourceKey] = source[sourceKey];\n                }\n            });\n            return target;\n        }\n        // If source (or target) is not an object, let source replace target.\n        return source;\n    };\n    DeepMerger.prototype.shallowCopyForMerge = function (value) {\n        if (isNonNullObject(value)) {\n            if (!this.pastCopies.has(value)) {\n                if (Array.isArray(value)) {\n                    value = value.slice(0);\n                }\n                else {\n                    value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n                }\n                this.pastCopies.add(value);\n            }\n        }\n        return value;\n    };\n    return DeepMerger;\n}());\nexport { DeepMerger };\n//# sourceMappingURL=mergeDeep.js.map","import { __assign } from \"tslib\";\nimport { compact } from \"./compact.js\";\nexport function mergeOptions(defaults, options) {\n    return compact(defaults, options, options.variables && {\n        variables: compact(__assign(__assign({}, (defaults && defaults.variables)), options.variables)),\n    });\n}\n//# sourceMappingURL=mergeOptions.js.map","export function isNonNullObject(obj) {\n    return obj !== null && typeof obj === \"object\";\n}\nexport function isPlainObject(obj) {\n    return (obj !== null &&\n        typeof obj === \"object\" &&\n        (Object.getPrototypeOf(obj) === Object.prototype ||\n            Object.getPrototypeOf(obj) === null));\n}\n//# sourceMappingURL=objects.js.map","import { makeUniqueId } from \"./makeUniqueId.js\";\nexport function stringifyForDisplay(value, space) {\n    if (space === void 0) { space = 0; }\n    var undefId = makeUniqueId(\"stringifyForDisplay\");\n    return JSON.stringify(value, function (key, value) {\n        return value === void 0 ? undefId : value;\n    }, space)\n        .split(JSON.stringify(undefId))\n        .join(\"<undefined>\");\n}\n//# sourceMappingURL=stringifyForDisplay.js.map","import { maybe } from \"./maybe.js\";\nexport default (maybe(function () { return globalThis; }) ||\n    maybe(function () { return window; }) ||\n    maybe(function () { return self; }) ||\n    maybe(function () { return global; }) || // We don't expect the Function constructor ever to be invoked at runtime, as\n// long as at least one of globalThis, window, self, or global is defined, so\n// we are under no obligation to make it easy for static analysis tools to\n// detect syntactic usage of the Function constructor. If you think you can\n// improve your static analysis to detect this obfuscation, think again. This\n// is an arms race you cannot win, at least not in JavaScript.\nmaybe(function () {\n    return maybe.constructor(\"return this\")();\n}));\n//# sourceMappingURL=global.js.map","import { invariant, newInvariantError, InvariantError, } from \"./invariantWrappers.js\";\nexport { maybe } from \"./maybe.js\";\nexport { default as global } from \"./global.js\";\nexport { invariant, newInvariantError, InvariantError };\n/**\n * @deprecated we do not use this internally anymore,\n * it is just exported for backwards compatibility\n */\n// this file is extempt from automatic `__DEV__` replacement\n// so we have to write it out here\n// @ts-ignore\nexport var DEV = globalThis.__DEV__ !== false;\nexport { DEV as __DEV__ };\n//# sourceMappingURL=index.js.map","import { invariant as originalInvariant, InvariantError } from \"ts-invariant\";\nimport { version } from \"../../version.js\";\nimport global from \"./global.js\";\nimport { stringifyForDisplay } from \"../common/stringifyForDisplay.js\";\nfunction wrap(fn) {\n    return function (message) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        if (typeof message === \"number\") {\n            var arg0 = message;\n            message = getHandledErrorMsg(arg0);\n            if (!message) {\n                message = getFallbackErrorMsg(arg0, args);\n                args = [];\n            }\n        }\n        fn.apply(void 0, [message].concat(args));\n    };\n}\nvar invariant = Object.assign(function invariant(condition, message) {\n    var args = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        args[_i - 2] = arguments[_i];\n    }\n    if (!condition) {\n        originalInvariant(condition, getHandledErrorMsg(message, args) || getFallbackErrorMsg(message, args));\n    }\n}, {\n    debug: wrap(originalInvariant.debug),\n    log: wrap(originalInvariant.log),\n    warn: wrap(originalInvariant.warn),\n    error: wrap(originalInvariant.error),\n});\n/**\n * Returns an InvariantError.\n *\n * `message` can only be a string, a concatenation of strings, or a ternary statement\n * that results in a string. This will be enforced on build, where the message will\n * be replaced with a message number.\n * String substitutions with %s are supported and will also return\n * pretty-stringified objects.\n * Excess `optionalParams` will be swallowed.\n */\nfunction newInvariantError(message) {\n    var optionalParams = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        optionalParams[_i - 1] = arguments[_i];\n    }\n    return new InvariantError(getHandledErrorMsg(message, optionalParams) ||\n        getFallbackErrorMsg(message, optionalParams));\n}\nvar ApolloErrorMessageHandler = Symbol.for(\"ApolloErrorMessageHandler_\" + version);\nfunction stringify(arg) {\n    return typeof arg == \"string\" ? arg : (stringifyForDisplay(arg, 2).slice(0, 1000));\n}\nfunction getHandledErrorMsg(message, messageArgs) {\n    if (messageArgs === void 0) { messageArgs = []; }\n    if (!message)\n        return;\n    return (global[ApolloErrorMessageHandler] &&\n        global[ApolloErrorMessageHandler](message, messageArgs.map(stringify)));\n}\nfunction getFallbackErrorMsg(message, messageArgs) {\n    if (messageArgs === void 0) { messageArgs = []; }\n    if (!message)\n        return;\n    return \"An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#\".concat(encodeURIComponent(JSON.stringify({\n        version: version,\n        message: message,\n        args: messageArgs.map(stringify),\n    })));\n}\nexport { invariant, InvariantError, newInvariantError, ApolloErrorMessageHandler, };\n//# sourceMappingURL=invariantWrappers.js.map","export function maybe(thunk) {\n    try {\n        return thunk();\n    }\n    catch (_a) { }\n}\n//# sourceMappingURL=maybe.js.map","import { Trie } from \"@wry/trie\";\nimport { canUseWeakMap, canUseWeakSet } from \"../common/canUse.js\";\nimport { checkDocument } from \"./getFromAST.js\";\nimport { invariant } from \"../globals/index.js\";\nfunction identity(document) {\n    return document;\n}\nvar DocumentTransform = /** @class */ (function () {\n    function DocumentTransform(transform, options) {\n        if (options === void 0) { options = Object.create(null); }\n        this.resultCache = canUseWeakSet ? new WeakSet() : new Set();\n        this.transform = transform;\n        if (options.getCacheKey) {\n            // Override default `getCacheKey` function, which returns [document].\n            this.getCacheKey = options.getCacheKey;\n        }\n        if (options.cache !== false) {\n            this.stableCacheKeys = new Trie(canUseWeakMap, function (key) { return ({ key: key }); });\n        }\n    }\n    // This default implementation of getCacheKey can be overridden by providing\n    // options.getCacheKey to the DocumentTransform constructor. In general, a\n    // getCacheKey function may either return an array of keys (often including\n    // the document) to be used as a cache key, or undefined to indicate the\n    // transform for this document should not be cached.\n    DocumentTransform.prototype.getCacheKey = function (document) {\n        return [document];\n    };\n    DocumentTransform.identity = function () {\n        // No need to cache this transform since it just returns the document\n        // unchanged. This should save a bit of memory that would otherwise be\n        // needed to populate the `documentCache` of this transform.\n        return new DocumentTransform(identity, { cache: false });\n    };\n    DocumentTransform.split = function (predicate, left, right) {\n        if (right === void 0) { right = DocumentTransform.identity(); }\n        return new DocumentTransform(function (document) {\n            var documentTransform = predicate(document) ? left : right;\n            return documentTransform.transformDocument(document);\n        }, \n        // Reasonably assume both `left` and `right` transforms handle their own caching\n        { cache: false });\n    };\n    DocumentTransform.prototype.transformDocument = function (document) {\n        // If a user passes an already transformed result back to this function,\n        // immediately return it.\n        if (this.resultCache.has(document)) {\n            return document;\n        }\n        var cacheEntry = this.getStableCacheEntry(document);\n        if (cacheEntry && cacheEntry.value) {\n            return cacheEntry.value;\n        }\n        checkDocument(document);\n        var transformedDocument = this.transform(document);\n        this.resultCache.add(transformedDocument);\n        if (cacheEntry) {\n            cacheEntry.value = transformedDocument;\n        }\n        return transformedDocument;\n    };\n    DocumentTransform.prototype.concat = function (otherTransform) {\n        var _this = this;\n        return new DocumentTransform(function (document) {\n            return otherTransform.transformDocument(_this.transformDocument(document));\n        }, \n        // Reasonably assume both transforms handle their own caching\n        { cache: false });\n    };\n    DocumentTransform.prototype.getStableCacheEntry = function (document) {\n        if (!this.stableCacheKeys)\n            return;\n        var cacheKeys = this.getCacheKey(document);\n        if (cacheKeys) {\n            invariant(Array.isArray(cacheKeys), 65);\n            return this.stableCacheKeys.lookupArray(cacheKeys);\n        }\n    };\n    return DocumentTransform;\n}());\nexport { DocumentTransform };\n//# sourceMappingURL=DocumentTransform.js.map","import { invariant } from \"../globals/index.js\";\nimport { visit, BREAK } from \"graphql\";\nexport function shouldInclude(_a, variables) {\n    var directives = _a.directives;\n    if (!directives || !directives.length) {\n        return true;\n    }\n    return getInclusionDirectives(directives).every(function (_a) {\n        var directive = _a.directive, ifArgument = _a.ifArgument;\n        var evaledValue = false;\n        if (ifArgument.value.kind === \"Variable\") {\n            evaledValue =\n                variables && variables[ifArgument.value.name.value];\n            invariant(evaledValue !== void 0, 66, directive.name.value);\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === \"skip\" ? !evaledValue : evaledValue;\n    });\n}\nexport function getDirectiveNames(root) {\n    var names = [];\n    visit(root, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nexport var hasAnyDirectives = function (names, root) {\n    return hasDirectives(names, root, false);\n};\nexport var hasAllDirectives = function (names, root) {\n    return hasDirectives(names, root, true);\n};\nexport function hasDirectives(names, root, all) {\n    var nameSet = new Set(names);\n    var uniqueCount = nameSet.size;\n    visit(root, {\n        Directive: function (node) {\n            if (nameSet.delete(node.name.value) && (!all || !nameSet.size)) {\n                return BREAK;\n            }\n        },\n    });\n    // If we found all the names, nameSet will be empty. If we only care about\n    // finding some of them, the < condition is sufficient.\n    return all ? !nameSet.size : nameSet.size < uniqueCount;\n}\nexport function hasClientExports(document) {\n    return document && hasDirectives([\"client\", \"export\"], document, true);\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === \"skip\" || value === \"include\";\n}\nexport function getInclusionDirectives(directives) {\n    var result = [];\n    if (directives && directives.length) {\n        directives.forEach(function (directive) {\n            if (!isInclusionDirective(directive))\n                return;\n            var directiveArguments = directive.arguments;\n            var directiveName = directive.name.value;\n            invariant(directiveArguments && directiveArguments.length === 1, 67, directiveName);\n            var ifArgument = directiveArguments[0];\n            invariant(ifArgument.name && ifArgument.name.value === \"if\", 68, directiveName);\n            var ifValue = ifArgument.value;\n            // means it has to be a variable value if this is a valid @skip or @include directive\n            invariant(ifValue &&\n                (ifValue.kind === \"Variable\" || ifValue.kind === \"BooleanValue\"), 69, directiveName);\n            result.push({ directive: directive, ifArgument: ifArgument });\n        });\n    }\n    return result;\n}\n//# sourceMappingURL=directives.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { invariant, newInvariantError } from \"../globals/index.js\";\n/**\n * Returns a query document which adds a single query operation that only\n * spreads the target fragment inside of it.\n *\n * So for example a document of:\n *\n * ```graphql\n * fragment foo on Foo { a b c }\n * ```\n *\n * Turns into:\n *\n * ```graphql\n * { ...foo }\n *\n * fragment foo on Foo { a b c }\n * ```\n *\n * The target fragment will either be the only fragment in the document, or a\n * fragment specified by the provided `fragmentName`. If there is more than one\n * fragment, but a `fragmentName` was not defined then an error will be thrown.\n */\nexport function getFragmentQueryDocument(document, fragmentName) {\n    var actualFragmentName = fragmentName;\n    // Build an array of all our fragment definitions that will be used for\n    // validations. We also do some validations on the other definitions in the\n    // document while building this list.\n    var fragments = [];\n    document.definitions.forEach(function (definition) {\n        // Throw an error if we encounter an operation definition because we will\n        // define our own operation definition later on.\n        if (definition.kind === \"OperationDefinition\") {\n            throw newInvariantError(\n                70,\n                definition.operation,\n                definition.name ? \" named '\".concat(definition.name.value, \"'\") : \"\"\n            );\n        }\n        // Add our definition to the fragments array if it is a fragment\n        // definition.\n        if (definition.kind === \"FragmentDefinition\") {\n            fragments.push(definition);\n        }\n    });\n    // If the user did not give us a fragment name then let us try to get a\n    // name from a single fragment in the definition.\n    if (typeof actualFragmentName === \"undefined\") {\n        invariant(fragments.length === 1, 71, fragments.length);\n        actualFragmentName = fragments[0].name.value;\n    }\n    // Generate a query document with an operation that simply spreads the\n    // fragment inside of it.\n    var query = __assign(__assign({}, document), { definitions: __spreadArray([\n            {\n                kind: \"OperationDefinition\",\n                // OperationTypeNode is an enum\n                operation: \"query\",\n                selectionSet: {\n                    kind: \"SelectionSet\",\n                    selections: [\n                        {\n                            kind: \"FragmentSpread\",\n                            name: {\n                                kind: \"Name\",\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions, true) });\n    return query;\n}\n// Utility function that takes a list of fragment definitions and makes a hash out of them\n// that maps the name of the fragment to the fragment definition.\nexport function createFragmentMap(fragments) {\n    if (fragments === void 0) { fragments = []; }\n    var symTable = {};\n    fragments.forEach(function (fragment) {\n        symTable[fragment.name.value] = fragment;\n    });\n    return symTable;\n}\nexport function getFragmentFromSelection(selection, fragmentMap) {\n    switch (selection.kind) {\n        case \"InlineFragment\":\n            return selection;\n        case \"FragmentSpread\": {\n            var fragmentName = selection.name.value;\n            if (typeof fragmentMap === \"function\") {\n                return fragmentMap(fragmentName);\n            }\n            var fragment = fragmentMap && fragmentMap[fragmentName];\n            invariant(fragment, 72, fragmentName);\n            return fragment || null;\n        }\n        default:\n            return null;\n    }\n}\n//# sourceMappingURL=fragments.js.map","import { invariant, newInvariantError } from \"../globals/index.js\";\nimport { valueToObjectRepresentation } from \"./storeUtils.js\";\n// Checks the document for errors and throws an exception if there is an error.\nexport function checkDocument(doc) {\n    invariant(doc && doc.kind === \"Document\", 73);\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== \"FragmentDefinition\"; })\n        .map(function (definition) {\n        if (definition.kind !== \"OperationDefinition\") {\n            throw newInvariantError(74, definition.kind);\n        }\n        return definition;\n    });\n    invariant(operations.length <= 1, 75, operations.length);\n    return doc;\n}\nexport function getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) {\n        return definition.kind === \"OperationDefinition\";\n    })[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}\n// Returns the FragmentDefinitions from a particular document as an array\nexport function getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) {\n        return definition.kind === \"FragmentDefinition\";\n    });\n}\nexport function getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    invariant(queryDef && queryDef.operation === \"query\", 76);\n    return queryDef;\n}\nexport function getFragmentDefinition(doc) {\n    invariant(doc.kind === \"Document\", 77);\n    invariant(doc.definitions.length <= 1, 78);\n    var fragmentDef = doc.definitions[0];\n    invariant(fragmentDef.kind === \"FragmentDefinition\", 79);\n    return fragmentDef;\n}\n/**\n * Returns the first operation definition found in this document.\n * If no operation definition is found, the first fragment definition will be returned.\n * If no definitions are found, an error will be thrown.\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            // we do this because we want to allow multiple fragment definitions\n            // to precede an operation definition.\n            fragmentDefinition = definition;\n        }\n    }\n    if (fragmentDefinition) {\n        return fragmentDefinition;\n    }\n    throw newInvariantError(80);\n}\nexport function getDefaultValues(definition) {\n    var defaultValues = Object.create(null);\n    var defs = definition && definition.variableDefinitions;\n    if (defs && defs.length) {\n        defs.forEach(function (def) {\n            if (def.defaultValue) {\n                valueToObjectRepresentation(defaultValues, def.variable.name, def.defaultValue);\n            }\n        });\n    }\n    return defaultValues;\n}\n//# sourceMappingURL=getFromAST.js.map","import { print as origPrint } from \"graphql\";\nimport { canUseWeakMap } from \"../common/canUse.js\";\nvar printCache = canUseWeakMap ? new WeakMap() : undefined;\nexport var print = function (ast) {\n    var result;\n    result = printCache === null || printCache === void 0 ? void 0 : printCache.get(ast);\n    if (!result) {\n        result = origPrint(ast);\n        printCache === null || printCache === void 0 ? void 0 : printCache.set(ast, result);\n    }\n    return result;\n};\n//# sourceMappingURL=print.js.map","import { newInvariantError } from \"../globals/index.js\";\nimport { isNonNullObject } from \"../common/objects.js\";\nimport { getFragmentFromSelection } from \"./fragments.js\";\nexport function makeReference(id) {\n    return { __ref: String(id) };\n}\nexport function isReference(obj) {\n    return Boolean(obj && typeof obj === \"object\" && typeof obj.__ref === \"string\");\n}\nexport function isDocumentNode(value) {\n    return (isNonNullObject(value) &&\n        value.kind === \"Document\" &&\n        Array.isArray(value.definitions));\n}\nfunction isStringValue(value) {\n    return value.kind === \"StringValue\";\n}\nfunction isBooleanValue(value) {\n    return value.kind === \"BooleanValue\";\n}\nfunction isIntValue(value) {\n    return value.kind === \"IntValue\";\n}\nfunction isFloatValue(value) {\n    return value.kind === \"FloatValue\";\n}\nfunction isVariable(value) {\n    return value.kind === \"Variable\";\n}\nfunction isObjectValue(value) {\n    return value.kind === \"ObjectValue\";\n}\nfunction isListValue(value) {\n    return value.kind === \"ListValue\";\n}\nfunction isEnumValue(value) {\n    return value.kind === \"EnumValue\";\n}\nfunction isNullValue(value) {\n    return value.kind === \"NullValue\";\n}\nexport function valueToObjectRepresentation(argObj, name, value, variables) {\n    if (isIntValue(value) || isFloatValue(value)) {\n        argObj[name.value] = Number(value.value);\n    }\n    else if (isBooleanValue(value) || isStringValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isObjectValue(value)) {\n        var nestedArgObj_1 = {};\n        value.fields.map(function (obj) {\n            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n        });\n        argObj[name.value] = nestedArgObj_1;\n    }\n    else if (isVariable(value)) {\n        var variableValue = (variables || {})[value.name.value];\n        argObj[name.value] = variableValue;\n    }\n    else if (isListValue(value)) {\n        argObj[name.value] = value.values.map(function (listValue) {\n            var nestedArgArrayObj = {};\n            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n            return nestedArgArrayObj[name.value];\n        });\n    }\n    else if (isEnumValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isNullValue(value)) {\n        argObj[name.value] = null;\n    }\n    else {\n        throw newInvariantError(81, name.value, value.kind);\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    \"nonreactive\",\n];\nexport var getStoreKeyName = Object.assign(function (fieldName, args, directives) {\n    if (args &&\n        directives &&\n        directives[\"connection\"] &&\n        directives[\"connection\"][\"key\"]) {\n        if (directives[\"connection\"][\"filter\"] &&\n            directives[\"connection\"][\"filter\"].length > 0) {\n            var filterKeys = directives[\"connection\"][\"filter\"] ?\n                directives[\"connection\"][\"filter\"]\n                : [];\n            filterKeys.sort();\n            var filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = args[key];\n            });\n            return \"\".concat(directives[\"connection\"][\"key\"], \"(\").concat(stringify(filteredArgs_1), \")\");\n        }\n        else {\n            return directives[\"connection\"][\"key\"];\n        }\n    }\n    var completeFieldName = fieldName;\n    if (args) {\n        // We can't use `JSON.stringify` here since it's non-deterministic,\n        // and can lead to different store key names being created even though\n        // the `args` object used during creation has the same properties/values.\n        var stringifiedArgs = stringify(args);\n        completeFieldName += \"(\".concat(stringifiedArgs, \")\");\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\".concat(key, \"(\").concat(stringify(directives[key]), \")\");\n            }\n            else {\n                completeFieldName += \"@\".concat(key);\n            }\n        });\n    }\n    return completeFieldName;\n}, {\n    setStringify: function (s) {\n        var previous = stringify;\n        stringify = s;\n        return previous;\n    },\n});\n// Default stable JSON.stringify implementation. Can be updated/replaced with\n// something better by calling getStoreKeyName.setStringify.\nvar stringify = function defaultStringify(value) {\n    return JSON.stringify(value, stringifyReplacer);\n};\nfunction stringifyReplacer(_key, value) {\n    if (isNonNullObject(value) && !Array.isArray(value)) {\n        value = Object.keys(value)\n            .sort()\n            .reduce(function (copy, key) {\n            copy[key] = value[key];\n            return copy;\n        }, {});\n    }\n    return value;\n}\nexport function argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        var argObj_1 = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj_1, name, value, variables);\n        });\n        return argObj_1;\n    }\n    return null;\n}\nexport function resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nexport function getTypenameFromResult(result, selectionSet, fragmentMap) {\n    var fragments;\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 if (fragments) {\n            fragments.push(selection);\n        }\n        else {\n            fragments = [selection];\n        }\n    }\n    if (typeof result.__typename === \"string\") {\n        return result.__typename;\n    }\n    if (fragments) {\n        for (var _b = 0, fragments_1 = fragments; _b < fragments_1.length; _b++) {\n            var selection = fragments_1[_b];\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 { __assign, __spreadArray } from \"tslib\";\nimport { invariant } from \"../globals/index.js\";\nimport { visit, Kind } from \"graphql\";\nimport { checkDocument, getOperationDefinition, getFragmentDefinition, getFragmentDefinitions, getMainDefinition, } from \"./getFromAST.js\";\nimport { isField } from \"./storeUtils.js\";\nimport { createFragmentMap } from \"./fragments.js\";\nimport { isArray, isNonEmptyArray } from \"../common/arrays.js\";\nvar TYPENAME_FIELD = {\n    kind: Kind.FIELD,\n    name: {\n        kind: Kind.NAME,\n        value: \"__typename\",\n    },\n};\nfunction isEmpty(op, fragmentMap) {\n    return (!op ||\n        op.selectionSet.selections.every(function (selection) {\n            return selection.kind === Kind.FRAGMENT_SPREAD &&\n                isEmpty(fragmentMap[selection.name.value], fragmentMap);\n        }));\n}\nfunction nullIfDocIsEmpty(doc) {\n    return (isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))) ?\n        null\n        : doc;\n}\nfunction getDirectiveMatcher(configs) {\n    var names = new Map();\n    var tests = new Map();\n    configs.forEach(function (directive) {\n        if (directive) {\n            if (directive.name) {\n                names.set(directive.name, directive);\n            }\n            else if (directive.test) {\n                tests.set(directive.test, directive);\n            }\n        }\n    });\n    return function (directive) {\n        var config = names.get(directive.name.value);\n        if (!config && tests.size) {\n            tests.forEach(function (testConfig, test) {\n                if (test(directive)) {\n                    config = testConfig;\n                }\n            });\n        }\n        return config;\n    };\n}\nfunction makeInUseGetterFunction(defaultKey) {\n    var map = new Map();\n    return function inUseGetterFunction(key) {\n        if (key === void 0) { key = defaultKey; }\n        var inUse = map.get(key);\n        if (!inUse) {\n            map.set(key, (inUse = {\n                // Variable and fragment spread names used directly within this\n                // operation or fragment definition, as identified by key. These sets\n                // will be populated during the first traversal of the document in\n                // removeDirectivesFromDocument below.\n                variables: new Set(),\n                fragmentSpreads: new Set(),\n            }));\n        }\n        return inUse;\n    };\n}\nexport function removeDirectivesFromDocument(directives, doc) {\n    checkDocument(doc);\n    // Passing empty strings to makeInUseGetterFunction means we handle anonymous\n    // operations as if their names were \"\". Anonymous fragment definitions are\n    // not supposed to be possible, but the same default naming strategy seems\n    // appropriate for that case as well.\n    var getInUseByOperationName = makeInUseGetterFunction(\"\");\n    var getInUseByFragmentName = makeInUseGetterFunction(\"\");\n    var getInUse = function (ancestors) {\n        for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {\n            if (isArray(ancestor))\n                continue;\n            if (ancestor.kind === Kind.OPERATION_DEFINITION) {\n                // If an operation is anonymous, we use the empty string as its key.\n                return getInUseByOperationName(ancestor.name && ancestor.name.value);\n            }\n            if (ancestor.kind === Kind.FRAGMENT_DEFINITION) {\n                return getInUseByFragmentName(ancestor.name.value);\n            }\n        }\n        globalThis.__DEV__ !== false && invariant.error(82);\n        return null;\n    };\n    var operationCount = 0;\n    for (var i = doc.definitions.length - 1; i >= 0; --i) {\n        if (doc.definitions[i].kind === Kind.OPERATION_DEFINITION) {\n            ++operationCount;\n        }\n    }\n    var directiveMatcher = getDirectiveMatcher(directives);\n    var shouldRemoveField = function (nodeDirectives) {\n        return isNonEmptyArray(nodeDirectives) &&\n            nodeDirectives\n                .map(directiveMatcher)\n                .some(function (config) { return config && config.remove; });\n    };\n    var originalFragmentDefsByPath = new Map();\n    // Any time the first traversal of the document below makes a change like\n    // removing a fragment (by returning null), this variable should be set to\n    // true. Once it becomes true, it should never be set to false again. If this\n    // variable remains false throughout the traversal, then we can return the\n    // original doc immediately without any modifications.\n    var firstVisitMadeChanges = false;\n    var fieldOrInlineFragmentVisitor = {\n        enter: function (node) {\n            if (shouldRemoveField(node.directives)) {\n                firstVisitMadeChanges = true;\n                return null;\n            }\n        },\n    };\n    var docWithoutDirectiveSubtrees = visit(doc, {\n        // These two AST node types share the same implementation, defined above.\n        Field: fieldOrInlineFragmentVisitor,\n        InlineFragment: fieldOrInlineFragmentVisitor,\n        VariableDefinition: {\n            enter: function () {\n                // VariableDefinition nodes do not count as variables in use, though\n                // they do contain Variable nodes that might be visited below. To avoid\n                // counting variable declarations as usages, we skip visiting the\n                // contents of this VariableDefinition node by returning false.\n                return false;\n            },\n        },\n        Variable: {\n            enter: function (node, _key, _parent, _path, ancestors) {\n                var inUse = getInUse(ancestors);\n                if (inUse) {\n                    inUse.variables.add(node.name.value);\n                }\n            },\n        },\n        FragmentSpread: {\n            enter: function (node, _key, _parent, _path, ancestors) {\n                if (shouldRemoveField(node.directives)) {\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n                var inUse = getInUse(ancestors);\n                if (inUse) {\n                    inUse.fragmentSpreads.add(node.name.value);\n                }\n                // We might like to remove this FragmentSpread by returning null here if\n                // the corresponding FragmentDefinition node is also going to be removed\n                // by the logic below, but we can't control the relative order of those\n                // events, so we have to postpone the removal of dangling FragmentSpread\n                // nodes until after the current visit of the document has finished.\n            },\n        },\n        FragmentDefinition: {\n            enter: function (node, _key, _parent, path) {\n                originalFragmentDefsByPath.set(JSON.stringify(path), node);\n            },\n            leave: function (node, _key, _parent, path) {\n                var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));\n                if (node === originalNode) {\n                    // If the FragmentNode received by this leave function is identical to\n                    // the one received by the corresponding enter function (above), then\n                    // the visitor must not have made any changes within this\n                    // FragmentDefinition node. This fragment definition may still be\n                    // removed if there are no ...spread references to it, but it won't be\n                    // removed just because it has only a __typename field.\n                    return node;\n                }\n                if (\n                // This logic applies only if the document contains one or more\n                // operations, since removing all fragments from a document containing\n                // only fragments makes the document useless.\n                operationCount > 0 &&\n                    node.selectionSet.selections.every(function (selection) {\n                        return selection.kind === Kind.FIELD &&\n                            selection.name.value === \"__typename\";\n                    })) {\n                    // This is a somewhat opinionated choice: if a FragmentDefinition ends\n                    // up having no fields other than __typename, we remove the whole\n                    // fragment definition, and later prune ...spread references to it.\n                    getInUseByFragmentName(node.name.value).removed = true;\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n            },\n        },\n        Directive: {\n            leave: function (node) {\n                // If a matching directive is found, remove the directive itself. Note\n                // that this does not remove the target (field, argument, etc) of the\n                // directive, but only the directive itself.\n                if (directiveMatcher(node)) {\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n            },\n        },\n    });\n    if (!firstVisitMadeChanges) {\n        // If our first pass did not change anything about the document, then there\n        // is no cleanup we need to do, and we can return the original doc.\n        return doc;\n    }\n    // Utility for making sure inUse.transitiveVars is recursively populated.\n    // Because this logic assumes inUse.fragmentSpreads has been completely\n    // populated and inUse.removed has been set if appropriate,\n    // populateTransitiveVars must be called after that information has been\n    // collected by the first traversal of the document.\n    var populateTransitiveVars = function (inUse) {\n        if (!inUse.transitiveVars) {\n            inUse.transitiveVars = new Set(inUse.variables);\n            if (!inUse.removed) {\n                inUse.fragmentSpreads.forEach(function (childFragmentName) {\n                    populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach(function (varName) {\n                        inUse.transitiveVars.add(varName);\n                    });\n                });\n            }\n        }\n        return inUse;\n    };\n    // Since we've been keeping track of fragment spreads used by particular\n    // operations and fragment definitions, we now need to compute the set of all\n    // spreads used (transitively) by any operations in the document.\n    var allFragmentNamesUsed = new Set();\n    docWithoutDirectiveSubtrees.definitions.forEach(function (def) {\n        if (def.kind === Kind.OPERATION_DEFINITION) {\n            populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function (childFragmentName) {\n                allFragmentNamesUsed.add(childFragmentName);\n            });\n        }\n        else if (def.kind === Kind.FRAGMENT_DEFINITION &&\n            // If there are no operations in the document, then all fragment\n            // definitions count as usages of their own fragment names. This heuristic\n            // prevents accidentally removing all fragment definitions from the\n            // document just because it contains no operations that use the fragments.\n            operationCount === 0 &&\n            !getInUseByFragmentName(def.name.value).removed) {\n            allFragmentNamesUsed.add(def.name.value);\n        }\n    });\n    // Now that we have added all fragment spreads used by operations to the\n    // allFragmentNamesUsed set, we can complete the set by transitively adding\n    // all fragment spreads used by those fragments, and so on.\n    allFragmentNamesUsed.forEach(function (fragmentName) {\n        // Once all the childFragmentName strings added here have been seen already,\n        // the top-level allFragmentNamesUsed.forEach loop will terminate.\n        populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function (childFragmentName) {\n            allFragmentNamesUsed.add(childFragmentName);\n        });\n    });\n    var fragmentWillBeRemoved = function (fragmentName) {\n        return !!(\n        // A fragment definition will be removed if there are no spreads that refer\n        // to it, or the fragment was explicitly removed because it had no fields\n        // other than __typename.\n        (!allFragmentNamesUsed.has(fragmentName) ||\n            getInUseByFragmentName(fragmentName).removed));\n    };\n    var enterVisitor = {\n        enter: function (node) {\n            if (fragmentWillBeRemoved(node.name.value)) {\n                return null;\n            }\n        },\n    };\n    return nullIfDocIsEmpty(visit(docWithoutDirectiveSubtrees, {\n        // If the fragment is going to be removed, then leaving any dangling\n        // FragmentSpread nodes with the same name would be a mistake.\n        FragmentSpread: enterVisitor,\n        // This is where the fragment definition is actually removed.\n        FragmentDefinition: enterVisitor,\n        OperationDefinition: {\n            leave: function (node) {\n                // Upon leaving each operation in the depth-first AST traversal, prune\n                // any variables that are declared by the operation but unused within.\n                if (node.variableDefinitions) {\n                    var usedVariableNames_1 = populateTransitiveVars(\n                    // If an operation is anonymous, we use the empty string as its key.\n                    getInUseByOperationName(node.name && node.name.value)).transitiveVars;\n                    // According to the GraphQL spec, all variables declared by an\n                    // operation must either be used by that operation or used by some\n                    // fragment included transitively into that operation:\n                    // https://spec.graphql.org/draft/#sec-All-Variables-Used\n                    //\n                    // To stay on the right side of this validation rule, if/when we\n                    // remove the last $var references from an operation or its fragments,\n                    // we must also remove the corresponding $var declaration from the\n                    // enclosing operation. This pruning applies only to operations and\n                    // not fragment definitions, at the moment. Fragments may be able to\n                    // declare variables eventually, but today they can only consume them.\n                    if (usedVariableNames_1.size < node.variableDefinitions.length) {\n                        return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n                                return usedVariableNames_1.has(varDef.variable.name.value);\n                            }) });\n                    }\n                }\n            },\n        },\n    }));\n}\nexport var addTypenameToDocument = Object.assign(function (doc) {\n    return visit(doc, {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                // Don't add __typename to OperationDefinitions.\n                if (parent &&\n                    parent.kind ===\n                        Kind.OPERATION_DEFINITION) {\n                    return;\n                }\n                // No changes if no selections.\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                // If selections already have a __typename, or are part of an\n                // introspection query, do nothing.\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                // If this SelectionSet is @export-ed as an input variable, it should\n                // not have a __typename field (see issue #4691).\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                // Create and return a new SelectionSet with a __typename Field.\n                return __assign(__assign({}, node), { selections: __spreadArray(__spreadArray([], selections, true), [TYPENAME_FIELD], false) });\n            },\n        },\n    });\n}, {\n    added: function (field) {\n        return field === TYPENAME_FIELD;\n    },\n});\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === \"connection\";\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === \"key\"; })) {\n                globalThis.__DEV__ !== false && invariant.warn(83);\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 === 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), { \n                    // Remove matching top level variables definitions.\n                    variableDefinitions: node.variableDefinitions ?\n                        node.variableDefinitions.filter(function (varDef) {\n                            return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });\n                        })\n                        : [] });\n            },\n        },\n        Field: {\n            enter: function (node) {\n                // If `remove` is set to true for an argument, and an argument match\n                // is found for a field, remove the field as well.\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                // Remove all matching arguments.\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}\n// If the incoming document is a query, return it as is. Otherwise, build a\n// new document containing a query operation based on the selection set\n// of the previous main operation.\nexport function buildQueryFromSelectionSet(document) {\n    var definition = getMainDefinition(document);\n    var definitionOperation = definition.operation;\n    if (definitionOperation === \"query\") {\n        // Already a query, so return the existing document.\n        return document;\n    }\n    // Build a new query using the selection set of the main operation.\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}\n// Remove fields / selection sets that include an @client directive.\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    return modifiedDoc;\n}\n//# sourceMappingURL=transform.js.map","export var version = \"3.8.10\";\n//# sourceMappingURL=version.js.map"],"names":["ApolloCache","options","_this","optimisticId","updateResult","transaction","document","object","optimistic","_a","id","data","fragment","fragmentName","update","cache","value","MissingFieldError","_super","message","path","query","variables","i","hasOwn","isNullish","defaultDataIdFromObject","context","__typename","_id","defaultConfig","normalizeConfig","config","compact","shouldCanonizeResults","getTypenameFromStoreObject","store","objectOrReference","TypeOrFieldNameRegExp","fieldNameFromStoreName","storeFieldName","match","selectionSetMatchesResult","selectionSet","result","item","field","key","storeValueIsStoreObject","makeProcessedFieldsMerger","extractFragmentContext","fragments","fragmentMap","name","def","DELETE","delModifier","INVALIDATE","EntityStore","policies","group","maybeDeepFreeze","objOrRef","objOrIdOrRef","mergeIntoStore","ref","dataId","fieldName","storeObject","Layer","dependOnExistence","older","newer","existing","incoming","merged","storeObjectReconciler","fieldsToDirty_1","fields","changedFields_1","needToMerge_1","allDeleted_1","sharedDetails_1","fieldNameOrOptions","from","fieldValue","modify","newValue","checkReference","seenReference","someNonReference","_i","newValue_1","args","typename","limit","evicted","obj","extraRootIds","newData","__META","rest_1","rootId","count","ids","snapshot","idsToRemove","root_1","found_1","root","workSet_1","child","CacheGroup","caching","parent","canUse","makeDepKey","maybeDependOnExistenceOfEntity","entityId","supportsResultCaching","Root","_b","resultCaching","seed","Stump","layerId","replay","ownStoreObject","parentStoreObject","fromParent","p","existingObject","incomingObject","property","existingValue","incomingValue","execSelectionSetKeyArgs","StoreReader","canonizeResults","peekArgs","other","array","_c","returnPartialData","_d","rootRef","execResult","missing","firstMissing","latest","enclosingRef","objectsToMerge","missingMerger","handleMissing","resultName","workSet","selection","mergeDeep","finalResult","frozen","childResult","assertSelectionSetForIdValue","tree","_","specifierInfoCache","lookupSpecifierInfo","spec","cacheKey","keyFieldsFnFromSpecifier","specifier","info","extract","keyObject","collectSpecifierPaths","schemaKeyPath","extracted","extractKeyPath","extractKey","keyArgsFnFromSpecifier","collected","keyPath","firstKey","firstChar","directiveName_1","d","directiveArgs","variableName","varKeyPath","suffix","extractor","merger","getSpecifierPaths","toMerge","paths_1","currentPath_1","s","normalize","reducer","argsFromFieldSpecifier","nullKeyFieldsFn","simpleKeyArgsFn","_args","mergeTrueFn","mergeObjects","mergeFalseFn","Policies","partialContext","normalizeReadFieldOptions","policy","keyFn","specifierOrId","typePolicies","queryType","mutationType","subscriptionType","keyFields","setMerge","merge","keyArgs","read","which","old","possibleTypes","supertype","subtype","policy_1","supertypes_1","regExp","fuzzy","fuzzySupertypes","rest","inbox","createIfMissing","fieldPolicies","supertypeSet","typenameSupertypeSet","workQueue_1","maybeEnqueue_1","needToCheckFuzzySubtypes","checkingFuzzySubtypes","fuzzyString","fieldSpec","specifierOrString","nameOrField","readOptions","makeFieldFunctionOptions","parentTypename","childTypename","storage","makeMergeObjectsFunction","toReference","canRead","readFieldArgs","argc","stringifyForDisplay","eType","iType","typesDiffer","getContextFlavor","clientOnly","deferred","flavored","StoreWriter","reader","overwrite","operationDefinition","mergeTree","fieldNodeSet","entityRef","applied","fieldsWithSelectionSets_1","hasSelectionSet_1","hasMergeFunction_1","childTree","warnAboutDataLoss","readField","result_1","resultFieldKey","getChildMergeTree","maybeRecycleChildMergeTree","e","dataRef","sets","previous_1","mergeMergeTrees","mergeTreeIsEmpty","cloneDeep","fieldMap","limitingTrie","flatten","inheritedContext","visitedNode","dir","getStorageArgs","e_1","i_1","getValue_1","eVal","iVal","aVal","emptyMergeTreePool","map","left","right","needToMergeMaps","remainingRightKeys_1","leftTree","warnings","existingRef","incomingObj","getChild","parentType","typeDotName","childTypenames","InMemoryCache","DocumentTransform","rootStore","resetResultIdentities","previousReader","c","watch","idToRemove","newOptimisticData","removeOptimistic","onWatchUpdated","perform","layer","optimisticData","alreadyDirty","diff","lastDiff","shallowCopy","ObjectCanon","copy","original","proto","node","proto_1","array_1","keys","firstValueIndex_1","obj_1","json","canonicalStringify","stringifyCanon","resetCanonicalStringify","canonical","stringifyCache","cacheSlot","cacheInfoMap","getCacheInfo","forgetCache","rv","recallCache","makeVar","caches","listeners","broadcast","oldListeners","listener","attach","execute","ApolloLink","HttpLink","createHttpLink","asyncMap","observable","mapFn","catchFn","observer","promiseQueue","callback","resolve","makeCallback","examiner","arg","both","error","handler","sub","graphQLResultHasError","errors","getGraphQLErrorsFromResult","graphQLErrors","incrementalResult","iterateObserversSafely","observers","method","argument","observersWithMethod","obs","fixObservableSubclass","subclass","set","isPromiseLike","Concast","sources","reject","reason","iterable","nextOrError","nextResultListeners","called","equalByQuery","aData","aRest","bData","bRest","equalBySelectionSet","aResult","bResult","seenSelections","selectionHasNonreactiveDirective","resultKey","aResultChild","bResultChild","childSelectionSet","aChildIsArray","bChildIsArray","length_1","directiveIsNonreactive","ObservableQuery","queryManager","queryInfo","subObserver","defaultSubscriptionObserverErrorCallback","first","last","skipCacheDataFor","defaultFetchPolicy","_e","fetchPolicy","_f","initialFetchPolicy","opDef","subscription","saveAsLastResult","lastResult","networkStatus","logMissingFieldErrors","newResult","resultIsDifferent","variablesMustMatch","reobserveOptions","queryDef","vars","v","fetchMoreOptions","combinedOptions","qid","originalNetworkStatus","updatedQuerySet","fetchMoreResult","updateQuery","previous","reobserveCacheFirst","subscriptionData","err","newOptions","mergedOptions","pollInterval","newNetworkStatus","pollingInfo","maybeFetch","poll","useDisposableConcast","oldVariables","oldFetchPolicy","finishWaitingForOwnResult","concast","fromLink","lastError","isDifferent","errorResult","obsQuery","nextFetchPolicy","currentFetchPolicy","LocalState","client","resolvers","fragmentMatcher","resolverGroup","remoteResult","onlyRunForcedResolvers","localResult","forceResolvers","rootValue","mainDefinition","selectionsToResolve","definitionOperation","defaultOperationType","execContext","isClientFieldDescendant","resultsToMerge","typeCondition","fieldResult","fragmentResult","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","directive","isClientField","isSingleASTNode","selectionsToResolveCache","collectByDefinition","definitionNode","matches_1","__","___","ancestors","spread","fragmentSelections","destructiveMethodCounts","wrapDestructiveCacheMethod","methodName","cancelNotifyTimeout","QueryInfo","queryId","oq","oldDiff","watchOptions","lastWrite","cacheWriteBehavior","mergedData","shouldWriteResult","diffOptions","errorPolicy","ignoreErrors","writeWithErrors","QueryManager","link","defaultOptions","documentTransform","queryDeduplication","onBroadcast","ssrMode","clientAwareness","localState","assumeImmutableResults","defaultDocumentTransform","_info","cancel","mutation","optimisticResponse","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","onQueryUpdated","_g","keepRootFields","mutationId","hasClientExports","mutationStoreValue","self","_h","storeResult","cacheWrites","skipCache","updateQueries_1","observableQuery","queryName","updater","currentQueryResult","complete","nextQueryResult","results_1","write","isFinalResult","transformCache","cacheEntry","include","queries","queryNamesAndDocs","legacyQueryOptions","desc","makeUniqueId","included","nameOrDoc","includeStandby","observableQueryPromises","makeObservable","hasErrors","hasProtocolErrors","observablePromise_1","deduplication","serverQuery","clientQuery","inFlightLinkObservables_1","operation","printedServerQuery_1","print","byVariables_1","varJson_1","requestId","linkDocument","aqr","networkError","defaults","notifyOnNetworkStatusChange","normalized","fromVariables","sourcesWithInfo","cleanupCancelFn","containsDataFromLink","updateCache","includedQueriesById","results","refetchWritePolicy","oldNetworkStatus","readCache","resultsFromCache","fromData","resolved","resultsFromLink","shouldNotify","newContext","hasSuggestedDevtools","ApolloClient","uri","credentials","headers","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","version","windowWithDevTools","devtoolsSymbol","nav","ua","url","mergeOptions","cb","payload","fn","serializedState","newLink","NetworkStatus","isNetworkRequestInFlight","isNetworkRequestSettled","loadDevMessages","loadErrorMessageHandler","errorCodes","errorCodes_1","codes","definition","msg","loadErrorMessages","PROTOCOL_ERRORS_SYMBOL","graphQLResultHasProtocolErrors","isApolloError","generateErrorMessage","ApolloError","protocolErrors","clientErrors","errorMessage","extraInfo","devDebug","devLog","devWarn","devError","setContext","setter","forward","request","handle","closed","req","createOperation","starting","next","getContext","transformOperation","transformedOperation","validateOperation","OPERATION_FIELDS","passthrough","op","toLink","isTerminating","links","x","y","test","leftLink","rightLink","second","firstLink","nextLink","split","onError","errorHandler","retriedSub","retriedResult","ErrorLink","serializeFetchParameter","label","serialized","parseError","selectURI","fallbackURI","contextURI","asyncIterator","source","iterator","nodeStreamIterator","stream","cleanup","done","waiting","onData","chunk","shiftedArr","all","pair","onEnd","getNext","promiseIterator","promise","readerIterator","isNodeResponse","isReadableStream","isAsyncIterableIterator","isStreamableBlob","isBlob","isNodeReadableStream","responseIterator","response","body","throwServerError","readMultipartBody","nextValue","decoder","contentType","delimiter","boundaryVal","boundary","buffer","running","searchFrom","bi","contentType_1","parseHeaders","parseJsonBody","headerText","headersInit","line","name_1","bodyText","getResult","handleError","parseAndCheckHttpResponse","operations","checkFetcher","fetcher","defaultHttpOptions","defaultHeaders","fallbackHttpConfig","defaultPrinter","ast","printer","selectHttpOptionsAndBody","fallbackConfig","configs","selectHttpOptionsAndBodyInternal","http","removeDuplicateHeaders","operationName","extensions","preserveHeaderCase","normalizedHeaders_1","headerData","normalizedHeaders","rewriteURIForGET","chosenURI","queryParams","addQueryParam","serializedVariables","serializedExtensions","preFragment","fragmentStart","queryParamsPrefix","newURI","fromError","errorValue","filterOperationVariables","unusedNames","_key","backupFetch","linkOptions","preferredFetch","includeExtensions","useGETForQueries","includeUnusedVariables","requestOptions","linkConfig","clientAwarenessHeaders","contextHeaders","contextConfig","transformedQuery","controller","definitionIsMutation","definitionIsSubscription","isSubscription","hasDefer","acceptHeader","currentFetch","observerNext","ctype","buildDelayFunction","delayOptions","initial","jitter","max","baseDelay","delay","buildRetryFunction","retryOptions","retryIf","RetryableOperation","delayFor","shouldRetry","index","o","RetryLink","attempts","retryable","isLikeCloseEvent","val","isLikeErrorEvent","GraphQLWsLink","likeClose","contextKey","getApolloContext","resetApolloContext","ApolloProvider","children","ApolloContext","parentContext","useApolloClient","override","EAGER_METHODS","useLazyQuery","execOptionsRef","optionsRef","queryRef","internalState","useQueryResult","eagerMethods","_loop_1","EAGER_METHODS_1","executeOptions","queryResult","useMutation","setResult","baseOptions","clientOptions","onCompleted","result_2","reset","result_3","didWarnUncachedGetSnapshot","uSESKey","realHook","useSyncExternalStore","subscribe","getSnapshot","getServerSnapshot","inst","forceUpdate","checkIfSnapshotChanged","useQuery","useInternalState","stateRef","InternalState","state","tick","previousResult","previousData","handleStoreChange","onNext","watchQueryOptions","currentWatchQueryOptions","globalDefaults","skip","ssr","otherOptions","ssrAllowed","nextResult","error_1","partial","resultWithoutPartial","useSubscription","hasIssuedDeprecationWarningRef","setObservable","canResetObservableRef","shouldResubscribe","subscriptionStopped","fetchResult","createFulfilledPromise","createRejectedPromise","isStatefulPromise","wrapPromiseWithState","pendingPromise","fulfilledPromise","rejectedPromise","useKey","__use","statefulPromise","useDeepMemo","memoFn","deps","QUERY_REFERENCE_SYMBOL","wrapQueryRef","internalQueryRef","unwrapQueryRef","OBSERVED_CHANGED_OPTIONS","InternalQueryReference","startDisposeTimer","disposed","option","currentCanonizeResults","returnedPromise","SuspenseCache","createObservable","suspenseCacheSymbol","getSuspenseCache","skipToken","useSuspenseQuery","suspenseCache","useWatchQueryOptions","queryKey","promiseCache","setPromiseCache","dispose","removeListener","skipResult","toApolloError","fetchMore","previousPromiseCache","refetch","subscribeToMore","validateOptions","validateFetchPolicy","validatePartialDataReturn","supportedFetchPolicies","DocumentType","type","parser","cached","mutations","subscriptions","definitions","verifyDocumentType","requiredOperationName","usedOperationName","isArray","isNonEmptyArray","canUseWeakMap","canUseWeakSet","canUseSymbol","canUseAsyncIteratorSymbol","canUseDOM","usingJSDOM","canUseLayoutEffect","toString","cloneDeepHelper","seen","copy_1","copy_2","objects","isExecutionPatchIncrementalResult","isExecutionPatchInitialResult","isExecutionPatchResult","isApolloPayloadResult","mergeIncrementalData","prevResult","isNumericKey","parent_1","prefixCounts","prefix","deepFreeze","shallowFreeze","hasOwnProperty","mergeDeepArray","target","DeepMerger","defaultReconciler","reconciler","sourceKey","targetValue","isNonNullObject","isPlainObject","space","undefId","DEV","wrap","arg0","getHandledErrorMsg","getFallbackErrorMsg","invariant","condition","newInvariantError","optionalParams","ApolloErrorMessageHandler","stringify","messageArgs","maybe","thunk","identity","transform","predicate","transformedDocument","otherTransform","cacheKeys","shouldInclude","directives","getInclusionDirectives","ifArgument","evaledValue","getDirectiveNames","names","hasAnyDirectives","hasDirectives","hasAllDirectives","nameSet","uniqueCount","isInclusionDirective","directiveArguments","directiveName","ifValue","getFragmentQueryDocument","actualFragmentName","createFragmentMap","symTable","getFragmentFromSelection","checkDocument","doc","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","getDefaultValues","defaultValues","defs","printCache","makeReference","isReference","isDocumentNode","isStringValue","isBooleanValue","isIntValue","isFloatValue","isVariable","isObjectValue","isListValue","isEnumValue","isNullValue","valueToObjectRepresentation","argObj","nestedArgObj_1","variableValue","listValue","nestedArgArrayObj","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","filterKeys","filteredArgs_1","completeFieldName","stringifiedArgs","stringifyReplacer","argumentsObjectFromField","argObj_1","resultKeyNameFromField","getTypenameFromResult","isField","fragments_1","isInlineFragment","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","getDirectiveMatcher","tests","testConfig","makeInUseGetterFunction","defaultKey","inUse","removeDirectivesFromDocument","getInUseByOperationName","getInUseByFragmentName","getInUse","ancestor","operationCount","directiveMatcher","shouldRemoveField","nodeDirectives","originalFragmentDefsByPath","firstVisitMadeChanges","fieldOrInlineFragmentVisitor","docWithoutDirectiveSubtrees","_parent","_path","originalNode","populateTransitiveVars","childFragmentName","varName","allFragmentNamesUsed","fragmentWillBeRemoved","enterVisitor","usedVariableNames_1","varDef","addTypenameToDocument","selections","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","hasDirectivesInSelectionSet","nestedCheck","hasDirectivesInSelection","getArgumentMatcher","aConfig","removeArgumentsFromDocument","argMatcher","argConfig","argMatchCount_1","removeFragmentSpreadFromDocument","enter","buildQueryFromSelectionSet","modifiedDoc","removeClientSetsFromDocument"],"sourceRoot":""}