{"version":3,"file":"static/chunks/7573-6bb3c03cc0b35b8d.js","mappings":"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A2BJ,EAAAnsC,EAAA6nB,QAAA,CAAA9nB,IAAA,CAAAC,EAAAqsC,YAAA,CAE3C,GAEAF,CACA,6DGpFAK,aFKA,IAAAC,EAAA,gCAEA,SAAAC,EAAAC,CAAA,EACA,OAAAC,CAAA,CAAAD,EAAAE,UAAA,KAGA,IAAAD,EAAA,CACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,MACA,MACA,MACA,UACA,MACA,MACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,GACA,GACA,MACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,OACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,gBCnKA,IAAAE,EAAA,CACAC,KAAA,CACAC,MAAA,GAAAhjC,EAAAvN,KAAA,EAEAomC,SAAA,CACAmK,MAAA,OAAAhjC,EAAAjK,IAAA,EAGAktC,SAAA,CACAD,MAAA,GAAAx9B,EAAAxF,EAAA+sB,WAAA,QACA,EACAmW,oBAAA,CACAF,MAAAhjC,CAAA,EACA,IAAAmjC,EAAAC,EAAA,IAAA59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","sources":["webpack://_N_E/./node_modules/@apollo/client/cache/core/cache.js","webpack://_N_E/./node_modules/@apollo/client/cache/core/types/common.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/helpers.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/entityStore.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/object-canon.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/readFromStore.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/key-extractor.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/policies.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/writeToStore.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/inMemoryCache.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/reactiveVars.js","webpack://_N_E/./node_modules/@apollo/client/link/core/execute.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/asyncMap.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/errorHandling.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/iteration.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/subclassing.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/Concast.js","webpack://_N_E/./node_modules/@apollo/client/core/equalByQuery.js","webpack://_N_E/./node_modules/@apollo/client/core/ObservableQuery.js","webpack://_N_E/./node_modules/graphql/language/predicates.mjs","webpack://_N_E/./node_modules/@apollo/client/core/LocalState.js","webpack://_N_E/./node_modules/@apollo/client/core/QueryInfo.js","webpack://_N_E/./node_modules/@apollo/client/core/QueryManager.js","webpack://_N_E/./node_modules/@apollo/client/core/ApolloClient.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/createOperation.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/transformOperation.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/validateOperation.js","webpack://_N_E/./node_modules/@apollo/client/link/core/ApolloLink.js","webpack://_N_E/./node_modules/@apollo/client/link/core/from.js","webpack://_N_E/./node_modules/@apollo/client/link/error/index.js","webpack://_N_E/./node_modules/@apollo/client/link/http/serializeFetchParameter.js","webpack://_N_E/./node_modules/@apollo/client/link/http/selectURI.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/async.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/nodeStream.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/promise.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/reader.js","webpack://_N_E/./node_modules/@apollo/client/link/http/responseIterator.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/throwServerError.js","webpack://_N_E/./node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js","webpack://_N_E/./node_modules/@apollo/client/link/http/checkFetcher.js","webpack://_N_E/./node_modules/@apollo/client/link/http/selectHttpOptionsAndBody.js","webpack://_N_E/./node_modules/@apollo/client/link/http/rewriteURIForGET.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/fromError.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/filterOperationVariables.js","webpack://_N_E/./node_modules/@apollo/client/link/http/createHttpLink.js","webpack://_N_E/./node_modules/@apollo/client/link/http/HttpLink.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/canonicalStringify.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/cloneDeep.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/incrementalResult.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/mergeDeep.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/DocumentTransform.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/directives.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/fragments.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/getFromAST.js","webpack://_N_E/./node_modules/graphql/language/printString.mjs","webpack://_N_E/./node_modules/graphql/language/printer.mjs","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/print.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/storeUtils.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/transform.js","webpack://_N_E/./node_modules/@wry/trie/lib/index.js","webpack://_N_E/./node_modules/graphql/language/visitor.mjs","webpack://_N_E/./node_modules/optimism/node_modules/@wry/trie/lib/index.js","webpack://_N_E/./node_modules/@wry/context/lib/slot.js","webpack://_N_E/./node_modules/@wry/context/lib/index.js","webpack://_N_E/./node_modules/optimism/lib/context.js","webpack://_N_E/./node_modules/optimism/lib/helpers.js","webpack://_N_E/./node_modules/optimism/lib/entry.js","webpack://_N_E/./node_modules/optimism/lib/dep.js","webpack://_N_E/./node_modules/optimism/lib/index.js","webpack://_N_E/./node_modules/zen-observable-ts/module.js","webpack://_N_E/<anon>"],"sourcesContent":["import { __assign, __rest } from \"tslib\";\nimport { wrap } from \"optimism\";\nimport { cacheSizes, getFragmentQueryDocument, } from \"../../utilities/index.js\";\nimport { WeakCache } from \"@wry/caches\";\nimport { getApolloCacheMemoryInternals } from \"../../utilities/caching/getMemoryInternals.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            max: cacheSizes[\"cache.fragmentQueryDocuments\"] ||\n                1000 /* defaultCacheSizes[\"cache.fragmentQueryDocuments\"] */,\n            cache: WeakCache,\n        });\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 };\nif (globalThis.__DEV__ !== false) {\n    ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;\n}\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 { 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//# sourceMappingURL=object-canon.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, canonicalStringify, cacheSizes, } 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 { 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        // memoized functions in this class will be \"garbage-collected\"\n        // by recreating the whole `StoreReader` in\n        // `InMemoryCache.resetResultsCache`\n        // (triggered from `InMemoryCache.gc` with `resetResultCache: true`)\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                cacheSizes[\"inMemoryCache.executeSelectionSet\"] ||\n                50000 /* defaultCacheSizes[\"inMemoryCache.executeSelectionSet\"] */,\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                cacheSizes[\"inMemoryCache.executeSubSelectedArray\"] ||\n                10000 /* defaultCacheSizes[\"inMemoryCache.executeSubSelectedArray\"] */,\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\";\nimport { keyArgsFnFromSpecifier, keyFieldsFnFromSpecifier, } from \"./key-extractor.js\";\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, canonicalStringify, } from \"../../utilities/index.js\";\nimport { isArray, makeProcessedFieldsMerger, fieldNameFromStoreName, storeValueIsStoreObject, extractFragmentContext, } from \"./helpers.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, canonicalStringify, print, cacheSizes, } 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 { getInMemoryCacheMemoryInternals } from \"../../utilities/caching/getMemoryInternals.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                cacheSizes[\"inMemoryCache.maybeBroadcastWatch\"] ||\n                5000 /* defaultCacheSizes[\"inMemoryCache.maybeBroadcastWatch\"] */,\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        var _a;\n        canonicalStringify.reset();\n        print.reset();\n        this.addTypenameTransform.resetCache();\n        (_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.resetCaches();\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 };\nif (globalThis.__DEV__ !== false) {\n    InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;\n}\n//# sourceMappingURL=inMemoryCache.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 { 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)); }, _this.handlers.error);\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        /**\n         * An object containing the variables that were provided for the query.\n         */\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    /** @internal */\n    ObservableQuery.prototype.resetDiff = function () {\n        this.queryInfo.resetDiff();\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    /**\n     * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).\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    /**\n     * A function that enables you to execute a [subscription](https://www.apollographql.com/docs/react/data/subscriptions/), usually to subscribe to specific fields that were included in the query.\n     *\n     * This function returns _another_ function that you can call to terminate the subscription.\n     */\n    ObservableQuery.prototype.subscribeToMore = function (options) {\n        var _this = this;\n        var subscription = this.queryManager\n            .startGraphQLSubscription({\n            query: options.document,\n            variables: options.variables,\n            context: options.context,\n        })\n            .subscribe({\n            next: function (subscriptionData) {\n                var updateQuery = options.updateQuery;\n                if (updateQuery) {\n                    _this.updateQuery(function (previous, _a) {\n                        var variables = _a.variables;\n                        return updateQuery(previous, {\n                            subscriptionData: subscriptionData,\n                            variables: variables,\n                        });\n                    });\n                }\n            },\n            error: function (err) {\n                if (options.onError) {\n                    options.onError(err);\n                    return;\n                }\n                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    /**\n     * A function that enables you to update the query's cached result without executing a followup GraphQL operation.\n     *\n     * See [using updateQuery and updateFragment](https://www.apollographql.com/docs/react/caching/cache-interaction/#using-updatequery-and-updatefragment) for additional information.\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    /**\n     * A function that instructs the query to begin re-executing at a specified interval (in milliseconds).\n     */\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        this.options.pollInterval = pollInterval;\n        this.updatePolling();\n    };\n    /**\n     * A function that instructs the query to stop polling after a previous call to `startPolling`.\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            var _a, _b;\n            if (_this.pollingInfo) {\n                if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus) &&\n                    !((_b = (_a = _this.options).skipPollAttempt) === null || _b === void 0 ? void 0 : _b.call(_a))) {\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                if (equal(_this.variables, variables)) {\n                    finishWaitingForOwnResult();\n                    _this.reportResult(result, variables);\n                }\n            },\n            error: function (error) {\n                if (equal(_this.variables, variables)) {\n                    finishWaitingForOwnResult();\n                    _this.reportError(error, variables);\n                }\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 { Kind } from './kinds.mjs';\nexport function isDefinitionNode(node) {\n  return (\n    isExecutableDefinitionNode(node) ||\n    isTypeSystemDefinitionNode(node) ||\n    isTypeSystemExtensionNode(node)\n  );\n}\nexport function isExecutableDefinitionNode(node) {\n  return (\n    node.kind === Kind.OPERATION_DEFINITION ||\n    node.kind === Kind.FRAGMENT_DEFINITION\n  );\n}\nexport function isSelectionNode(node) {\n  return (\n    node.kind === Kind.FIELD ||\n    node.kind === Kind.FRAGMENT_SPREAD ||\n    node.kind === Kind.INLINE_FRAGMENT\n  );\n}\nexport function isValueNode(node) {\n  return (\n    node.kind === Kind.VARIABLE ||\n    node.kind === Kind.INT ||\n    node.kind === Kind.FLOAT ||\n    node.kind === Kind.STRING ||\n    node.kind === Kind.BOOLEAN ||\n    node.kind === Kind.NULL ||\n    node.kind === Kind.ENUM ||\n    node.kind === Kind.LIST ||\n    node.kind === Kind.OBJECT\n  );\n}\nexport function isConstValueNode(node) {\n  return (\n    isValueNode(node) &&\n    (node.kind === Kind.LIST\n      ? node.values.some(isConstValueNode)\n      : node.kind === Kind.OBJECT\n      ? node.fields.some((field) => isConstValueNode(field.value))\n      : node.kind !== Kind.VARIABLE)\n  );\n}\nexport function isTypeNode(node) {\n  return (\n    node.kind === Kind.NAMED_TYPE ||\n    node.kind === Kind.LIST_TYPE ||\n    node.kind === Kind.NON_NULL_TYPE\n  );\n}\nexport function isTypeSystemDefinitionNode(node) {\n  return (\n    node.kind === Kind.SCHEMA_DEFINITION ||\n    isTypeDefinitionNode(node) ||\n    node.kind === Kind.DIRECTIVE_DEFINITION\n  );\n}\nexport function isTypeDefinitionNode(node) {\n  return (\n    node.kind === Kind.SCALAR_TYPE_DEFINITION ||\n    node.kind === Kind.OBJECT_TYPE_DEFINITION ||\n    node.kind === Kind.INTERFACE_TYPE_DEFINITION ||\n    node.kind === Kind.UNION_TYPE_DEFINITION ||\n    node.kind === Kind.ENUM_TYPE_DEFINITION ||\n    node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION\n  );\n}\nexport function isTypeSystemExtensionNode(node) {\n  return node.kind === Kind.SCHEMA_EXTENSION || isTypeExtensionNode(node);\n}\nexport function isTypeExtensionNode(node) {\n  return (\n    node.kind === Kind.SCALAR_TYPE_EXTENSION ||\n    node.kind === Kind.OBJECT_TYPE_EXTENSION ||\n    node.kind === Kind.INTERFACE_TYPE_EXTENSION ||\n    node.kind === Kind.UNION_TYPE_EXTENSION ||\n    node.kind === Kind.ENUM_TYPE_EXTENSION ||\n    node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION\n  );\n}\n","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        // @ts-expect-error this is just too generic to be typed correctly\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.resetDiff = function () {\n        this.lastDiff = void 0;\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 _a;\n        var oldDiff = this.lastDiff && this.lastDiff.diff;\n        // If we do not tolerate partial results, skip this update to prevent it\n        // from being reported. This prevents a situtuation where a query that\n        // errors and another succeeds with overlapping data does not report the\n        // partial data result to the errored query.\n        //\n        // See https://github.com/apollographql/apollo-client/issues/11400 for more\n        // information on this issue.\n        if (diff &&\n            !diff.complete &&\n            !((_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.returnPartialData) &&\n            // In the case of a cache eviction, the diff will become partial so we\n            // schedule a notification to send a network request (this.oqListener) to\n            // go and fetch the missing data.\n            !(oldDiff && oldDiff.complete)) {\n            return;\n        }\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, 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 IGNORE = Object.create(null);\nimport { Trie } from \"@wry/trie\";\nimport { AutoCleanedWeakCache, cacheSizes } from \"../utilities/index.js\";\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, defaultContext = _a.defaultContext;\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 AutoCleanedWeakCache(cacheSizes[\"queryManager.getDocumentInfo\"] ||\n            2000 /* defaultCacheSizes[\"queryManager.getDocumentInfo\"] */);\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 Trie(false);\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        this.defaultContext = defaultContext || Object.create(null);\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, isOptimistic, 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                        isOptimistic = 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                        this.broadcastQueries();\n                        self = this;\n                        return [2 /*return*/, new Promise(function (resolve, reject) {\n                                return asyncMap(self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), 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: isOptimistic ? 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 (isOptimistic) {\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 || \"\").length > 0 ||\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, { IGNORE: IGNORE })\n            : optimisticResponse;\n        if (data === IGNORE) {\n            return false;\n        }\n        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        return true;\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 varJson_1 = canonicalStringify(variables);\n                var entry = inFlightLinkObservables_1.lookup(printedServerQuery_1, varJson_1);\n                observable = entry.observable;\n                if (!observable) {\n                    var concast = new Concast([\n                        execute(link, operation),\n                    ]);\n                    observable = entry.observable = concast;\n                    concast.beforeNext(function () {\n                        inFlightLinkObservables_1.remove(printedServerQuery_1, varJson_1);\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(__assign({}, this.defaultContext), 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\";\nimport { getApolloClientMemoryInternals } from \"../utilities/caching/getMemoryInternals.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, defaultContext = options.defaultContext, _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            defaultContext: defaultContext,\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. In some cases both `data` and `errors` might be undefined, for example\n     * when `errorPolicy` is set to `'ignore'`.\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    Object.defineProperty(ApolloClient.prototype, \"defaultContext\", {\n        get: function () {\n            return this.queryManager.defaultContext;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return ApolloClient;\n}());\nexport { ApolloClient };\nif (globalThis.__DEV__ !== false) {\n    ApolloClient.prototype.getMemoryInternals = getApolloClientMemoryInternals;\n}\n//# sourceMappingURL=ApolloClient.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        var ret;\n        if (isTerminating(leftLink) && isTerminating(rightLink)) {\n            ret = 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            ret = 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        return Object.assign(ret, { left: leftLink, right: rightLink });\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        var ret;\n        if (isTerminating(nextLink)) {\n            ret = new ApolloLink(function (operation) {\n                return firstLink.request(operation, function (op) { return nextLink.request(op) || Observable.of(); }) || Observable.of();\n            });\n        }\n        else {\n            ret = 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        return Object.assign(ret, { left: firstLink, right: nextLink });\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 { __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","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 { AutoCleanedStrongCache, cacheSizes, } from \"../../utilities/caching/index.js\";\nimport { registerGlobalCache } from \"../caching/getMemoryInternals.js\";\n/**\n * Like JSON.stringify, but with object keys always sorted in the same order.\n *\n * To achieve performant sorting, this function uses a Map from JSON-serialized\n * arrays of keys (in any order) to sorted arrays of the same keys, with a\n * single sorted array reference shared by all permutations of the keys.\n *\n * As a drawback, this function will add a little bit more memory for every\n * object encountered that has different (more, less, a different order of) keys\n * than in the past.\n *\n * In a typical application, this extra memory usage should not play a\n * significant role, as `canonicalStringify` will be called for only a limited\n * number of object shapes, and the cache will not grow beyond a certain point.\n * But in some edge cases, this could be a problem, so we provide\n * canonicalStringify.reset() as a way of clearing the cache.\n * */\nexport var canonicalStringify = Object.assign(function canonicalStringify(value) {\n    return JSON.stringify(value, stableObjectReplacer);\n}, {\n    reset: function () {\n        // Clearing the sortingMap will reclaim all cached memory, without\n        // affecting the logical results of canonicalStringify, but potentially\n        // sacrificing performance until the cache is refilled.\n        sortingMap = new AutoCleanedStrongCache(cacheSizes.canonicalStringify || 1000 /* defaultCacheSizes.canonicalStringify */);\n    },\n});\nif (globalThis.__DEV__ !== false) {\n    registerGlobalCache(\"canonicalStringify\", function () { return sortingMap.size; });\n}\n// Values are JSON-serialized arrays of object keys (in any order), and values\n// are sorted arrays of the same keys.\nvar sortingMap;\ncanonicalStringify.reset();\n// The JSON.stringify function takes an optional second argument called a\n// replacer function. This function is called for each key-value pair in the\n// object being stringified, and its return value is used instead of the\n// original value. If the replacer function returns a new value, that value is\n// stringified as JSON instead of the original value of the property.\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#the_replacer_parameter\nfunction stableObjectReplacer(key, value) {\n    if (value && typeof value === \"object\") {\n        var proto = Object.getPrototypeOf(value);\n        // We don't want to mess with objects that are not \"plain\" objects, which\n        // means their prototype is either Object.prototype or null. This check also\n        // prevents needlessly rearranging the indices of arrays.\n        if (proto === Object.prototype || proto === null) {\n            var keys = Object.keys(value);\n            // If keys is already sorted, let JSON.stringify serialize the original\n            // value instead of creating a new object with keys in the same order.\n            if (keys.every(everyKeyInOrder))\n                return value;\n            var unsortedKey = JSON.stringify(keys);\n            var sortedKeys = sortingMap.get(unsortedKey);\n            if (!sortedKeys) {\n                keys.sort();\n                var sortedKey = JSON.stringify(keys);\n                // Checking for sortedKey in the sortingMap allows us to share the same\n                // sorted array reference for all permutations of the same set of keys.\n                sortedKeys = sortingMap.get(sortedKey) || keys;\n                sortingMap.set(unsortedKey, sortedKeys);\n                sortingMap.set(sortedKey, sortedKeys);\n            }\n            var sortedObject_1 = Object.create(proto);\n            // Reassigning the keys in sorted order will cause JSON.stringify to\n            // serialize them in sorted order.\n            sortedKeys.forEach(function (key) {\n                sortedObject_1[key] = value[key];\n            });\n            return sortedObject_1;\n        }\n    }\n    return value;\n}\n// Since everything that happens in stableObjectReplacer benefits from being as\n// efficient as possible, we use a static function as the callback for\n// keys.every in order to test if the provided keys are already sorted without\n// allocating extra memory for a callback.\nfunction everyKeyInOrder(key, i, keys) {\n    return i === 0 || keys[i - 1] <= key;\n}\n//# sourceMappingURL=canonicalStringify.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","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","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 { Trie } from \"@wry/trie\";\nimport { canUseWeakMap, canUseWeakSet } from \"../common/canUse.js\";\nimport { checkDocument } from \"./getFromAST.js\";\nimport { invariant } from \"../globals/index.js\";\nimport { WeakCache } from \"@wry/caches\";\nimport { wrap } from \"optimism\";\nimport { cacheSizes } from \"../caching/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        this.cached = options.cache !== false;\n        this.resetCache();\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 Object.assign(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 }), { left: left, right: right });\n    };\n    /**\n     * Resets the internal cache of this transform, if it has one.\n     */\n    DocumentTransform.prototype.resetCache = function () {\n        var _this = this;\n        if (this.cached) {\n            var stableCacheKeys_1 = new Trie(canUseWeakMap);\n            this.performWork = wrap(DocumentTransform.prototype.performWork.bind(this), {\n                makeCacheKey: function (document) {\n                    var cacheKeys = _this.getCacheKey(document);\n                    if (cacheKeys) {\n                        invariant(Array.isArray(cacheKeys), 66);\n                        return stableCacheKeys_1.lookupArray(cacheKeys);\n                    }\n                },\n                max: cacheSizes[\"documentTransform.cache\"],\n                cache: (WeakCache),\n            });\n        }\n    };\n    DocumentTransform.prototype.performWork = function (document) {\n        checkDocument(document);\n        return this.transform(document);\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 transformedDocument = this.performWork(document);\n        this.resultCache.add(transformedDocument);\n        return transformedDocument;\n    };\n    DocumentTransform.prototype.concat = function (otherTransform) {\n        var _this = this;\n        return Object.assign(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            left: this,\n            right: otherTransform,\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, 67, 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, 68, directiveName);\n            var ifArgument = directiveArguments[0];\n            invariant(ifArgument.name && ifArgument.name.value === \"if\", 69, 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\"), 70, 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                71,\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, 72, 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, 73, 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\", 74);\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(75, definition.kind);\n        }\n        return definition;\n    });\n    invariant(operations.length <= 1, 76, 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\", 77);\n    return queryDef;\n}\nexport function getFragmentDefinition(doc) {\n    invariant(doc.kind === \"Document\", 78);\n    invariant(doc.definitions.length <= 1, 79);\n    var fragmentDef = doc.definitions[0];\n    invariant(fragmentDef.kind === \"FragmentDefinition\", 80);\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(81);\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","/**\n * Prints a string as a GraphQL StringValue literal. Replaces control characters\n * and excluded characters (\" U+0022 and \\\\ U+005C) with escape sequences.\n */\nexport function printString(str) {\n  return `\"${str.replace(escapedRegExp, escapedReplacer)}\"`;\n} // eslint-disable-next-line no-control-regex\n\nconst escapedRegExp = /[\\x00-\\x1f\\x22\\x5c\\x7f-\\x9f]/g;\n\nfunction escapedReplacer(str) {\n  return escapeSequences[str.charCodeAt(0)];\n} // prettier-ignore\n\nconst escapeSequences = [\n  '\\\\u0000',\n  '\\\\u0001',\n  '\\\\u0002',\n  '\\\\u0003',\n  '\\\\u0004',\n  '\\\\u0005',\n  '\\\\u0006',\n  '\\\\u0007',\n  '\\\\b',\n  '\\\\t',\n  '\\\\n',\n  '\\\\u000B',\n  '\\\\f',\n  '\\\\r',\n  '\\\\u000E',\n  '\\\\u000F',\n  '\\\\u0010',\n  '\\\\u0011',\n  '\\\\u0012',\n  '\\\\u0013',\n  '\\\\u0014',\n  '\\\\u0015',\n  '\\\\u0016',\n  '\\\\u0017',\n  '\\\\u0018',\n  '\\\\u0019',\n  '\\\\u001A',\n  '\\\\u001B',\n  '\\\\u001C',\n  '\\\\u001D',\n  '\\\\u001E',\n  '\\\\u001F',\n  '',\n  '',\n  '\\\\\"',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 2F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 3F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 4F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '\\\\\\\\',\n  '',\n  '',\n  '', // 5F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 6F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '\\\\u007F',\n  '\\\\u0080',\n  '\\\\u0081',\n  '\\\\u0082',\n  '\\\\u0083',\n  '\\\\u0084',\n  '\\\\u0085',\n  '\\\\u0086',\n  '\\\\u0087',\n  '\\\\u0088',\n  '\\\\u0089',\n  '\\\\u008A',\n  '\\\\u008B',\n  '\\\\u008C',\n  '\\\\u008D',\n  '\\\\u008E',\n  '\\\\u008F',\n  '\\\\u0090',\n  '\\\\u0091',\n  '\\\\u0092',\n  '\\\\u0093',\n  '\\\\u0094',\n  '\\\\u0095',\n  '\\\\u0096',\n  '\\\\u0097',\n  '\\\\u0098',\n  '\\\\u0099',\n  '\\\\u009A',\n  '\\\\u009B',\n  '\\\\u009C',\n  '\\\\u009D',\n  '\\\\u009E',\n  '\\\\u009F',\n];\n","import { printBlockString } from './blockString.mjs';\nimport { printString } from './printString.mjs';\nimport { visit } from './visitor.mjs';\n/**\n * Converts an AST into a string, using one set of reasonable\n * formatting rules.\n */\n\nexport function print(ast) {\n  return visit(ast, printDocASTReducer);\n}\nconst MAX_LINE_LENGTH = 80;\nconst printDocASTReducer = {\n  Name: {\n    leave: (node) => node.value,\n  },\n  Variable: {\n    leave: (node) => '$' + node.name,\n  },\n  // Document\n  Document: {\n    leave: (node) => join(node.definitions, '\\n\\n'),\n  },\n  OperationDefinition: {\n    leave(node) {\n      const varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');\n      const prefix = join(\n        [\n          node.operation,\n          join([node.name, varDefs]),\n          join(node.directives, ' '),\n        ],\n        ' ',\n      ); // Anonymous queries with no directives or variable definitions can use\n      // the query short form.\n\n      return (prefix === 'query' ? '' : prefix + ' ') + node.selectionSet;\n    },\n  },\n  VariableDefinition: {\n    leave: ({ variable, type, defaultValue, directives }) =>\n      variable +\n      ': ' +\n      type +\n      wrap(' = ', defaultValue) +\n      wrap(' ', join(directives, ' ')),\n  },\n  SelectionSet: {\n    leave: ({ selections }) => block(selections),\n  },\n  Field: {\n    leave({ alias, name, arguments: args, directives, selectionSet }) {\n      const prefix = wrap('', alias, ': ') + name;\n      let argsLine = prefix + wrap('(', join(args, ', '), ')');\n\n      if (argsLine.length > MAX_LINE_LENGTH) {\n        argsLine = prefix + wrap('(\\n', indent(join(args, '\\n')), '\\n)');\n      }\n\n      return join([argsLine, join(directives, ' '), selectionSet], ' ');\n    },\n  },\n  Argument: {\n    leave: ({ name, value }) => name + ': ' + value,\n  },\n  // Fragments\n  FragmentSpread: {\n    leave: ({ name, directives }) =>\n      '...' + name + wrap(' ', join(directives, ' ')),\n  },\n  InlineFragment: {\n    leave: ({ typeCondition, directives, selectionSet }) =>\n      join(\n        [\n          '...',\n          wrap('on ', typeCondition),\n          join(directives, ' '),\n          selectionSet,\n        ],\n        ' ',\n      ),\n  },\n  FragmentDefinition: {\n    leave: (\n      { name, typeCondition, variableDefinitions, directives, selectionSet }, // Note: fragment variable definitions are experimental and may be changed\n    ) =>\n      // or removed in the future.\n      `fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` +\n      `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}` +\n      selectionSet,\n  },\n  // Value\n  IntValue: {\n    leave: ({ value }) => value,\n  },\n  FloatValue: {\n    leave: ({ value }) => value,\n  },\n  StringValue: {\n    leave: ({ value, block: isBlockString }) =>\n      isBlockString ? printBlockString(value) : printString(value),\n  },\n  BooleanValue: {\n    leave: ({ value }) => (value ? 'true' : 'false'),\n  },\n  NullValue: {\n    leave: () => 'null',\n  },\n  EnumValue: {\n    leave: ({ value }) => value,\n  },\n  ListValue: {\n    leave: ({ values }) => '[' + join(values, ', ') + ']',\n  },\n  ObjectValue: {\n    leave: ({ fields }) => '{' + join(fields, ', ') + '}',\n  },\n  ObjectField: {\n    leave: ({ name, value }) => name + ': ' + value,\n  },\n  // Directive\n  Directive: {\n    leave: ({ name, arguments: args }) =>\n      '@' + name + wrap('(', join(args, ', '), ')'),\n  },\n  // Type\n  NamedType: {\n    leave: ({ name }) => name,\n  },\n  ListType: {\n    leave: ({ type }) => '[' + type + ']',\n  },\n  NonNullType: {\n    leave: ({ type }) => type + '!',\n  },\n  // Type System Definitions\n  SchemaDefinition: {\n    leave: ({ description, directives, operationTypes }) =>\n      wrap('', description, '\\n') +\n      join(['schema', join(directives, ' '), block(operationTypes)], ' '),\n  },\n  OperationTypeDefinition: {\n    leave: ({ operation, type }) => operation + ': ' + type,\n  },\n  ScalarTypeDefinition: {\n    leave: ({ description, name, directives }) =>\n      wrap('', description, '\\n') +\n      join(['scalar', name, join(directives, ' ')], ' '),\n  },\n  ObjectTypeDefinition: {\n    leave: ({ description, name, interfaces, directives, fields }) =>\n      wrap('', description, '\\n') +\n      join(\n        [\n          'type',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  FieldDefinition: {\n    leave: ({ description, name, arguments: args, type, directives }) =>\n      wrap('', description, '\\n') +\n      name +\n      (hasMultilineItems(args)\n        ? wrap('(\\n', indent(join(args, '\\n')), '\\n)')\n        : wrap('(', join(args, ', '), ')')) +\n      ': ' +\n      type +\n      wrap(' ', join(directives, ' ')),\n  },\n  InputValueDefinition: {\n    leave: ({ description, name, type, defaultValue, directives }) =>\n      wrap('', description, '\\n') +\n      join(\n        [name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')],\n        ' ',\n      ),\n  },\n  InterfaceTypeDefinition: {\n    leave: ({ description, name, interfaces, directives, fields }) =>\n      wrap('', description, '\\n') +\n      join(\n        [\n          'interface',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  UnionTypeDefinition: {\n    leave: ({ description, name, directives, types }) =>\n      wrap('', description, '\\n') +\n      join(\n        ['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))],\n        ' ',\n      ),\n  },\n  EnumTypeDefinition: {\n    leave: ({ description, name, directives, values }) =>\n      wrap('', description, '\\n') +\n      join(['enum', name, join(directives, ' '), block(values)], ' '),\n  },\n  EnumValueDefinition: {\n    leave: ({ description, name, directives }) =>\n      wrap('', description, '\\n') + join([name, join(directives, ' ')], ' '),\n  },\n  InputObjectTypeDefinition: {\n    leave: ({ description, name, directives, fields }) =>\n      wrap('', description, '\\n') +\n      join(['input', name, join(directives, ' '), block(fields)], ' '),\n  },\n  DirectiveDefinition: {\n    leave: ({ description, name, arguments: args, repeatable, locations }) =>\n      wrap('', description, '\\n') +\n      'directive @' +\n      name +\n      (hasMultilineItems(args)\n        ? wrap('(\\n', indent(join(args, '\\n')), '\\n)')\n        : wrap('(', join(args, ', '), ')')) +\n      (repeatable ? ' repeatable' : '') +\n      ' on ' +\n      join(locations, ' | '),\n  },\n  SchemaExtension: {\n    leave: ({ directives, operationTypes }) =>\n      join(\n        ['extend schema', join(directives, ' '), block(operationTypes)],\n        ' ',\n      ),\n  },\n  ScalarTypeExtension: {\n    leave: ({ name, directives }) =>\n      join(['extend scalar', name, join(directives, ' ')], ' '),\n  },\n  ObjectTypeExtension: {\n    leave: ({ name, interfaces, directives, fields }) =>\n      join(\n        [\n          'extend type',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  InterfaceTypeExtension: {\n    leave: ({ name, interfaces, directives, fields }) =>\n      join(\n        [\n          'extend interface',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  UnionTypeExtension: {\n    leave: ({ name, directives, types }) =>\n      join(\n        [\n          'extend union',\n          name,\n          join(directives, ' '),\n          wrap('= ', join(types, ' | ')),\n        ],\n        ' ',\n      ),\n  },\n  EnumTypeExtension: {\n    leave: ({ name, directives, values }) =>\n      join(['extend enum', name, join(directives, ' '), block(values)], ' '),\n  },\n  InputObjectTypeExtension: {\n    leave: ({ name, directives, fields }) =>\n      join(['extend input', name, join(directives, ' '), block(fields)], ' '),\n  },\n};\n/**\n * Given maybeArray, print an empty string if it is null or empty, otherwise\n * print all items together separated by separator if provided\n */\n\nfunction join(maybeArray, separator = '') {\n  var _maybeArray$filter$jo;\n\n  return (_maybeArray$filter$jo =\n    maybeArray === null || maybeArray === void 0\n      ? void 0\n      : maybeArray.filter((x) => x).join(separator)) !== null &&\n    _maybeArray$filter$jo !== void 0\n    ? _maybeArray$filter$jo\n    : '';\n}\n/**\n * Given array, print each item on its own line, wrapped in an indented `{ }` block.\n */\n\nfunction block(array) {\n  return wrap('{\\n', indent(join(array, '\\n')), '\\n}');\n}\n/**\n * If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.\n */\n\nfunction wrap(start, maybeString, end = '') {\n  return maybeString != null && maybeString !== ''\n    ? start + maybeString + end\n    : '';\n}\n\nfunction indent(str) {\n  return wrap('  ', str.replace(/\\n/g, '\\n  '));\n}\n\nfunction hasMultilineItems(maybeArray) {\n  var _maybeArray$some;\n\n  // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n  /* c8 ignore next */\n  return (_maybeArray$some =\n    maybeArray === null || maybeArray === void 0\n      ? void 0\n      : maybeArray.some((str) => str.includes('\\n'))) !== null &&\n    _maybeArray$some !== void 0\n    ? _maybeArray$some\n    : false;\n}\n","import { print as origPrint } from \"graphql\";\nimport { AutoCleanedWeakCache, cacheSizes, } from \"../caching/index.js\";\nimport { registerGlobalCache } from \"../caching/getMemoryInternals.js\";\nvar printCache;\nexport var print = Object.assign(function (ast) {\n    var result = printCache.get(ast);\n    if (!result) {\n        result = origPrint(ast);\n        printCache.set(ast, result);\n    }\n    return result;\n}, {\n    reset: function () {\n        printCache = new AutoCleanedWeakCache(cacheSizes.print || 2000 /* defaultCacheSizes.print */);\n    },\n});\nprint.reset();\nif (globalThis.__DEV__ !== false) {\n    registerGlobalCache(\"print\", function () { return (printCache ? printCache.size : 0); });\n}\n//# sourceMappingURL=print.js.map","import { newInvariantError } from \"../globals/index.js\";\nimport { isNonNullObject } from \"../common/objects.js\";\nimport { getFragmentFromSelection } from \"./fragments.js\";\nimport { canonicalStringify } from \"../common/canonicalStringify.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(82, 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];\n// Default stable JSON.stringify implementation used by getStoreKeyName. Can be\n// updated/replaced with something better by calling\n// getStoreKeyName.setStringify(newStringifyFunction).\nvar storeKeyNameStringify = canonicalStringify;\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(storeKeyNameStringify(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 = storeKeyNameStringify(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(storeKeyNameStringify(directives[key]), \")\");\n            }\n            else {\n                completeFieldName += \"@\".concat(key);\n            }\n        });\n    }\n    return completeFieldName;\n}, {\n    setStringify: function (s) {\n        var previous = storeKeyNameStringify;\n        storeKeyNameStringify = s;\n        return previous;\n    },\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(83);\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(84);\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","// A [trie](https://en.wikipedia.org/wiki/Trie) data structure that holds\n// object keys weakly, yet can also hold non-object keys, unlike the\n// native `WeakMap`.\n// If no makeData function is supplied, the looked-up data will be an empty,\n// null-prototype Object.\nconst defaultMakeData = () => Object.create(null);\n// Useful for processing arguments objects as well as arrays.\nconst { forEach, slice } = Array.prototype;\nconst { hasOwnProperty } = Object.prototype;\nexport class Trie {\n    constructor(weakness = true, makeData = defaultMakeData) {\n        this.weakness = weakness;\n        this.makeData = makeData;\n    }\n    lookup() {\n        return this.lookupArray(arguments);\n    }\n    lookupArray(array) {\n        let node = this;\n        forEach.call(array, key => node = node.getChildTrie(key));\n        return hasOwnProperty.call(node, \"data\")\n            ? node.data\n            : node.data = this.makeData(slice.call(array));\n    }\n    peek() {\n        return this.peekArray(arguments);\n    }\n    peekArray(array) {\n        let node = this;\n        for (let i = 0, len = array.length; node && i < len; ++i) {\n            const map = node.mapFor(array[i], false);\n            node = map && map.get(array[i]);\n        }\n        return node && node.data;\n    }\n    remove() {\n        return this.removeArray(arguments);\n    }\n    removeArray(array) {\n        let data;\n        if (array.length) {\n            const head = array[0];\n            const map = this.mapFor(head, false);\n            const child = map && map.get(head);\n            if (child) {\n                data = child.removeArray(slice.call(array, 1));\n                if (!child.data && !child.weak && !(child.strong && child.strong.size)) {\n                    map.delete(head);\n                }\n            }\n        }\n        else {\n            data = this.data;\n            delete this.data;\n        }\n        return data;\n    }\n    getChildTrie(key) {\n        const map = this.mapFor(key, true);\n        let child = map.get(key);\n        if (!child)\n            map.set(key, child = new Trie(this.weakness, this.makeData));\n        return child;\n    }\n    mapFor(key, create) {\n        return this.weakness && isObjRef(key)\n            ? this.weak || (create ? this.weak = new WeakMap : void 0)\n            : this.strong || (create ? this.strong = new Map : void 0);\n    }\n}\nfunction isObjRef(value) {\n    switch (typeof value) {\n        case \"object\":\n            if (value === null)\n                break;\n        // Fall through to return true...\n        case \"function\":\n            return true;\n    }\n    return false;\n}\n//# sourceMappingURL=index.js.map","import { devAssert } from '../jsutils/devAssert.mjs';\nimport { inspect } from '../jsutils/inspect.mjs';\nimport { isNode, QueryDocumentKeys } from './ast.mjs';\nimport { Kind } from './kinds.mjs';\n/**\n * A visitor is provided to visit, it contains the collection of\n * relevant functions to be called during the visitor's traversal.\n */\n\nexport const BREAK = Object.freeze({});\n/**\n * visit() will walk through an AST using a depth-first traversal, calling\n * the visitor's enter function at each node in the traversal, and calling the\n * leave function after visiting that node and all of its child nodes.\n *\n * By returning different values from the enter and leave functions, the\n * behavior of the visitor can be altered, including skipping over a sub-tree of\n * the AST (by returning false), editing the AST by returning a value or null\n * to remove the value, or to stop the whole traversal by returning BREAK.\n *\n * When using visit() to edit an AST, the original AST will not be modified, and\n * a new version of the AST with the changes applied will be returned from the\n * visit function.\n *\n * ```ts\n * const editedAST = visit(ast, {\n *   enter(node, key, parent, path, ancestors) {\n *     // @return\n *     //   undefined: no action\n *     //   false: skip visiting this node\n *     //   visitor.BREAK: stop visiting altogether\n *     //   null: delete this node\n *     //   any value: replace this node with the returned value\n *   },\n *   leave(node, key, parent, path, ancestors) {\n *     // @return\n *     //   undefined: no action\n *     //   false: no action\n *     //   visitor.BREAK: stop visiting altogether\n *     //   null: delete this node\n *     //   any value: replace this node with the returned value\n *   }\n * });\n * ```\n *\n * Alternatively to providing enter() and leave() functions, a visitor can\n * instead provide functions named the same as the kinds of AST nodes, or\n * enter/leave visitors at a named key, leading to three permutations of the\n * visitor API:\n *\n * 1) Named visitors triggered when entering a node of a specific kind.\n *\n * ```ts\n * visit(ast, {\n *   Kind(node) {\n *     // enter the \"Kind\" node\n *   }\n * })\n * ```\n *\n * 2) Named visitors that trigger upon entering and leaving a node of a specific kind.\n *\n * ```ts\n * visit(ast, {\n *   Kind: {\n *     enter(node) {\n *       // enter the \"Kind\" node\n *     }\n *     leave(node) {\n *       // leave the \"Kind\" node\n *     }\n *   }\n * })\n * ```\n *\n * 3) Generic visitors that trigger upon entering and leaving any node.\n *\n * ```ts\n * visit(ast, {\n *   enter(node) {\n *     // enter any node\n *   },\n *   leave(node) {\n *     // leave any node\n *   }\n * })\n * ```\n */\n\nexport function visit(root, visitor, visitorKeys = QueryDocumentKeys) {\n  const enterLeaveMap = new Map();\n\n  for (const kind of Object.values(Kind)) {\n    enterLeaveMap.set(kind, getEnterLeaveForKind(visitor, kind));\n  }\n  /* eslint-disable no-undef-init */\n\n  let stack = undefined;\n  let inArray = Array.isArray(root);\n  let keys = [root];\n  let index = -1;\n  let edits = [];\n  let node = root;\n  let key = undefined;\n  let parent = undefined;\n  const path = [];\n  const ancestors = [];\n  /* eslint-enable no-undef-init */\n\n  do {\n    index++;\n    const isLeaving = index === keys.length;\n    const isEdited = isLeaving && edits.length !== 0;\n\n    if (isLeaving) {\n      key = ancestors.length === 0 ? undefined : path[path.length - 1];\n      node = parent;\n      parent = ancestors.pop();\n\n      if (isEdited) {\n        if (inArray) {\n          node = node.slice();\n          let editOffset = 0;\n\n          for (const [editKey, editValue] of edits) {\n            const arrayKey = editKey - editOffset;\n\n            if (editValue === null) {\n              node.splice(arrayKey, 1);\n              editOffset++;\n            } else {\n              node[arrayKey] = editValue;\n            }\n          }\n        } else {\n          node = Object.defineProperties(\n            {},\n            Object.getOwnPropertyDescriptors(node),\n          );\n\n          for (const [editKey, editValue] of edits) {\n            node[editKey] = editValue;\n          }\n        }\n      }\n\n      index = stack.index;\n      keys = stack.keys;\n      edits = stack.edits;\n      inArray = stack.inArray;\n      stack = stack.prev;\n    } else if (parent) {\n      key = inArray ? index : keys[index];\n      node = parent[key];\n\n      if (node === null || node === undefined) {\n        continue;\n      }\n\n      path.push(key);\n    }\n\n    let result;\n\n    if (!Array.isArray(node)) {\n      var _enterLeaveMap$get, _enterLeaveMap$get2;\n\n      isNode(node) || devAssert(false, `Invalid AST Node: ${inspect(node)}.`);\n      const visitFn = isLeaving\n        ? (_enterLeaveMap$get = enterLeaveMap.get(node.kind)) === null ||\n          _enterLeaveMap$get === void 0\n          ? void 0\n          : _enterLeaveMap$get.leave\n        : (_enterLeaveMap$get2 = enterLeaveMap.get(node.kind)) === null ||\n          _enterLeaveMap$get2 === void 0\n        ? void 0\n        : _enterLeaveMap$get2.enter;\n      result =\n        visitFn === null || visitFn === void 0\n          ? void 0\n          : visitFn.call(visitor, node, key, parent, path, ancestors);\n\n      if (result === BREAK) {\n        break;\n      }\n\n      if (result === false) {\n        if (!isLeaving) {\n          path.pop();\n          continue;\n        }\n      } else if (result !== undefined) {\n        edits.push([key, result]);\n\n        if (!isLeaving) {\n          if (isNode(result)) {\n            node = result;\n          } else {\n            path.pop();\n            continue;\n          }\n        }\n      }\n    }\n\n    if (result === undefined && isEdited) {\n      edits.push([key, node]);\n    }\n\n    if (isLeaving) {\n      path.pop();\n    } else {\n      var _node$kind;\n\n      stack = {\n        inArray,\n        index,\n        keys,\n        edits,\n        prev: stack,\n      };\n      inArray = Array.isArray(node);\n      keys = inArray\n        ? node\n        : (_node$kind = visitorKeys[node.kind]) !== null &&\n          _node$kind !== void 0\n        ? _node$kind\n        : [];\n      index = -1;\n      edits = [];\n\n      if (parent) {\n        ancestors.push(parent);\n      }\n\n      parent = node;\n    }\n  } while (stack !== undefined);\n\n  if (edits.length !== 0) {\n    // New root\n    return edits[edits.length - 1][1];\n  }\n\n  return root;\n}\n/**\n * Creates a new visitor instance which delegates to many visitors to run in\n * parallel. Each visitor will be visited for each node before moving on.\n *\n * If a prior visitor edits a node, no following visitors will see that node.\n */\n\nexport function visitInParallel(visitors) {\n  const skipping = new Array(visitors.length).fill(null);\n  const mergedVisitor = Object.create(null);\n\n  for (const kind of Object.values(Kind)) {\n    let hasVisitor = false;\n    const enterList = new Array(visitors.length).fill(undefined);\n    const leaveList = new Array(visitors.length).fill(undefined);\n\n    for (let i = 0; i < visitors.length; ++i) {\n      const { enter, leave } = getEnterLeaveForKind(visitors[i], kind);\n      hasVisitor || (hasVisitor = enter != null || leave != null);\n      enterList[i] = enter;\n      leaveList[i] = leave;\n    }\n\n    if (!hasVisitor) {\n      continue;\n    }\n\n    const mergedEnterLeave = {\n      enter(...args) {\n        const node = args[0];\n\n        for (let i = 0; i < visitors.length; i++) {\n          if (skipping[i] === null) {\n            var _enterList$i;\n\n            const result =\n              (_enterList$i = enterList[i]) === null || _enterList$i === void 0\n                ? void 0\n                : _enterList$i.apply(visitors[i], args);\n\n            if (result === false) {\n              skipping[i] = node;\n            } else if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined) {\n              return result;\n            }\n          }\n        }\n      },\n\n      leave(...args) {\n        const node = args[0];\n\n        for (let i = 0; i < visitors.length; i++) {\n          if (skipping[i] === null) {\n            var _leaveList$i;\n\n            const result =\n              (_leaveList$i = leaveList[i]) === null || _leaveList$i === void 0\n                ? void 0\n                : _leaveList$i.apply(visitors[i], args);\n\n            if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined && result !== false) {\n              return result;\n            }\n          } else if (skipping[i] === node) {\n            skipping[i] = null;\n          }\n        }\n      },\n    };\n    mergedVisitor[kind] = mergedEnterLeave;\n  }\n\n  return mergedVisitor;\n}\n/**\n * Given a visitor instance and a node kind, return EnterLeaveVisitor for that kind.\n */\n\nexport function getEnterLeaveForKind(visitor, kind) {\n  const kindVisitor = visitor[kind];\n\n  if (typeof kindVisitor === 'object') {\n    // { Kind: { enter() {}, leave() {} } }\n    return kindVisitor;\n  } else if (typeof kindVisitor === 'function') {\n    // { Kind() {} }\n    return {\n      enter: kindVisitor,\n      leave: undefined,\n    };\n  } // { enter() {}, leave() {} }\n\n  return {\n    enter: visitor.enter,\n    leave: visitor.leave,\n  };\n}\n/**\n * Given a visitor instance, if it is leaving or not, and a node kind, return\n * the function the visitor runtime should call.\n *\n * @deprecated Please use `getEnterLeaveForKind` instead. Will be removed in v17\n */\n\n/* c8 ignore next 8 */\n\nexport function getVisitFn(visitor, kind, isLeaving) {\n  const { enter, leave } = getEnterLeaveForKind(visitor, kind);\n  return isLeaving ? leave : enter;\n}\n","// A [trie](https://en.wikipedia.org/wiki/Trie) data structure that holds\n// object keys weakly, yet can also hold non-object keys, unlike the\n// native `WeakMap`.\n// If no makeData function is supplied, the looked-up data will be an empty,\n// null-prototype Object.\nconst defaultMakeData = () => Object.create(null);\n// Useful for processing arguments objects as well as arrays.\nconst { forEach, slice } = Array.prototype;\nconst { hasOwnProperty } = Object.prototype;\nexport class Trie {\n    constructor(weakness = true, makeData = defaultMakeData) {\n        this.weakness = weakness;\n        this.makeData = makeData;\n    }\n    lookup(...array) {\n        return this.lookupArray(array);\n    }\n    lookupArray(array) {\n        let node = this;\n        forEach.call(array, key => node = node.getChildTrie(key));\n        return hasOwnProperty.call(node, \"data\")\n            ? node.data\n            : node.data = this.makeData(slice.call(array));\n    }\n    peek(...array) {\n        return this.peekArray(array);\n    }\n    peekArray(array) {\n        let node = this;\n        for (let i = 0, len = array.length; node && i < len; ++i) {\n            const map = this.weakness && isObjRef(array[i]) ? node.weak : node.strong;\n            node = map && map.get(array[i]);\n        }\n        return node && node.data;\n    }\n    getChildTrie(key) {\n        const map = this.weakness && isObjRef(key)\n            ? this.weak || (this.weak = new WeakMap())\n            : this.strong || (this.strong = new Map());\n        let child = map.get(key);\n        if (!child)\n            map.set(key, child = new Trie(this.weakness, this.makeData));\n        return child;\n    }\n}\nfunction isObjRef(value) {\n    switch (typeof value) {\n        case \"object\":\n            if (value === null)\n                break;\n        // Fall through to return true...\n        case \"function\":\n            return true;\n    }\n    return false;\n}\n//# sourceMappingURL=index.js.map","// This currentContext variable will only be used if the makeSlotClass\n// function is called, which happens only if this is the first copy of the\n// @wry/context package to be imported.\nlet currentContext = null;\n// This unique internal object is used to denote the absence of a value\n// for a given Slot, and is never exposed to outside code.\nconst MISSING_VALUE = {};\nlet idCounter = 1;\n// Although we can't do anything about the cost of duplicated code from\n// accidentally bundling multiple copies of the @wry/context package, we can\n// avoid creating the Slot class more than once using makeSlotClass.\nconst makeSlotClass = () => class Slot {\n    constructor() {\n        // If you have a Slot object, you can find out its slot.id, but you cannot\n        // guess the slot.id of a Slot you don't have access to, thanks to the\n        // randomized suffix.\n        this.id = [\n            \"slot\",\n            idCounter++,\n            Date.now(),\n            Math.random().toString(36).slice(2),\n        ].join(\":\");\n    }\n    hasValue() {\n        for (let context = currentContext; context; context = context.parent) {\n            // We use the Slot object iself as a key to its value, which means the\n            // value cannot be obtained without a reference to the Slot object.\n            if (this.id in context.slots) {\n                const value = context.slots[this.id];\n                if (value === MISSING_VALUE)\n                    break;\n                if (context !== currentContext) {\n                    // Cache the value in currentContext.slots so the next lookup will\n                    // be faster. This caching is safe because the tree of contexts and\n                    // the values of the slots are logically immutable.\n                    currentContext.slots[this.id] = value;\n                }\n                return true;\n            }\n        }\n        if (currentContext) {\n            // If a value was not found for this Slot, it's never going to be found\n            // no matter how many times we look it up, so we might as well cache\n            // the absence of the value, too.\n            currentContext.slots[this.id] = MISSING_VALUE;\n        }\n        return false;\n    }\n    getValue() {\n        if (this.hasValue()) {\n            return currentContext.slots[this.id];\n        }\n    }\n    withValue(value, callback, \n    // Given the prevalence of arrow functions, specifying arguments is likely\n    // to be much more common than specifying `this`, hence this ordering:\n    args, thisArg) {\n        const slots = {\n            __proto__: null,\n            [this.id]: value,\n        };\n        const parent = currentContext;\n        currentContext = { parent, slots };\n        try {\n            // Function.prototype.apply allows the arguments array argument to be\n            // omitted or undefined, so args! is fine here.\n            return callback.apply(thisArg, args);\n        }\n        finally {\n            currentContext = parent;\n        }\n    }\n    // Capture the current context and wrap a callback function so that it\n    // reestablishes the captured context when called.\n    static bind(callback) {\n        const context = currentContext;\n        return function () {\n            const saved = currentContext;\n            try {\n                currentContext = context;\n                return callback.apply(this, arguments);\n            }\n            finally {\n                currentContext = saved;\n            }\n        };\n    }\n    // Immediately run a callback function without any captured context.\n    static noContext(callback, \n    // Given the prevalence of arrow functions, specifying arguments is likely\n    // to be much more common than specifying `this`, hence this ordering:\n    args, thisArg) {\n        if (currentContext) {\n            const saved = currentContext;\n            try {\n                currentContext = null;\n                // Function.prototype.apply allows the arguments array argument to be\n                // omitted or undefined, so args! is fine here.\n                return callback.apply(thisArg, args);\n            }\n            finally {\n                currentContext = saved;\n            }\n        }\n        else {\n            return callback.apply(thisArg, args);\n        }\n    }\n};\nfunction maybe(fn) {\n    try {\n        return fn();\n    }\n    catch (ignored) { }\n}\n// We store a single global implementation of the Slot class as a permanent\n// non-enumerable property of the globalThis object. This obfuscation does\n// nothing to prevent access to the Slot class, but at least it ensures the\n// implementation (i.e. currentContext) cannot be tampered with, and all copies\n// of the @wry/context package (hopefully just one) will share the same Slot\n// implementation. Since the first copy of the @wry/context package to be\n// imported wins, this technique imposes a steep cost for any future breaking\n// changes to the Slot class.\nconst globalKey = \"@wry/context:Slot\";\nconst host = \n// Prefer globalThis when available.\n// https://github.com/benjamn/wryware/issues/347\nmaybe(() => globalThis) ||\n    // Fall back to global, which works in Node.js and may be converted by some\n    // bundlers to the appropriate identifier (window, self, ...) depending on the\n    // bundling target. https://github.com/endojs/endo/issues/576#issuecomment-1178515224\n    maybe(() => global) ||\n    // Otherwise, use a dummy host that's local to this module. We used to fall\n    // back to using the Array constructor as a namespace, but that was flagged in\n    // https://github.com/benjamn/wryware/issues/347, and can be avoided.\n    Object.create(null);\n// Whichever globalHost we're using, make TypeScript happy about the additional\n// globalKey property.\nconst globalHost = host;\nexport const Slot = globalHost[globalKey] ||\n    // Earlier versions of this package stored the globalKey property on the Array\n    // constructor, so we check there as well, to prevent Slot class duplication.\n    Array[globalKey] ||\n    (function (Slot) {\n        try {\n            Object.defineProperty(globalHost, globalKey, {\n                value: Slot,\n                enumerable: false,\n                writable: false,\n                // When it was possible for globalHost to be the Array constructor (a\n                // legacy Slot dedup strategy), it was important for the property to be\n                // configurable:true so it could be deleted. That does not seem to be as\n                // important when globalHost is the global object, but I don't want to\n                // cause similar problems again, and configurable:true seems safest.\n                // https://github.com/endojs/endo/issues/576#issuecomment-1178274008\n                configurable: true\n            });\n        }\n        finally {\n            return Slot;\n        }\n    })(makeSlotClass());\n//# sourceMappingURL=slot.js.map","import { Slot } from \"./slot.js\";\nexport { Slot };\nexport const { bind, noContext } = Slot;\n// Like global.setTimeout, except the callback runs with captured context.\nexport { setTimeoutWithContext as setTimeout };\nfunction setTimeoutWithContext(callback, delay) {\n    return setTimeout(bind(callback), delay);\n}\n// Turn any generator function into an async function (using yield instead\n// of await), with context automatically preserved across yields.\nexport function asyncFromGen(genFn) {\n    return function () {\n        const gen = genFn.apply(this, arguments);\n        const boundNext = bind(gen.next);\n        const boundThrow = bind(gen.throw);\n        return new Promise((resolve, reject) => {\n            function invoke(method, argument) {\n                try {\n                    var result = method.call(gen, argument);\n                }\n                catch (error) {\n                    return reject(error);\n                }\n                const next = result.done ? resolve : invokeNext;\n                if (isPromiseLike(result.value)) {\n                    result.value.then(next, result.done ? reject : invokeThrow);\n                }\n                else {\n                    next(result.value);\n                }\n            }\n            const invokeNext = (value) => invoke(boundNext, value);\n            const invokeThrow = (error) => invoke(boundThrow, error);\n            invokeNext();\n        });\n    };\n}\nfunction isPromiseLike(value) {\n    return value && typeof value.then === \"function\";\n}\n// If you use the fibers npm package to implement coroutines in Node.js,\n// you should call this function at least once to ensure context management\n// remains coherent across any yields.\nconst wrappedFibers = [];\nexport function wrapYieldingFiberMethods(Fiber) {\n    // There can be only one implementation of Fiber per process, so this array\n    // should never grow longer than one element.\n    if (wrappedFibers.indexOf(Fiber) < 0) {\n        const wrap = (obj, method) => {\n            const fn = obj[method];\n            obj[method] = function () {\n                return noContext(fn, arguments, this);\n            };\n        };\n        // These methods can yield, according to\n        // https://github.com/laverdet/node-fibers/blob/ddebed9b8ae3883e57f822e2108e6943e5c8d2a8/fibers.js#L97-L100\n        wrap(Fiber, \"yield\");\n        wrap(Fiber.prototype, \"run\");\n        wrap(Fiber.prototype, \"throwInto\");\n        wrappedFibers.push(Fiber);\n    }\n    return Fiber;\n}\n//# sourceMappingURL=index.js.map","import { Slot } from \"@wry/context\";\nexport const parentEntrySlot = new Slot();\nexport function nonReactive(fn) {\n    return parentEntrySlot.withValue(void 0, fn);\n}\nexport { Slot };\nexport { bind as bindContext, noContext, setTimeout, asyncFromGen, } from \"@wry/context\";\n//# sourceMappingURL=context.js.map","export const { hasOwnProperty, } = Object.prototype;\nexport const arrayFromSet = Array.from ||\n    function (set) {\n        const array = [];\n        set.forEach(item => array.push(item));\n        return array;\n    };\nexport function maybeUnsubscribe(entryOrDep) {\n    const { unsubscribe } = entryOrDep;\n    if (typeof unsubscribe === \"function\") {\n        entryOrDep.unsubscribe = void 0;\n        unsubscribe();\n    }\n}\n//# sourceMappingURL=helpers.js.map","import { parentEntrySlot } from \"./context.js\";\nimport { maybeUnsubscribe, arrayFromSet } from \"./helpers.js\";\nconst emptySetPool = [];\nconst POOL_TARGET_SIZE = 100;\n// Since this package might be used browsers, we should avoid using the\n// Node built-in assert module.\nfunction assert(condition, optionalMessage) {\n    if (!condition) {\n        throw new Error(optionalMessage || \"assertion failure\");\n    }\n}\nfunction valueIs(a, b) {\n    const len = a.length;\n    return (\n    // Unknown values are not equal to each other.\n    len > 0 &&\n        // Both values must be ordinary (or both exceptional) to be equal.\n        len === b.length &&\n        // The underlying value or exception must be the same.\n        a[len - 1] === b[len - 1]);\n}\nfunction valueGet(value) {\n    switch (value.length) {\n        case 0: throw new Error(\"unknown value\");\n        case 1: return value[0];\n        case 2: throw value[1];\n    }\n}\nfunction valueCopy(value) {\n    return value.slice(0);\n}\nexport class Entry {\n    constructor(fn) {\n        this.fn = fn;\n        this.parents = new Set();\n        this.childValues = new Map();\n        // When this Entry has children that are dirty, this property becomes\n        // a Set containing other Entry objects, borrowed from emptySetPool.\n        // When the set becomes empty, it gets recycled back to emptySetPool.\n        this.dirtyChildren = null;\n        this.dirty = true;\n        this.recomputing = false;\n        this.value = [];\n        this.deps = null;\n        ++Entry.count;\n    }\n    peek() {\n        if (this.value.length === 1 && !mightBeDirty(this)) {\n            rememberParent(this);\n            return this.value[0];\n        }\n    }\n    // This is the most important method of the Entry API, because it\n    // determines whether the cached this.value can be returned immediately,\n    // or must be recomputed. The overall performance of the caching system\n    // depends on the truth of the following observations: (1) this.dirty is\n    // usually false, (2) this.dirtyChildren is usually null/empty, and thus\n    // (3) valueGet(this.value) is usually returned without recomputation.\n    recompute(args) {\n        assert(!this.recomputing, \"already recomputing\");\n        rememberParent(this);\n        return mightBeDirty(this)\n            ? reallyRecompute(this, args)\n            : valueGet(this.value);\n    }\n    setDirty() {\n        if (this.dirty)\n            return;\n        this.dirty = true;\n        reportDirty(this);\n        // We can go ahead and unsubscribe here, since any further dirty\n        // notifications we receive will be redundant, and unsubscribing may\n        // free up some resources, e.g. file watchers.\n        maybeUnsubscribe(this);\n    }\n    dispose() {\n        this.setDirty();\n        // Sever any dependency relationships with our own children, so those\n        // children don't retain this parent Entry in their child.parents sets,\n        // thereby preventing it from being fully garbage collected.\n        forgetChildren(this);\n        // Because this entry has been kicked out of the cache (in index.js),\n        // we've lost the ability to find out if/when this entry becomes dirty,\n        // whether that happens through a subscription, because of a direct call\n        // to entry.setDirty(), or because one of its children becomes dirty.\n        // Because of this loss of future information, we have to assume the\n        // worst (that this entry might have become dirty very soon), so we must\n        // immediately mark this entry's parents as dirty. Normally we could\n        // just call entry.setDirty() rather than calling parent.setDirty() for\n        // each parent, but that would leave this entry in parent.childValues\n        // and parent.dirtyChildren, which would prevent the child from being\n        // truly forgotten.\n        eachParent(this, (parent, child) => {\n            parent.setDirty();\n            forgetChild(parent, this);\n        });\n    }\n    forget() {\n        // The code that creates Entry objects in index.ts will replace this method\n        // with one that actually removes the Entry from the cache, which will also\n        // trigger the entry.dispose method.\n        this.dispose();\n    }\n    dependOn(dep) {\n        dep.add(this);\n        if (!this.deps) {\n            this.deps = emptySetPool.pop() || new Set();\n        }\n        this.deps.add(dep);\n    }\n    forgetDeps() {\n        if (this.deps) {\n            arrayFromSet(this.deps).forEach(dep => dep.delete(this));\n            this.deps.clear();\n            emptySetPool.push(this.deps);\n            this.deps = null;\n        }\n    }\n}\nEntry.count = 0;\nfunction rememberParent(child) {\n    const parent = parentEntrySlot.getValue();\n    if (parent) {\n        child.parents.add(parent);\n        if (!parent.childValues.has(child)) {\n            parent.childValues.set(child, []);\n        }\n        if (mightBeDirty(child)) {\n            reportDirtyChild(parent, child);\n        }\n        else {\n            reportCleanChild(parent, child);\n        }\n        return parent;\n    }\n}\nfunction reallyRecompute(entry, args) {\n    forgetChildren(entry);\n    // Set entry as the parent entry while calling recomputeNewValue(entry).\n    parentEntrySlot.withValue(entry, recomputeNewValue, [entry, args]);\n    if (maybeSubscribe(entry, args)) {\n        // If we successfully recomputed entry.value and did not fail to\n        // (re)subscribe, then this Entry is no longer explicitly dirty.\n        setClean(entry);\n    }\n    return valueGet(entry.value);\n}\nfunction recomputeNewValue(entry, args) {\n    entry.recomputing = true;\n    const { normalizeResult } = entry;\n    let oldValueCopy;\n    if (normalizeResult && entry.value.length === 1) {\n        oldValueCopy = valueCopy(entry.value);\n    }\n    // Make entry.value an empty array, representing an unknown value.\n    entry.value.length = 0;\n    try {\n        // If entry.fn succeeds, entry.value will become a normal Value.\n        entry.value[0] = entry.fn.apply(null, args);\n        // If we have a viable oldValueCopy to compare with the (successfully\n        // recomputed) new entry.value, and they are not already === identical, give\n        // normalizeResult a chance to pick/choose/reuse parts of oldValueCopy[0]\n        // and/or entry.value[0] to determine the final cached entry.value.\n        if (normalizeResult && oldValueCopy && !valueIs(oldValueCopy, entry.value)) {\n            try {\n                entry.value[0] = normalizeResult(entry.value[0], oldValueCopy[0]);\n            }\n            catch (_a) {\n                // If normalizeResult throws, just use the newer value, rather than\n                // saving the exception as entry.value[1].\n            }\n        }\n    }\n    catch (e) {\n        // If entry.fn throws, entry.value will hold that exception.\n        entry.value[1] = e;\n    }\n    // Either way, this line is always reached.\n    entry.recomputing = false;\n}\nfunction mightBeDirty(entry) {\n    return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);\n}\nfunction setClean(entry) {\n    entry.dirty = false;\n    if (mightBeDirty(entry)) {\n        // This Entry may still have dirty children, in which case we can't\n        // let our parents know we're clean just yet.\n        return;\n    }\n    reportClean(entry);\n}\nfunction reportDirty(child) {\n    eachParent(child, reportDirtyChild);\n}\nfunction reportClean(child) {\n    eachParent(child, reportCleanChild);\n}\nfunction eachParent(child, callback) {\n    const parentCount = child.parents.size;\n    if (parentCount) {\n        const parents = arrayFromSet(child.parents);\n        for (let i = 0; i < parentCount; ++i) {\n            callback(parents[i], child);\n        }\n    }\n}\n// Let a parent Entry know that one of its children may be dirty.\nfunction reportDirtyChild(parent, child) {\n    // Must have called rememberParent(child) before calling\n    // reportDirtyChild(parent, child).\n    assert(parent.childValues.has(child));\n    assert(mightBeDirty(child));\n    const parentWasClean = !mightBeDirty(parent);\n    if (!parent.dirtyChildren) {\n        parent.dirtyChildren = emptySetPool.pop() || new Set;\n    }\n    else if (parent.dirtyChildren.has(child)) {\n        // If we already know this child is dirty, then we must have already\n        // informed our own parents that we are dirty, so we can terminate\n        // the recursion early.\n        return;\n    }\n    parent.dirtyChildren.add(child);\n    // If parent was clean before, it just became (possibly) dirty (according to\n    // mightBeDirty), since we just added child to parent.dirtyChildren.\n    if (parentWasClean) {\n        reportDirty(parent);\n    }\n}\n// Let a parent Entry know that one of its children is no longer dirty.\nfunction reportCleanChild(parent, child) {\n    // Must have called rememberChild(child) before calling\n    // reportCleanChild(parent, child).\n    assert(parent.childValues.has(child));\n    assert(!mightBeDirty(child));\n    const childValue = parent.childValues.get(child);\n    if (childValue.length === 0) {\n        parent.childValues.set(child, valueCopy(child.value));\n    }\n    else if (!valueIs(childValue, child.value)) {\n        parent.setDirty();\n    }\n    removeDirtyChild(parent, child);\n    if (mightBeDirty(parent)) {\n        return;\n    }\n    reportClean(parent);\n}\nfunction removeDirtyChild(parent, child) {\n    const dc = parent.dirtyChildren;\n    if (dc) {\n        dc.delete(child);\n        if (dc.size === 0) {\n            if (emptySetPool.length < POOL_TARGET_SIZE) {\n                emptySetPool.push(dc);\n            }\n            parent.dirtyChildren = null;\n        }\n    }\n}\n// Removes all children from this entry and returns an array of the\n// removed children.\nfunction forgetChildren(parent) {\n    if (parent.childValues.size > 0) {\n        parent.childValues.forEach((_value, child) => {\n            forgetChild(parent, child);\n        });\n    }\n    // Remove this parent Entry from any sets to which it was added by the\n    // addToSet method.\n    parent.forgetDeps();\n    // After we forget all our children, this.dirtyChildren must be empty\n    // and therefore must have been reset to null.\n    assert(parent.dirtyChildren === null);\n}\nfunction forgetChild(parent, child) {\n    child.parents.delete(parent);\n    parent.childValues.delete(child);\n    removeDirtyChild(parent, child);\n}\nfunction maybeSubscribe(entry, args) {\n    if (typeof entry.subscribe === \"function\") {\n        try {\n            maybeUnsubscribe(entry); // Prevent double subscriptions.\n            entry.unsubscribe = entry.subscribe.apply(null, args);\n        }\n        catch (e) {\n            // If this Entry has a subscribe function and it threw an exception\n            // (or an unsubscribe function it previously returned now throws),\n            // return false to indicate that we were not able to subscribe (or\n            // unsubscribe), and this Entry should remain dirty.\n            entry.setDirty();\n            return false;\n        }\n    }\n    // Returning true indicates either that there was no entry.subscribe\n    // function or that it succeeded.\n    return true;\n}\n//# sourceMappingURL=entry.js.map","import { parentEntrySlot } from \"./context.js\";\nimport { hasOwnProperty, maybeUnsubscribe, arrayFromSet, } from \"./helpers.js\";\nconst EntryMethods = {\n    setDirty: true,\n    dispose: true,\n    forget: true, // Fully remove parent Entry from LRU cache and computation graph\n};\nexport function dep(options) {\n    const depsByKey = new Map();\n    const subscribe = options && options.subscribe;\n    function depend(key) {\n        const parent = parentEntrySlot.getValue();\n        if (parent) {\n            let dep = depsByKey.get(key);\n            if (!dep) {\n                depsByKey.set(key, dep = new Set);\n            }\n            parent.dependOn(dep);\n            if (typeof subscribe === \"function\") {\n                maybeUnsubscribe(dep);\n                dep.unsubscribe = subscribe(key);\n            }\n        }\n    }\n    depend.dirty = function dirty(key, entryMethodName) {\n        const dep = depsByKey.get(key);\n        if (dep) {\n            const m = (entryMethodName &&\n                hasOwnProperty.call(EntryMethods, entryMethodName)) ? entryMethodName : \"setDirty\";\n            // We have to use arrayFromSet(dep).forEach instead of dep.forEach,\n            // because modifying a Set while iterating over it can cause elements in\n            // the Set to be removed from the Set before they've been iterated over.\n            arrayFromSet(dep).forEach(entry => entry[m]());\n            depsByKey.delete(key);\n            maybeUnsubscribe(dep);\n        }\n    };\n    return depend;\n}\n//# sourceMappingURL=dep.js.map","import { Trie } from \"@wry/trie\";\nimport { StrongCache } from \"@wry/caches\";\nimport { Entry } from \"./entry.js\";\nimport { parentEntrySlot } from \"./context.js\";\n// These helper functions are important for making optimism work with\n// asynchronous code. In order to register parent-child dependencies,\n// optimism needs to know about any currently active parent computations.\n// In ordinary synchronous code, the parent context is implicit in the\n// execution stack, but asynchronous code requires some extra guidance in\n// order to propagate context from one async task segment to the next.\nexport { bindContext, noContext, nonReactive, setTimeout, asyncFromGen, Slot, } from \"./context.js\";\n// A lighter-weight dependency, similar to OptimisticWrapperFunction, except\n// with only one argument, no makeCacheKey, no wrapped function to recompute,\n// and no result value. Useful for representing dependency leaves in the graph\n// of computation. Subscriptions are supported.\nexport { dep } from \"./dep.js\";\n// The defaultMakeCacheKey function is remarkably powerful, because it gives\n// a unique object for any shallow-identical list of arguments. If you need\n// to implement a custom makeCacheKey function, you may find it helpful to\n// delegate the final work to defaultMakeCacheKey, which is why we export it\n// here. However, you may want to avoid defaultMakeCacheKey if your runtime\n// does not support WeakMap, or you have the ability to return a string key.\n// In those cases, just write your own custom makeCacheKey functions.\nlet defaultKeyTrie;\nexport function defaultMakeCacheKey(...args) {\n    const trie = defaultKeyTrie || (defaultKeyTrie = new Trie(typeof WeakMap === \"function\"));\n    return trie.lookupArray(args);\n}\n// If you're paranoid about memory leaks, or you want to avoid using WeakMap\n// under the hood, but you still need the behavior of defaultMakeCacheKey,\n// import this constructor to create your own tries.\nexport { Trie as KeyTrie };\n;\nconst caches = new Set();\nexport function wrap(originalFunction, { max = Math.pow(2, 16), keyArgs, makeCacheKey = defaultMakeCacheKey, normalizeResult, subscribe, cache: cacheOption = StrongCache, } = Object.create(null)) {\n    const cache = typeof cacheOption === \"function\"\n        ? new cacheOption(max, entry => entry.dispose())\n        : cacheOption;\n    const optimistic = function () {\n        const key = makeCacheKey.apply(null, keyArgs ? keyArgs.apply(null, arguments) : arguments);\n        if (key === void 0) {\n            return originalFunction.apply(null, arguments);\n        }\n        let entry = cache.get(key);\n        if (!entry) {\n            cache.set(key, entry = new Entry(originalFunction));\n            entry.normalizeResult = normalizeResult;\n            entry.subscribe = subscribe;\n            // Give the Entry the ability to trigger cache.delete(key), even though\n            // the Entry itself does not know about key or cache.\n            entry.forget = () => cache.delete(key);\n        }\n        const value = entry.recompute(Array.prototype.slice.call(arguments));\n        // Move this entry to the front of the least-recently used queue,\n        // since we just finished computing its value.\n        cache.set(key, entry);\n        caches.add(cache);\n        // Clean up any excess entries in the cache, but only if there is no\n        // active parent entry, meaning we're not in the middle of a larger\n        // computation that might be flummoxed by the cleaning.\n        if (!parentEntrySlot.hasValue()) {\n            caches.forEach(cache => cache.clean());\n            caches.clear();\n        }\n        return value;\n    };\n    Object.defineProperty(optimistic, \"size\", {\n        get: () => cache.size,\n        configurable: false,\n        enumerable: false,\n    });\n    Object.freeze(optimistic.options = {\n        max,\n        keyArgs,\n        makeCacheKey,\n        normalizeResult,\n        subscribe,\n        cache,\n    });\n    function dirtyKey(key) {\n        const entry = key && cache.get(key);\n        if (entry) {\n            entry.setDirty();\n        }\n    }\n    optimistic.dirtyKey = dirtyKey;\n    optimistic.dirty = function dirty() {\n        dirtyKey(makeCacheKey.apply(null, arguments));\n    };\n    function peekKey(key) {\n        const entry = key && cache.get(key);\n        if (entry) {\n            return entry.peek();\n        }\n    }\n    optimistic.peekKey = peekKey;\n    optimistic.peek = function peek() {\n        return peekKey(makeCacheKey.apply(null, arguments));\n    };\n    function forgetKey(key) {\n        return key ? cache.delete(key) : false;\n    }\n    optimistic.forgetKey = forgetKey;\n    optimistic.forget = function forget() {\n        return forgetKey(makeCacheKey.apply(null, arguments));\n    };\n    optimistic.makeCacheKey = makeCacheKey;\n    optimistic.getKey = keyArgs ? function getKey() {\n        return makeCacheKey.apply(null, keyArgs.apply(null, arguments));\n    } : makeCacheKey;\n    return Object.freeze(optimistic);\n}\n//# sourceMappingURL=index.js.map","function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\n// === Symbol Support ===\nvar hasSymbols = function () {\n  return typeof Symbol === 'function';\n};\n\nvar hasSymbol = function (name) {\n  return hasSymbols() && Boolean(Symbol[name]);\n};\n\nvar getSymbol = function (name) {\n  return hasSymbol(name) ? Symbol[name] : '@@' + name;\n};\n\nif (hasSymbols() && !hasSymbol('observable')) {\n  Symbol.observable = Symbol('observable');\n}\n\nvar SymbolIterator = getSymbol('iterator');\nvar SymbolObservable = getSymbol('observable');\nvar SymbolSpecies = getSymbol('species'); // === Abstract Operations ===\n\nfunction getMethod(obj, key) {\n  var value = obj[key];\n  if (value == null) return undefined;\n  if (typeof value !== 'function') throw new TypeError(value + ' is not a function');\n  return value;\n}\n\nfunction getSpecies(obj) {\n  var ctor = obj.constructor;\n\n  if (ctor !== undefined) {\n    ctor = ctor[SymbolSpecies];\n\n    if (ctor === null) {\n      ctor = undefined;\n    }\n  }\n\n  return ctor !== undefined ? ctor : Observable;\n}\n\nfunction isObservable(x) {\n  return x instanceof Observable; // SPEC: Brand check\n}\n\nfunction hostReportError(e) {\n  if (hostReportError.log) {\n    hostReportError.log(e);\n  } else {\n    setTimeout(function () {\n      throw e;\n    });\n  }\n}\n\nfunction enqueue(fn) {\n  Promise.resolve().then(function () {\n    try {\n      fn();\n    } catch (e) {\n      hostReportError(e);\n    }\n  });\n}\n\nfunction cleanupSubscription(subscription) {\n  var cleanup = subscription._cleanup;\n  if (cleanup === undefined) return;\n  subscription._cleanup = undefined;\n\n  if (!cleanup) {\n    return;\n  }\n\n  try {\n    if (typeof cleanup === 'function') {\n      cleanup();\n    } else {\n      var unsubscribe = getMethod(cleanup, 'unsubscribe');\n\n      if (unsubscribe) {\n        unsubscribe.call(cleanup);\n      }\n    }\n  } catch (e) {\n    hostReportError(e);\n  }\n}\n\nfunction closeSubscription(subscription) {\n  subscription._observer = undefined;\n  subscription._queue = undefined;\n  subscription._state = 'closed';\n}\n\nfunction flushSubscription(subscription) {\n  var queue = subscription._queue;\n\n  if (!queue) {\n    return;\n  }\n\n  subscription._queue = undefined;\n  subscription._state = 'ready';\n\n  for (var i = 0; i < queue.length; ++i) {\n    notifySubscription(subscription, queue[i].type, queue[i].value);\n    if (subscription._state === 'closed') break;\n  }\n}\n\nfunction notifySubscription(subscription, type, value) {\n  subscription._state = 'running';\n  var observer = subscription._observer;\n\n  try {\n    var m = getMethod(observer, type);\n\n    switch (type) {\n      case 'next':\n        if (m) m.call(observer, value);\n        break;\n\n      case 'error':\n        closeSubscription(subscription);\n        if (m) m.call(observer, value);else throw value;\n        break;\n\n      case 'complete':\n        closeSubscription(subscription);\n        if (m) m.call(observer);\n        break;\n    }\n  } catch (e) {\n    hostReportError(e);\n  }\n\n  if (subscription._state === 'closed') cleanupSubscription(subscription);else if (subscription._state === 'running') subscription._state = 'ready';\n}\n\nfunction onNotify(subscription, type, value) {\n  if (subscription._state === 'closed') return;\n\n  if (subscription._state === 'buffering') {\n    subscription._queue.push({\n      type: type,\n      value: value\n    });\n\n    return;\n  }\n\n  if (subscription._state !== 'ready') {\n    subscription._state = 'buffering';\n    subscription._queue = [{\n      type: type,\n      value: value\n    }];\n    enqueue(function () {\n      return flushSubscription(subscription);\n    });\n    return;\n  }\n\n  notifySubscription(subscription, type, value);\n}\n\nvar Subscription = /*#__PURE__*/function () {\n  function Subscription(observer, subscriber) {\n    // ASSERT: observer is an object\n    // ASSERT: subscriber is callable\n    this._cleanup = undefined;\n    this._observer = observer;\n    this._queue = undefined;\n    this._state = 'initializing';\n    var subscriptionObserver = new SubscriptionObserver(this);\n\n    try {\n      this._cleanup = subscriber.call(undefined, subscriptionObserver);\n    } catch (e) {\n      subscriptionObserver.error(e);\n    }\n\n    if (this._state === 'initializing') this._state = 'ready';\n  }\n\n  var _proto = Subscription.prototype;\n\n  _proto.unsubscribe = function unsubscribe() {\n    if (this._state !== 'closed') {\n      closeSubscription(this);\n      cleanupSubscription(this);\n    }\n  };\n\n  _createClass(Subscription, [{\n    key: \"closed\",\n    get: function () {\n      return this._state === 'closed';\n    }\n  }]);\n\n  return Subscription;\n}();\n\nvar SubscriptionObserver = /*#__PURE__*/function () {\n  function SubscriptionObserver(subscription) {\n    this._subscription = subscription;\n  }\n\n  var _proto2 = SubscriptionObserver.prototype;\n\n  _proto2.next = function next(value) {\n    onNotify(this._subscription, 'next', value);\n  };\n\n  _proto2.error = function error(value) {\n    onNotify(this._subscription, 'error', value);\n  };\n\n  _proto2.complete = function complete() {\n    onNotify(this._subscription, 'complete');\n  };\n\n  _createClass(SubscriptionObserver, [{\n    key: \"closed\",\n    get: function () {\n      return this._subscription._state === 'closed';\n    }\n  }]);\n\n  return SubscriptionObserver;\n}();\n\nvar Observable = /*#__PURE__*/function () {\n  function Observable(subscriber) {\n    if (!(this instanceof Observable)) throw new TypeError('Observable cannot be called as a function');\n    if (typeof subscriber !== 'function') throw new TypeError('Observable initializer must be a function');\n    this._subscriber = subscriber;\n  }\n\n  var _proto3 = Observable.prototype;\n\n  _proto3.subscribe = function subscribe(observer) {\n    if (typeof observer !== 'object' || observer === null) {\n      observer = {\n        next: observer,\n        error: arguments[1],\n        complete: arguments[2]\n      };\n    }\n\n    return new Subscription(observer, this._subscriber);\n  };\n\n  _proto3.forEach = function forEach(fn) {\n    var _this = this;\n\n    return new Promise(function (resolve, reject) {\n      if (typeof fn !== 'function') {\n        reject(new TypeError(fn + ' is not a function'));\n        return;\n      }\n\n      function done() {\n        subscription.unsubscribe();\n        resolve();\n      }\n\n      var subscription = _this.subscribe({\n        next: function (value) {\n          try {\n            fn(value, done);\n          } catch (e) {\n            reject(e);\n            subscription.unsubscribe();\n          }\n        },\n        error: reject,\n        complete: resolve\n      });\n    });\n  };\n\n  _proto3.map = function map(fn) {\n    var _this2 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      return _this2.subscribe({\n        next: function (value) {\n          try {\n            value = fn(value);\n          } catch (e) {\n            return observer.error(e);\n          }\n\n          observer.next(value);\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          observer.complete();\n        }\n      });\n    });\n  };\n\n  _proto3.filter = function filter(fn) {\n    var _this3 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      return _this3.subscribe({\n        next: function (value) {\n          try {\n            if (!fn(value)) return;\n          } catch (e) {\n            return observer.error(e);\n          }\n\n          observer.next(value);\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          observer.complete();\n        }\n      });\n    });\n  };\n\n  _proto3.reduce = function reduce(fn) {\n    var _this4 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    var hasSeed = arguments.length > 1;\n    var hasValue = false;\n    var seed = arguments[1];\n    var acc = seed;\n    return new C(function (observer) {\n      return _this4.subscribe({\n        next: function (value) {\n          var first = !hasValue;\n          hasValue = true;\n\n          if (!first || hasSeed) {\n            try {\n              acc = fn(acc, value);\n            } catch (e) {\n              return observer.error(e);\n            }\n          } else {\n            acc = value;\n          }\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          if (!hasValue && !hasSeed) return observer.error(new TypeError('Cannot reduce an empty sequence'));\n          observer.next(acc);\n          observer.complete();\n        }\n      });\n    });\n  };\n\n  _proto3.concat = function concat() {\n    var _this5 = this;\n\n    for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {\n      sources[_key] = arguments[_key];\n    }\n\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      var subscription;\n      var index = 0;\n\n      function startNext(next) {\n        subscription = next.subscribe({\n          next: function (v) {\n            observer.next(v);\n          },\n          error: function (e) {\n            observer.error(e);\n          },\n          complete: function () {\n            if (index === sources.length) {\n              subscription = undefined;\n              observer.complete();\n            } else {\n              startNext(C.from(sources[index++]));\n            }\n          }\n        });\n      }\n\n      startNext(_this5);\n      return function () {\n        if (subscription) {\n          subscription.unsubscribe();\n          subscription = undefined;\n        }\n      };\n    });\n  };\n\n  _proto3.flatMap = function flatMap(fn) {\n    var _this6 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      var subscriptions = [];\n\n      var outer = _this6.subscribe({\n        next: function (value) {\n          if (fn) {\n            try {\n              value = fn(value);\n            } catch (e) {\n              return observer.error(e);\n            }\n          }\n\n          var inner = C.from(value).subscribe({\n            next: function (value) {\n              observer.next(value);\n            },\n            error: function (e) {\n              observer.error(e);\n            },\n            complete: function () {\n              var i = subscriptions.indexOf(inner);\n              if (i >= 0) subscriptions.splice(i, 1);\n              completeIfDone();\n            }\n          });\n          subscriptions.push(inner);\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          completeIfDone();\n        }\n      });\n\n      function completeIfDone() {\n        if (outer.closed && subscriptions.length === 0) observer.complete();\n      }\n\n      return function () {\n        subscriptions.forEach(function (s) {\n          return s.unsubscribe();\n        });\n        outer.unsubscribe();\n      };\n    });\n  };\n\n  _proto3[SymbolObservable] = function () {\n    return this;\n  };\n\n  Observable.from = function from(x) {\n    var C = typeof this === 'function' ? this : Observable;\n    if (x == null) throw new TypeError(x + ' is not an object');\n    var method = getMethod(x, SymbolObservable);\n\n    if (method) {\n      var observable = method.call(x);\n      if (Object(observable) !== observable) throw new TypeError(observable + ' is not an object');\n      if (isObservable(observable) && observable.constructor === C) return observable;\n      return new C(function (observer) {\n        return observable.subscribe(observer);\n      });\n    }\n\n    if (hasSymbol('iterator')) {\n      method = getMethod(x, SymbolIterator);\n\n      if (method) {\n        return new C(function (observer) {\n          enqueue(function () {\n            if (observer.closed) return;\n\n            for (var _iterator = _createForOfIteratorHelperLoose(method.call(x)), _step; !(_step = _iterator()).done;) {\n              var item = _step.value;\n              observer.next(item);\n              if (observer.closed) return;\n            }\n\n            observer.complete();\n          });\n        });\n      }\n    }\n\n    if (Array.isArray(x)) {\n      return new C(function (observer) {\n        enqueue(function () {\n          if (observer.closed) return;\n\n          for (var i = 0; i < x.length; ++i) {\n            observer.next(x[i]);\n            if (observer.closed) return;\n          }\n\n          observer.complete();\n        });\n      });\n    }\n\n    throw new TypeError(x + ' is not observable');\n  };\n\n  Observable.of = function of() {\n    for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      items[_key2] = arguments[_key2];\n    }\n\n    var C = typeof this === 'function' ? this : Observable;\n    return new C(function (observer) {\n      enqueue(function () {\n        if (observer.closed) return;\n\n        for (var i = 0; i < items.length; ++i) {\n          observer.next(items[i]);\n          if (observer.closed) return;\n        }\n\n        observer.complete();\n      });\n    });\n  };\n\n  _createClass(Observable, null, [{\n    key: SymbolSpecies,\n    get: function () {\n      return this;\n    }\n  }]);\n\n  return Observable;\n}();\n\nif (hasSymbols()) {\n  Object.defineProperty(Observable, Symbol('extensions'), {\n    value: {\n      symbol: SymbolObservable,\n      hostReportError: hostReportError\n    },\n    configurable: true\n  });\n}\n\nexport { Observable };\n"],"names":["EntityStore","Root","ApolloCache","assumeImmutableResults","getFragmentDoc","lib","re","graphql_fragments","Yk","max","sizes","Q","cache","weak","k","prototype","batch","options","updateResult","_this","optimisticId","optimistic","performTransaction","update","recordOptimisticTransaction","transaction","transformDocument","document","transformForLink","identify","object","gc","modify","readQuery","read","tslib_es6","pi","rootId","id","readFragment","query","fragment","fragmentName","writeQuery","_a","data","_T","write","Object","assign","dataId","result","writeFragment","updateQuery","value","updateFragment","globalThis","__DEV__","getMemoryInternals","Kb","MissingFieldError","_super","message","path","variables","call","Array","isArray","missing","i","length","__proto__","ZT","Error","hasOwn","hasOwnProperty","isNullish","defaultDataIdFromObject","context","__typename","_id","keyObject","concat","JSON","stringify","defaultConfig","dataIdFromObject","addTypename","resultCaching","canonizeResults","shouldCanonizeResults","config","TypeOrFieldNameRegExp","fieldNameFromStoreName","storeFieldName","match","storeValueIsStoreObject","objects","s","storeUtils","arrays","extractFragmentContext","fragments","fragmentMap","F","getFromAST","kU","lookupFragment","name","def","lookup","DELETE","create","delModifier","INVALIDATE","policies","group","rootIds","refs","getFieldValue","objectOrReference","maybeDeepFreeze","J","get","__ref","canRead","objOrRef","has","toReference","objOrIdOrRef","mergeIntoStore","kQ","ref","merge","toObject","fieldName","depend","storeObject","rootTypenamesById","Layer","parent","dependOnExistence","older","newer","existing","incoming","globals","kG","merged","mergeDeep","w0","storeObjectReconciler","caching","fieldsToDirty_1","__exists","keys","forEach","hasKeyArgs","dirty","fields","changedFields_1","needToMerge_1","allDeleted_1","sharedDetails_1","isReference","readField","fieldNameOrOptions","from","store","fieldValue","newValue","storage","getStorage","checkReference","undefined","warn","seenReference","someNonReference","_i","newValue_1","delete","args","typename","getStoreFieldName","evict","limit","evicted","clear","replace","extract","obj","extraRootIds","getRootIdSet","push","__META","sort","newData","rest_1","retain","release","count","ids","Set","add","snapshot","findChildRefIds","idsToRemove","root_1","found_1","root","workSet_1","key","child","makeCacheKey","keyMaker","lookupArray","arguments","CacheGroup","d","resetCaching","dP","trie_lib","B","canUse","mr","maybeDependOnExistenceOfEntity","entityId","supportsResultCaching","_b","seed","stump","Stump","storageTrie","addLayer","layerId","replay","removeLayer","ownStoreObject","parentStoreObject","equality_lib","D","fromParent","p","apply","existingObject","incomingObject","property","existingValue","incomingValue","ObjectCanon","known","sy","WeakSet","pool","passes","WeakMap","keysByJSON","Map","empty","admit","isKnown","pass","copy","slice","getPrototypeOf","set","original","array","map","node","freeze","proto_1","array_1","sortedKeys","json","firstValueIndex_1","sorted","obj_1","execSelectionSetKeyArgs","selectionSet","StoreReader","knownResults","compact","o","canon","executeSelectionSet","peekArgs","other","peek","enclosingRef","execSelectionSetImpl","resultCacheMaxSize","keyArgs","varString","executeSubSelectedArray","execSubSelectedArrayImpl","field","resetCanon","diffQueryAgainstStore","_c","returnPartialData","_d","O4","iW","rootRef","execResult","p$","canonicalStringify","firstMissing","tree","_","complete","isFresh","latest","objectsToMerge","missingMerger","handleMissing","resultName","rootIdsByTypename","workSet","selections","selection","directives","LZ","My","u2","transform","Gw","added","hi","kind","kinds","h","FRAGMENT_SPREAD","_K","fragmentMatches","finalResult","bw","frozen","childResult","filter","item","assertSelectionSetForIdValue","values","specifierInfoCache","lookupSpecifierInfo","spec","cacheKey","keyFieldsFnFromSpecifier","specifier","info","keyFieldsFn","collectSpecifierPaths","schemaKeyPath","extracted","extractKeyPath","extractKey","join","keyArgsFnFromSpecifier","keyArgsFn","suffix","keyPath","firstKey","firstChar","charAt","O","directiveName_1","find","directiveArgs","NC","variableName","varKeyPath","extractor","merger","getSpecifierPaths","paths","paths_1","currentPath_1","reduce","collected","toMerge","normalize","reducer","argsFromFieldSpecifier","nullKeyFieldsFn","simpleKeyArgsFn","_args","mergeTrueFn","mergeObjects","mergeFalseFn","Policies","typePolicies","toBeAdded","supertypeMap","fuzzySubtypes","usingPossibleTypes","setRootTypename","possibleTypes","addPossibleTypes","addTypePolicies","partialContext","ROOT_QUERY","normalizeReadFieldOptions","policy","getTypePolicy","keyFn","specifierOrId","String","queryType","mutationType","subscriptionType","updateTypePolicy","keyFields","setMerge","getFieldPolicy","which","toUpperCase","old","supertype","getSupertypeSet","subtype","RegExp","policy_1","supertypes_1","size","regExp","fuzzy","test","fuzzySupertypes","inbox","splice","createIfMissing","fieldPolicies","supertypeSet","typeCondition","typenameSupertypeSet","workQueue_1","maybeEnqueue_1","indexOf","needToCheckFuzzySubtypes","checkingFuzzySubtypes","selectionSetMatchesResult","every","fuzzyString","fieldSpec","specifierOrString","vf","PT","readOptions","makeFieldFunctionOptions","reactiveVars","ab","withValue","getReadFunction","getMergeFunction","parentTypename","childTypename","runMergeFunction","makeMergeObjectsFunction","overwrite","readFieldArgs","argc","stringifyForDisplay","v","eType","iType","getContextFlavor","clientOnly","deferred","flavored","flavors","StoreWriter","reader","writeToStore","operationDefinition","$H","written","incomingById","processSelectionSet","mergeTree","fieldNodeSet","entityRef","applied","applyMerges","fieldsWithSelectionSets_1","hasMergeFunction_1","childTree","Boolean","warnAboutDataLoss","existingRef","incomingObj","getChild","parentType","typeDotName","warnings","childTypenames","includes","qw","result_1","flattenFields","getChildMergeTree","processFieldValue","maybeRecycleChildMergeTree","error","e","dataRef","sets","previous_1","mergeMergeTrees","left","right","mergeTreeIsEmpty","needToMergeMaps","remainingRightKeys_1","leftTree","cloneDeep","X","fieldMap","limitingTrie","flatten","inheritedContext","visitedNode","visited","dir","if","getStorageArgs","e_1","i_1","getValue_1","eVal","iVal","aVal","pop","emptyMergeTreePool","InMemoryCache","watches","addTypenameTransform","DocumentTransform","A","makeVar","QS","txCount","init","rootStore","optimisticData","resetResultCache","resetResultIdentities","previousReader","storeReader","storeWriter","maybeBroadcastWatch","c","broadcastWatch","callback","restore","broadcast","broadcastWatches","diff","watch","_v","immediate","li","forget","reset","print","S","resetCache","resetCaches","discardWatches","Promise","resolve","removeOptimistic","idToRemove","newOptimisticData","onWatchUpdated","perform","layer","alreadyDirty","addTypenameToDocument","addFragmentsToDocument","lastDiff","fromOptimisticTransaction","q4","cacheSlot","optimism__WEBPACK_IMPORTED_MODULE_0__","g7","cacheInfoMap","getCacheInfo","vars","dep","forgetCache","rv","recallCache","attachCache","caches","listeners","oldListeners","listener","getValue","attach","onNextChange","execute","ApolloLink","asyncMap","observable","mapFn","catchFn","zen_observable_ts_module","y","observer","promiseQueue","then","makeCallback","examiner","arg","both","closed","next","handler","sub","subscribe","unsubscribe","graphQLResultHasError","errors","getGraphQLErrorsFromResult","graphQLErrors","incrementalResult","GG","incremental","iterateObserversSafely","observers","method","argument","observersWithMethod","obs","fixObservableSubclass","subclass","defineProperty","aS","Symbol","species","isPromiseLike","Concast","sources","addObserver","removeObserver","promise","reject","handlers","notify","setTimeout","shift","nextResultListeners","cancel","reason","catch","iterable","start","deliverLastMessage","nextOrError","beforeNext","called","selectionHasNonreactiveDirective","some","directiveIsNonreactive","ObservableQuery_assign","ObservableQuery_hasOwnProperty","ObservableQuery","queryManager","queryInfo","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","first","last","reobserve","tearDownQuery","subscriptions","waitForOwnResult","skipCacheDataFor","fetchPolicy","isTornDown","defaultOptions","watchQuery","defaultFetchPolicy","_e","_f","initialFetchPolicy","queryId","generateQueryId","opDef","queryName","lastQuery","enumerable","configurable","removeQuery","subscription","resetDiff","getCurrentResult","saveAsLastResult","lastResult","getLastResult","networkStatus","core_networkStatus","Ie","ready","loading","Oj","getDocumentInfo","hasForcedResolvers","getDiff","partial","partialRefetch","logMissingFieldErrors","updateLastResult","isDifferentFromLastResult","newResult","aData","aRest","bData","bRest","hasNonreactiveDirective","Z","equalBySelectionSet","aResult","bResult","seenSelections","resultKey","aResultChild","bResultChild","childSelectionSet","aChildIsArray","bChildIsArray","length_1","getLast","variablesMustMatch","getLastError","resetLastResults","resetQueryStoreErrors","resetErrors","refetch","reobserveOptions","pollInterval","queryDef","variableDefinitions","variable","resetLastWrite","fetchMore","fetchMoreOptions","combinedOptions","qid","originalNetworkStatus","notifyOnNetworkStatusChange","observe","updatedQuerySet","fetchQuery","fetchMoreResult","previous","finally","reobserveCacheFirst","subscribeToMore","startGraphQLSubscription","subscriptionData","err","onError","setOptions","newOptions","silentSetOptions","mergedOptions","setVariables","broadcastQueries","startPolling","updatePolling","stopPolling","applyNextFetchPolicy","nextFetchPolicy","fetch","newNetworkStatus","setObservableQuery","ssrMode","pollingInfo","clearTimeout","timeout","interval","maybeFetch","skipPollAttempt","poll","reobserveAsConcast","useDisposableConcast","oldVariables","oldFetchPolicy","finishWaitingForOwnResult","concast","fromLink","reportResult","reportError","resubscribeAfterError","lastError","isDifferent","errorResult","hasObservers","stopQuery","obsQuery","currentFetchPolicy","stack","debug","isSelectionNode","FIELD","INLINE_FRAGMENT","LocalState","client","resolvers","fragmentMatcher","selectionsToResolveCache","addResolvers","setFragmentMatcher","resolverGroup","Ee","setResolvers","getResolvers","runResolvers","remoteResult","onlyRunForcedResolvers","mG","Jh","resolveDocument","localResult","getFragmentMatcher","clientQuery","FS","serverQuery","ob","prepareContext","getCacheKey","addExportedVariables","buildRootValueFromCache","exportedVariables","shouldForceResolvers","forceResolvers","visitor","Vn","Directive","enter","$_","aL","rootValue","mainDefinition","selectionsToResolve","definitionOperation","defaultOperationType","execContext","collectSelectionsToResolve","operation","resolveSelectionSet","isClientFieldDescendant","resultsToMerge","resolveField","fieldResult","Ao","fragmentResult","all","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","directive","isClientField","resolveSubSelectedArray","isSingleASTNode","collectByDefinition","definitionNode","matches_1","__","___","ancestors","FragmentSpread","spread","fragmentSelections","destructiveMethodCounts","wrapDestructiveCacheMethod","methodName","cancelNotifyTimeout","QueryInfo","lastRequestId","stopped","observableQuery","networkError","getDiffOptions","updateWatch","oq","updateLastDiff","setDiff","oldDiff","notifyTimeout","oqListener","shouldNotify","stop","watchOptions","watcher","lastWatch","lastWrite","shouldWrite","dmCount","markResult","cacheWriteBehavior","mergedData","mT","hasNext","shouldWriteResult","errorPolicy","diffOptions","markReady","markError","ignoreErrors","writeWithErrors","QueryManager_hasOwnProperty","IGNORE","QueryManager","link","documentTransform","queryDeduplication","onBroadcast","clientAwareness","localState","defaultContext","queries","fetchCancelFns","transformCache","queryIdCounter","requestIdCounter","mutationIdCounter","inFlightLinkObservables","defaultDocumentTransform","mutationStore","_info","stopQueryNoBroadcast","cancelPendingFetches","mutate","mutation","optimisticResponse","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","onQueryUpdated","_g","keepRootFields","mutationId","hasClientExports","mutationStoreValue","isOptimistic","self","_h","label","generateMutationId","getVariables","sent","markMutationOptimistic","getObservableFromLink","client_errors","cA","storeResult","markMutationResult","cacheWrites","skipCache","asQuery","updateQueries_1","updater","currentQueryResult","nextQueryResult","mutationResult","rY","queryVariables","results_1","updateCache","isFinalResult","M0","include","fetchConcastWithInfo","getQueryStore","cacheEntry","mj","bi","remove","defaultVars","definitions","generateRequestId","stopQueryInStore","stopQueryInStoreNoBroadcast","clearStore","getObservableQueries","queryNamesAndDocs","legacyQueryOptions","desc","JW","makeUniqueId","getQuery","included","nameOrDoc","reFetchObservableQueries","includeStandby","observableQueryPromises","makeObservable","hasErrors","hasProtocolErrors","ls","protocolErrors","extensions","YG","observablePromise_1","getLocalState","deduplication","inFlightLinkObservables_1","operationName","forceFetch","printedServerQuery_1","varJson_1","entry","of","getResultsFromLink","requestId","linkDocument","aqr","MS","containsDataFromLink","defaults","normalized","fromVariables","sourcesWithInfo","fetchQueryByPolicy","cleanupCancelFn","includedQueriesById","results","refetchWritePolicy","oldNetworkStatus","readCache","resultsFromCache","fromData","resolved","resultsFromLink","newContext","hasSuggestedDevtools","ApolloClient","resetStoreCallbacks","clearStoreCallbacks","uri","credentials","headers","ssrForceFetchDelay","connectToDevTools","window","__APOLLO_CLIENT__","typeDefs","clientAwarenessName","clientAwarenessVersion","version","HttpLink","u","disableNetworkFetches","bind","resetStore","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","windowWithDevTools","devtoolsSymbol","for","top","__APOLLO_DEVTOOLS_GLOBAL_HOOK__","nav","navigator","ua","userAgent","url","log","mergeOptions","__actionHookForDevTools","cb","__requestRaw","payload","fn","onResetStore","onClearStore","serializedState","setLocalStateFragmentMatcher","setLink","newLink","su","passthrough","op","forward","toLink","isTerminating","request","links","x","split","leftLink","rightLink","transformedOperation","starting","validateOperation","OPERATION_FIELDS","second","firstLink","nextLink","setOnError","_ApolloLink_js__WEBPACK_IMPORTED_MODULE_0__","errorHandler","_core_index_js__WEBPACK_IMPORTED_MODULE_0__","_utilities_index_js__WEBPACK_IMPORTED_MODULE_1__","retriedSub","retriedResult","response","ErrorLink","tslib__WEBPACK_IMPORTED_MODULE_2__","serializeFetchParameter","serialized","parseError","readerIterator","iterator","DN","asyncIterator","throwServerError","statusCode","status","parseAndCheckHttpResponse_hasOwnProperty","parseJsonBody","bodyText","getResult","parse","checkFetcher","fetcher","fallbackHttpConfig","http","includeQuery","includeExtensions","preserveHeaderCase","accept","defaultPrinter","ast","printer","fromError","errorValue","backupFetch","wY","createHttpLink","linkOptions","preferredFetch","useGETForQueries","includeUnusedVariables","requestOptions","linkConfig","fetchOptions","fallbackURI","unusedNames","controller","chosenURI","getContext","clientAwarenessHeaders","name_1","contextHeaders","contextConfig","transformedQuery","selectHttpOptionsAndBodyInternal","configs","removeDuplicateHeaders","normalizedHeaders_1","toLowerCase","headerData","originalName","normalizedHeaders","body","Variable","_key","signal","AbortController","isSubscription","hasDefer","acceptHeader","rewriteURIForGET","queryParams","addQueryParam","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","newURI","currentFetch","observerNext","setContext","ctype","readMultipartBody","nextValue","decoder","contentType","delimiter","boundaryVal","boundary","buffer","running","done","chunk","searchFrom","contentType_1","TextDecoder","substring","trim","responseIterator","source","getReader","stream","arrayBuffer","pipe","nodeStreamIterator","cleanup","waiting","onData","shiftedArr","pair","onEnd","removeListener","on","decode","headerText","headersInit","line","yU","parseAndCheckHttpResponse","text","operations","abort","sortingMap","stableObjectReplacer","_utilities_caching_index_js__WEBPACK_IMPORTED_MODULE_0__","L","_utilities_caching_index_js__WEBPACK_IMPORTED_MODULE_1__","proto","everyKeyInOrder","unsortedKey","sortedKey","sortedObject_1","_caching_getMemoryInternals_js__WEBPACK_IMPORTED_MODULE_2__","zP","toString","cloneDeepHelper","val","seen","copy_1","copy_2","isExecutionPatchIncrementalResult","isExecutionPatchResult","isApolloPayloadResult","_objects_js__WEBPACK_IMPORTED_MODULE_0__","mergeIncrementalData","prevResult","_mergeDeep_js__WEBPACK_IMPORTED_MODULE_1__","_arrays_js__WEBPACK_IMPORTED_MODULE_2__","parent_1","isNumericKey","mergeDeepArray","target","DeepMerger","defaultReconciler","reconciler","isObject","pastCopies","sourceKey","targetValue","tslib__WEBPACK_IMPORTED_MODULE_1__","ev","shallowCopyForMerge","identity","resultCache","_common_canUse_js__WEBPACK_IMPORTED_MODULE_3__","cached","predicate","stableCacheKeys_1","_wry_trie__WEBPACK_IMPORTED_MODULE_0__","performWork","optimism__WEBPACK_IMPORTED_MODULE_2__","cacheKeys","_globals_index_js__WEBPACK_IMPORTED_MODULE_1__","_caching_index_js__WEBPACK_IMPORTED_MODULE_4__","_wry_caches__WEBPACK_IMPORTED_MODULE_5__","_getFromAST_js__WEBPACK_IMPORTED_MODULE_6__","A$","transformedDocument","otherTransform","shouldInclude","getInclusionDirectives","directiveArguments","directiveName","_globals_index_js__WEBPACK_IMPORTED_MODULE_0__","ifArgument","ifValue","evaledValue","hasDirectives","names","nameSet","uniqueCount","graphql__WEBPACK_IMPORTED_MODULE_1__","getFragmentQueryDocument","actualFragmentName","definition","createFragmentMap","symTable","getFragmentFromSelection","checkDocument","doc","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","getDefaultValues","defaultValues","defs","defaultValue","_storeUtils_js__WEBPACK_IMPORTED_MODULE_1__","vb","printCache","escapedRegExp","escapedReplacer","str","escapeSequences","charCodeAt","printDocASTReducer","Name","leave","Document","OperationDefinition","varDefs","wrap","prefix","VariableDefinition","type","SelectionSet","block","Field","alias","argsLine","indent","Argument","InlineFragment","FragmentDefinition","IntValue","FloatValue","StringValue","isBlockString","blockString","BooleanValue","NullValue","EnumValue","ListValue","ObjectValue","ObjectField","NamedType","ListType","NonNullType","SchemaDefinition","description","operationTypes","OperationTypeDefinition","ScalarTypeDefinition","ObjectTypeDefinition","interfaces","FieldDefinition","hasMultilineItems","InputValueDefinition","InterfaceTypeDefinition","UnionTypeDefinition","types","EnumTypeDefinition","EnumValueDefinition","InputObjectTypeDefinition","DirectiveDefinition","repeatable","locations","SchemaExtension","ScalarTypeExtension","ObjectTypeExtension","InterfaceTypeExtension","UnionTypeExtension","EnumTypeExtension","InputObjectTypeExtension","maybeArray","separator","_maybeArray$filter$jo","maybeString","end","_maybeArray$some","print_print","getTypenameFromResult","isField","resultKeyNameFromField","fragments_1","_fragments_js__WEBPACK_IMPORTED_MODULE_3__","makeReference","isDocumentNode","_common_objects_js__WEBPACK_IMPORTED_MODULE_1__","valueToObjectRepresentation","argObj","isIntValue","Number","isBooleanValue","nestedArgObj_1","variableValue","listValue","nestedArgArrayObj","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","storeKeyNameStringify","_common_canonicalStringify_js__WEBPACK_IMPORTED_MODULE_2__","filterKeys","filteredArgs_1","completeFieldName","stringifiedArgs","setStringify","argumentsObjectFromField","argObj_1","isInlineFragment","TYPENAME_FIELD","NAME","makeInUseGetterFunction","defaultKey","inUse","fragmentSpreads","removeDirectivesFromDocument","_getFromAST_js__WEBPACK_IMPORTED_MODULE_2__","tests","getInUseByOperationName","getInUseByFragmentName","getInUse","ancestor","_common_arrays_js__WEBPACK_IMPORTED_MODULE_4__","OPERATION_DEFINITION","FRAGMENT_DEFINITION","operationCount","directiveMatcher","testConfig","shouldRemoveField","nodeDirectives","originalFragmentDefsByPath","firstVisitMadeChanges","fieldOrInlineFragmentVisitor","docWithoutDirectiveSubtrees","graphql__WEBPACK_IMPORTED_MODULE_5__","_parent","_path","removed","populateTransitiveVars","transitiveVars","childFragmentName","varName","allFragmentNamesUsed","enterVisitor","usedVariableNames_1","tslib__WEBPACK_IMPORTED_MODULE_6__","varDef","isEmpty","pD","_storeUtils_js__WEBPACK_IMPORTED_MODULE_7__","lastIndexOf","buildQueryFromSelectionSet","removeClientSetsFromDocument","defaultMakeData","Trie","constructor","weakness","makeData","getChildTrie","peekArray","len","mapFor","removeArray","head","strong","isObjRef","BREAK","visit","visitorKeys","_ast_mjs__WEBPACK_IMPORTED_MODULE_0__","h8","enterLeaveMap","_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__","getEnterLeaveForKind","kindVisitor","inArray","index","edits","_enterLeaveMap$get","_enterLeaveMap$get2","_node$kind","isLeaving","isEdited","editOffset","editKey","editValue","arrayKey","defineProperties","getOwnPropertyDescriptors","prev","UG","_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_2__","a","_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_3__","visitFn","defaultKeyTrie","lib_hasOwnProperty","currentContext","MISSING_VALUE","idCounter","maybe","ignored","globalKey","host","global","Slot","globalHost","writable","Date","now","Math","random","hasValue","slots","thisArg","saved","noContext","parentEntrySlot","helpers_hasOwnProperty","arrayFromSet","maybeUnsubscribe","entryOrDep","emptySetPool","assert","condition","optionalMessage","valueIs","b","valueGet","Entry","parents","childValues","dirtyChildren","recomputing","deps","mightBeDirty","rememberParent","recompute","forgetChildren","recomputeNewValue","maybeSubscribe","setDirty","eachParent","reportCleanChild","reportDirtyChild","dispose","forgetChild","dependOn","forgetDeps","oldValueCopy","normalizeResult","parentCount","parentWasClean","childValue","removeDirtyChild","dc","_value","EntryMethods","depsByKey","entryMethodName","m","defaultMakeCacheKey","trie","originalFunction","cacheOption","clean","dirtyKey","peekKey","forgetKey","getKey","_arrayLikeToArray","arr","arr2","_defineProperties","props","descriptor","_createClass","Constructor","protoProps","staticProps","hasSymbols","hasSymbol","getSymbol","SymbolIterator","SymbolObservable","SymbolSpecies","getMethod","getSpecies","ctor","Observable","hostReportError","enqueue","cleanupSubscription","_cleanup","closeSubscription","_queue","_state","notifySubscription","onNotify","flushSubscription","queue","Subscription","subscriber","subscriptionObserver","SubscriptionObserver","_proto","_proto2","_subscriber","_proto3","_this2","_this3","_this4","C","hasSeed","acc","_this5","_len","startNext","flatMap","_this6","outer","inner","completeIfDone","_step","_iterator","_createForOfIteratorHelperLoose","allowArrayLike","it","_unsupportedIterableToArray","minLen","n","_len2","items","_key2","symbol"],"sourceRoot":""}