@apollo/client 3.5.10 → 3.6.4

package/cache/cache.cjs.native.js

@@ -0,0 +1,2289 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var globals = require('../utilities/globals');
+var tslib = require('tslib');
+var optimism = require('optimism');
+var utilities = require('../utilities');
+var equality = require('@wry/equality');
+var trie = require('@wry/trie');
+var context = require('@wry/context');
+
+var ApolloCache = (function () {
+    function ApolloCache() {
+        this.getFragmentDoc = optimism.wrap(utilities.getFragmentQueryDocument);
+    }
+    ApolloCache.prototype.batch = function (options) {
+        var _this = this;
+        var optimisticId = typeof options.optimistic === "string" ? options.optimistic :
+            options.optimistic === false ? null : void 0;
+        var updateResult;
+        this.performTransaction(function () { return updateResult = options.update(_this); }, optimisticId);
+        return updateResult;
+    };
+    ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {
+        this.performTransaction(transaction, optimisticId);
+    };
+    ApolloCache.prototype.transformDocument = function (document) {
+        return document;
+    };
+    ApolloCache.prototype.identify = function (object) {
+        return;
+    };
+    ApolloCache.prototype.gc = function () {
+        return [];
+    };
+    ApolloCache.prototype.modify = function (options) {
+        return false;
+    };
+    ApolloCache.prototype.transformForLink = function (document) {
+        return document;
+    };
+    ApolloCache.prototype.readQuery = function (options, optimistic) {
+        if (optimistic === void 0) { optimistic = !!options.optimistic; }
+        return this.read(tslib.__assign(tslib.__assign({}, options), { rootId: options.id || 'ROOT_QUERY', optimistic: optimistic }));
+    };
+    ApolloCache.prototype.readFragment = function (options, optimistic) {
+        if (optimistic === void 0) { optimistic = !!options.optimistic; }
+        return this.read(tslib.__assign(tslib.__assign({}, options), { query: this.getFragmentDoc(options.fragment, options.fragmentName), rootId: options.id, optimistic: optimistic }));
+    };
+    ApolloCache.prototype.writeQuery = function (_a) {
+        var id = _a.id, data = _a.data, options = tslib.__rest(_a, ["id", "data"]);
+        return this.write(Object.assign(options, {
+            dataId: id || 'ROOT_QUERY',
+            result: data,
+        }));
+    };
+    ApolloCache.prototype.writeFragment = function (_a) {
+        var id = _a.id, data = _a.data, fragment = _a.fragment, fragmentName = _a.fragmentName, options = tslib.__rest(_a, ["id", "data", "fragment", "fragmentName"]);
+        return this.write(Object.assign(options, {
+            query: this.getFragmentDoc(fragment, fragmentName),
+            dataId: id,
+            result: data,
+        }));
+    };
+    ApolloCache.prototype.updateQuery = function (options, update) {
+        return this.batch({
+            update: function (cache) {
+                var value = cache.readQuery(options);
+                var data = update(value);
+                if (data === void 0 || data === null)
+                    return value;
+                cache.writeQuery(tslib.__assign(tslib.__assign({}, options), { data: data }));
+                return data;
+            },
+        });
+    };
+    ApolloCache.prototype.updateFragment = function (options, update) {
+        return this.batch({
+            update: function (cache) {
+                var value = cache.readFragment(options);
+                var data = update(value);
+                if (data === void 0 || data === null)
+                    return value;
+                cache.writeFragment(tslib.__assign(tslib.__assign({}, options), { data: data }));
+                return data;
+            },
+        });
+    };
+    return ApolloCache;
+}());
+
+exports.Cache = void 0;
+(function (Cache) {
+})(exports.Cache || (exports.Cache = {}));
+
+var MissingFieldError = (function () {
+    function MissingFieldError(message, path, query, variables) {
+        this.message = message;
+        this.path = path;
+        this.query = query;
+        this.variables = variables;
+    }
+    return MissingFieldError;
+}());
+
+var hasOwn = Object.prototype.hasOwnProperty;
+function defaultDataIdFromObject(_a, context) {
+    var __typename = _a.__typename, id = _a.id, _id = _a._id;
+    if (typeof __typename === "string") {
+        if (context) {
+            context.keyObject =
+                id !== void 0 ? { id: id } :
+                    _id !== void 0 ? { _id: _id } :
+                        void 0;
+        }
+        if (id === void 0)
+            id = _id;
+        if (id !== void 0) {
+            return "".concat(__typename, ":").concat((typeof id === "number" ||
+                typeof id === "string") ? id : JSON.stringify(id));
+        }
+    }
+}
+var defaultConfig = {
+    dataIdFromObject: defaultDataIdFromObject,
+    addTypename: true,
+    resultCaching: true,
+    canonizeResults: false,
+};
+function normalizeConfig(config) {
+    return utilities.compact(defaultConfig, config);
+}
+function shouldCanonizeResults(config) {
+    var value = config.canonizeResults;
+    return value === void 0 ? defaultConfig.canonizeResults : value;
+}
+function getTypenameFromStoreObject(store, objectOrReference) {
+    return utilities.isReference(objectOrReference)
+        ? store.get(objectOrReference.__ref, "__typename")
+        : objectOrReference && objectOrReference.__typename;
+}
+var TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;
+function fieldNameFromStoreName(storeFieldName) {
+    var match = storeFieldName.match(TypeOrFieldNameRegExp);
+    return match ? match[0] : storeFieldName;
+}
+function selectionSetMatchesResult(selectionSet, result, variables) {
+    if (utilities.isNonNullObject(result)) {
+        return isArray(result)
+            ? result.every(function (item) { return selectionSetMatchesResult(selectionSet, item, variables); })
+            : selectionSet.selections.every(function (field) {
+                if (utilities.isField(field) && utilities.shouldInclude(field, variables)) {
+                    var key = utilities.resultKeyNameFromField(field);
+                    return hasOwn.call(result, key) &&
+                        (!field.selectionSet ||
+                            selectionSetMatchesResult(field.selectionSet, result[key], variables));
+                }
+                return true;
+            });
+    }
+    return false;
+}
+function storeValueIsStoreObject(value) {
+    return utilities.isNonNullObject(value) &&
+        !utilities.isReference(value) &&
+        !isArray(value);
+}
+function makeProcessedFieldsMerger() {
+    return new utilities.DeepMerger;
+}
+var isArray = function (a) { return Array.isArray(a); };
+
+var DELETE = Object.create(null);
+var delModifier = function () { return DELETE; };
+var INVALIDATE = Object.create(null);
+exports.EntityStore = (function () {
+    function EntityStore(policies, group) {
+        var _this = this;
+        this.policies = policies;
+        this.group = group;
+        this.data = Object.create(null);
+        this.rootIds = Object.create(null);
+        this.refs = Object.create(null);
+        this.getFieldValue = function (objectOrReference, storeFieldName) { return utilities.maybeDeepFreeze(utilities.isReference(objectOrReference)
+            ? _this.get(objectOrReference.__ref, storeFieldName)
+            : objectOrReference && objectOrReference[storeFieldName]); };
+        this.canRead = function (objOrRef) {
+            return utilities.isReference(objOrRef)
+                ? _this.has(objOrRef.__ref)
+                : typeof objOrRef === "object";
+        };
+        this.toReference = function (objOrIdOrRef, mergeIntoStore) {
+            if (typeof objOrIdOrRef === "string") {
+                return utilities.makeReference(objOrIdOrRef);
+            }
+            if (utilities.isReference(objOrIdOrRef)) {
+                return objOrIdOrRef;
+            }
+            var id = _this.policies.identify(objOrIdOrRef)[0];
+            if (id) {
+                var ref = utilities.makeReference(id);
+                if (mergeIntoStore) {
+                    _this.merge(id, objOrIdOrRef);
+                }
+                return ref;
+            }
+        };
+    }
+    EntityStore.prototype.toObject = function () {
+        return tslib.__assign({}, this.data);
+    };
+    EntityStore.prototype.has = function (dataId) {
+        return this.lookup(dataId, true) !== void 0;
+    };
+    EntityStore.prototype.get = function (dataId, fieldName) {
+        this.group.depend(dataId, fieldName);
+        if (hasOwn.call(this.data, dataId)) {
+            var storeObject = this.data[dataId];
+            if (storeObject && hasOwn.call(storeObject, fieldName)) {
+                return storeObject[fieldName];
+            }
+        }
+        if (fieldName === "__typename" &&
+            hasOwn.call(this.policies.rootTypenamesById, dataId)) {
+            return this.policies.rootTypenamesById[dataId];
+        }
+        if (this instanceof Layer) {
+            return this.parent.get(dataId, fieldName);
+        }
+    };
+    EntityStore.prototype.lookup = function (dataId, dependOnExistence) {
+        if (dependOnExistence)
+            this.group.depend(dataId, "__exists");
+        if (hasOwn.call(this.data, dataId)) {
+            return this.data[dataId];
+        }
+        if (this instanceof Layer) {
+            return this.parent.lookup(dataId, dependOnExistence);
+        }
+        if (this.policies.rootTypenamesById[dataId]) {
+            return Object.create(null);
+        }
+    };
+    EntityStore.prototype.merge = function (older, newer) {
+        var _this = this;
+        var dataId;
+        if (utilities.isReference(older))
+            older = older.__ref;
+        if (utilities.isReference(newer))
+            newer = newer.__ref;
+        var existing = typeof older === "string"
+            ? this.lookup(dataId = older)
+            : older;
+        var incoming = typeof newer === "string"
+            ? this.lookup(dataId = newer)
+            : newer;
+        if (!incoming)
+            return;
+        __DEV__ ? globals.invariant(typeof dataId === "string", "store.merge expects a string ID") : globals.invariant(typeof dataId === "string", 1);
+        var merged = new utilities.DeepMerger(storeObjectReconciler).merge(existing, incoming);
+        this.data[dataId] = merged;
+        if (merged !== existing) {
+            delete this.refs[dataId];
+            if (this.group.caching) {
+                var fieldsToDirty_1 = Object.create(null);
+                if (!existing)
+                    fieldsToDirty_1.__exists = 1;
+                Object.keys(incoming).forEach(function (storeFieldName) {
+                    if (!existing || existing[storeFieldName] !== merged[storeFieldName]) {
+                        fieldsToDirty_1[storeFieldName] = 1;
+                        var fieldName = fieldNameFromStoreName(storeFieldName);
+                        if (fieldName !== storeFieldName &&
+                            !_this.policies.hasKeyArgs(merged.__typename, fieldName)) {
+                            fieldsToDirty_1[fieldName] = 1;
+                        }
+                        if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {
+                            delete merged[storeFieldName];
+                        }
+                    }
+                });
+                if (fieldsToDirty_1.__typename &&
+                    !(existing && existing.__typename) &&
+                    this.policies.rootTypenamesById[dataId] === merged.__typename) {
+                    delete fieldsToDirty_1.__typename;
+                }
+                Object.keys(fieldsToDirty_1).forEach(function (fieldName) { return _this.group.dirty(dataId, fieldName); });
+            }
+        }
+    };
+    EntityStore.prototype.modify = function (dataId, fields) {
+        var _this = this;
+        var storeObject = this.lookup(dataId);
+        if (storeObject) {
+            var changedFields_1 = Object.create(null);
+            var needToMerge_1 = false;
+            var allDeleted_1 = true;
+            var sharedDetails_1 = {
+                DELETE: DELETE,
+                INVALIDATE: INVALIDATE,
+                isReference: utilities.isReference,
+                toReference: this.toReference,
+                canRead: this.canRead,
+                readField: function (fieldNameOrOptions, from) { return _this.policies.readField(typeof fieldNameOrOptions === "string" ? {
+                    fieldName: fieldNameOrOptions,
+                    from: from || utilities.makeReference(dataId),
+                } : fieldNameOrOptions, { store: _this }); },
+            };
+            Object.keys(storeObject).forEach(function (storeFieldName) {
+                var fieldName = fieldNameFromStoreName(storeFieldName);
+                var fieldValue = storeObject[storeFieldName];
+                if (fieldValue === void 0)
+                    return;
+                var modify = typeof fields === "function"
+                    ? fields
+                    : fields[storeFieldName] || fields[fieldName];
+                if (modify) {
+                    var newValue = modify === delModifier ? DELETE :
+                        modify(utilities.maybeDeepFreeze(fieldValue), tslib.__assign(tslib.__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) }));
+                    if (newValue === INVALIDATE) {
+                        _this.group.dirty(dataId, storeFieldName);
+                    }
+                    else {
+                        if (newValue === DELETE)
+                            newValue = void 0;
+                        if (newValue !== fieldValue) {
+                            changedFields_1[storeFieldName] = newValue;
+                            needToMerge_1 = true;
+                            fieldValue = newValue;
+                        }
+                    }
+                }
+                if (fieldValue !== void 0) {
+                    allDeleted_1 = false;
+                }
+            });
+            if (needToMerge_1) {
+                this.merge(dataId, changedFields_1);
+                if (allDeleted_1) {
+                    if (this instanceof Layer) {
+                        this.data[dataId] = void 0;
+                    }
+                    else {
+                        delete this.data[dataId];
+                    }
+                    this.group.dirty(dataId, "__exists");
+                }
+                return true;
+            }
+        }
+        return false;
+    };
+    EntityStore.prototype.delete = function (dataId, fieldName, args) {
+        var _a;
+        var storeObject = this.lookup(dataId);
+        if (storeObject) {
+            var typename = this.getFieldValue(storeObject, "__typename");
+            var storeFieldName = fieldName && args
+                ? this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })
+                : fieldName;
+            return this.modify(dataId, storeFieldName ? (_a = {},
+                _a[storeFieldName] = delModifier,
+                _a) : delModifier);
+        }
+        return false;
+    };
+    EntityStore.prototype.evict = function (options, limit) {
+        var evicted = false;
+        if (options.id) {
+            if (hasOwn.call(this.data, options.id)) {
+                evicted = this.delete(options.id, options.fieldName, options.args);
+            }
+            if (this instanceof Layer && this !== limit) {
+                evicted = this.parent.evict(options, limit) || evicted;
+            }
+            if (options.fieldName || evicted) {
+                this.group.dirty(options.id, options.fieldName || "__exists");
+            }
+        }
+        return evicted;
+    };
+    EntityStore.prototype.clear = function () {
+        this.replace(null);
+    };
+    EntityStore.prototype.extract = function () {
+        var _this = this;
+        var obj = this.toObject();
+        var extraRootIds = [];
+        this.getRootIdSet().forEach(function (id) {
+            if (!hasOwn.call(_this.policies.rootTypenamesById, id)) {
+                extraRootIds.push(id);
+            }
+        });
+        if (extraRootIds.length) {
+            obj.__META = { extraRootIds: extraRootIds.sort() };
+        }
+        return obj;
+    };
+    EntityStore.prototype.replace = function (newData) {
+        var _this = this;
+        Object.keys(this.data).forEach(function (dataId) {
+            if (!(newData && hasOwn.call(newData, dataId))) {
+                _this.delete(dataId);
+            }
+        });
+        if (newData) {
+            var __META = newData.__META, rest_1 = tslib.__rest(newData, ["__META"]);
+            Object.keys(rest_1).forEach(function (dataId) {
+                _this.merge(dataId, rest_1[dataId]);
+            });
+            if (__META) {
+                __META.extraRootIds.forEach(this.retain, this);
+            }
+        }
+    };
+    EntityStore.prototype.retain = function (rootId) {
+        return this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1;
+    };
+    EntityStore.prototype.release = function (rootId) {
+        if (this.rootIds[rootId] > 0) {
+            var count = --this.rootIds[rootId];
+            if (!count)
+                delete this.rootIds[rootId];
+            return count;
+        }
+        return 0;
+    };
+    EntityStore.prototype.getRootIdSet = function (ids) {
+        if (ids === void 0) { ids = new Set(); }
+        Object.keys(this.rootIds).forEach(ids.add, ids);
+        if (this instanceof Layer) {
+            this.parent.getRootIdSet(ids);
+        }
+        else {
+            Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);
+        }
+        return ids;
+    };
+    EntityStore.prototype.gc = function () {
+        var _this = this;
+        var ids = this.getRootIdSet();
+        var snapshot = this.toObject();
+        ids.forEach(function (id) {
+            if (hasOwn.call(snapshot, id)) {
+                Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);
+                delete snapshot[id];
+            }
+        });
+        var idsToRemove = Object.keys(snapshot);
+        if (idsToRemove.length) {
+            var root_1 = this;
+            while (root_1 instanceof Layer)
+                root_1 = root_1.parent;
+            idsToRemove.forEach(function (id) { return root_1.delete(id); });
+        }
+        return idsToRemove;
+    };
+    EntityStore.prototype.findChildRefIds = function (dataId) {
+        if (!hasOwn.call(this.refs, dataId)) {
+            var found_1 = this.refs[dataId] = Object.create(null);
+            var root = this.data[dataId];
+            if (!root)
+                return found_1;
+            var workSet_1 = new Set([root]);
+            workSet_1.forEach(function (obj) {
+                if (utilities.isReference(obj)) {
+                    found_1[obj.__ref] = true;
+                }
+                if (utilities.isNonNullObject(obj)) {
+                    Object.keys(obj).forEach(function (key) {
+                        var child = obj[key];
+                        if (utilities.isNonNullObject(child)) {
+                            workSet_1.add(child);
+                        }
+                    });
+                }
+            });
+        }
+        return this.refs[dataId];
+    };
+    EntityStore.prototype.makeCacheKey = function () {
+        return this.group.keyMaker.lookupArray(arguments);
+    };
+    return EntityStore;
+}());
+var CacheGroup = (function () {
+    function CacheGroup(caching, parent) {
+        if (parent === void 0) { parent = null; }
+        this.caching = caching;
+        this.parent = parent;
+        this.d = null;
+        this.resetCaching();
+    }
+    CacheGroup.prototype.resetCaching = function () {
+        this.d = this.caching ? optimism.dep() : null;
+        this.keyMaker = new trie.Trie(utilities.canUseWeakMap);
+    };
+    CacheGroup.prototype.depend = function (dataId, storeFieldName) {
+        if (this.d) {
+            this.d(makeDepKey(dataId, storeFieldName));
+            var fieldName = fieldNameFromStoreName(storeFieldName);
+            if (fieldName !== storeFieldName) {
+                this.d(makeDepKey(dataId, fieldName));
+            }
+            if (this.parent) {
+                this.parent.depend(dataId, storeFieldName);
+            }
+        }
+    };
+    CacheGroup.prototype.dirty = function (dataId, storeFieldName) {
+        if (this.d) {
+            this.d.dirty(makeDepKey(dataId, storeFieldName), storeFieldName === "__exists" ? "forget" : "setDirty");
+        }
+    };
+    return CacheGroup;
+}());
+function makeDepKey(dataId, storeFieldName) {
+    return storeFieldName + '#' + dataId;
+}
+function maybeDependOnExistenceOfEntity(store, entityId) {
+    if (supportsResultCaching(store)) {
+        store.group.depend(entityId, "__exists");
+    }
+}
+(function (EntityStore) {
+    var Root = (function (_super) {
+        tslib.__extends(Root, _super);
+        function Root(_a) {
+            var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;
+            var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;
+            _this.stump = new Stump(_this);
+            _this.storageTrie = new trie.Trie(utilities.canUseWeakMap);
+            if (seed)
+                _this.replace(seed);
+            return _this;
+        }
+        Root.prototype.addLayer = function (layerId, replay) {
+            return this.stump.addLayer(layerId, replay);
+        };
+        Root.prototype.removeLayer = function () {
+            return this;
+        };
+        Root.prototype.getStorage = function () {
+            return this.storageTrie.lookupArray(arguments);
+        };
+        return Root;
+    }(EntityStore));
+    EntityStore.Root = Root;
+})(exports.EntityStore || (exports.EntityStore = {}));
+var Layer = (function (_super) {
+    tslib.__extends(Layer, _super);
+    function Layer(id, parent, replay, group) {
+        var _this = _super.call(this, parent.policies, group) || this;
+        _this.id = id;
+        _this.parent = parent;
+        _this.replay = replay;
+        _this.group = group;
+        replay(_this);
+        return _this;
+    }
+    Layer.prototype.addLayer = function (layerId, replay) {
+        return new Layer(layerId, this, replay, this.group);
+    };
+    Layer.prototype.removeLayer = function (layerId) {
+        var _this = this;
+        var parent = this.parent.removeLayer(layerId);
+        if (layerId === this.id) {
+            if (this.group.caching) {
+                Object.keys(this.data).forEach(function (dataId) {
+                    var ownStoreObject = _this.data[dataId];
+                    var parentStoreObject = parent["lookup"](dataId);
+                    if (!parentStoreObject) {
+                        _this.delete(dataId);
+                    }
+                    else if (!ownStoreObject) {
+                        _this.group.dirty(dataId, "__exists");
+                        Object.keys(parentStoreObject).forEach(function (storeFieldName) {
+                            _this.group.dirty(dataId, storeFieldName);
+                        });
+                    }
+                    else if (ownStoreObject !== parentStoreObject) {
+                        Object.keys(ownStoreObject).forEach(function (storeFieldName) {
+                            if (!equality.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
+                                _this.group.dirty(dataId, storeFieldName);
+                            }
+                        });
+                    }
+                });
+            }
+            return parent;
+        }
+        if (parent === this.parent)
+            return this;
+        return parent.addLayer(this.id, this.replay);
+    };
+    Layer.prototype.toObject = function () {
+        return tslib.__assign(tslib.__assign({}, this.parent.toObject()), this.data);
+    };
+    Layer.prototype.findChildRefIds = function (dataId) {
+        var fromParent = this.parent.findChildRefIds(dataId);
+        return hasOwn.call(this.data, dataId) ? tslib.__assign(tslib.__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;
+    };
+    Layer.prototype.getStorage = function () {
+        var p = this.parent;
+        while (p.parent)
+            p = p.parent;
+        return p.getStorage.apply(p, arguments);
+    };
+    return Layer;
+}(exports.EntityStore));
+var Stump = (function (_super) {
+    tslib.__extends(Stump, _super);
+    function Stump(root) {
+        return _super.call(this, "EntityStore.Stump", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;
+    }
+    Stump.prototype.removeLayer = function () {
+        return this;
+    };
+    Stump.prototype.merge = function () {
+        return this.parent.merge.apply(this.parent, arguments);
+    };
+    return Stump;
+}(Layer));
+function storeObjectReconciler(existingObject, incomingObject, property) {
+    var existingValue = existingObject[property];
+    var incomingValue = incomingObject[property];
+    return equality.equal(existingValue, incomingValue) ? existingValue : incomingValue;
+}
+function supportsResultCaching(store) {
+    return !!(store instanceof exports.EntityStore && store.group.caching);
+}
+
+function shallowCopy(value) {
+    if (utilities.isNonNullObject(value)) {
+        return isArray(value)
+            ? value.slice(0)
+            : tslib.__assign({ __proto__: Object.getPrototypeOf(value) }, value);
+    }
+    return value;
+}
+var ObjectCanon = (function () {
+    function ObjectCanon() {
+        this.known = new (utilities.canUseWeakSet ? WeakSet : Set)();
+        this.pool = new trie.Trie(utilities.canUseWeakMap);
+        this.passes = new WeakMap();
+        this.keysByJSON = new Map();
+        this.empty = this.admit({});
+    }
+    ObjectCanon.prototype.isKnown = function (value) {
+        return utilities.isNonNullObject(value) && this.known.has(value);
+    };
+    ObjectCanon.prototype.pass = function (value) {
+        if (utilities.isNonNullObject(value)) {
+            var copy = shallowCopy(value);
+            this.passes.set(copy, value);
+            return copy;
+        }
+        return value;
+    };
+    ObjectCanon.prototype.admit = function (value) {
+        var _this = this;
+        if (utilities.isNonNullObject(value)) {
+            var original = this.passes.get(value);
+            if (original)
+                return original;
+            var proto = Object.getPrototypeOf(value);
+            switch (proto) {
+                case Array.prototype: {
+                    if (this.known.has(value))
+                        return value;
+                    var array = value.map(this.admit, this);
+                    var node = this.pool.lookupArray(array);
+                    if (!node.array) {
+                        this.known.add(node.array = array);
+                        if (__DEV__) {
+                            Object.freeze(array);
+                        }
+                    }
+                    return node.array;
+                }
+                case null:
+                case Object.prototype: {
+                    if (this.known.has(value))
+                        return value;
+                    var proto_1 = Object.getPrototypeOf(value);
+                    var array_1 = [proto_1];
+                    var keys = this.sortedKeys(value);
+                    array_1.push(keys.json);
+                    var firstValueIndex_1 = array_1.length;
+                    keys.sorted.forEach(function (key) {
+                        array_1.push(_this.admit(value[key]));
+                    });
+                    var node = this.pool.lookupArray(array_1);
+                    if (!node.object) {
+                        var obj_1 = node.object = Object.create(proto_1);
+                        this.known.add(obj_1);
+                        keys.sorted.forEach(function (key, i) {
+                            obj_1[key] = array_1[firstValueIndex_1 + i];
+                        });
+                        if (__DEV__) {
+                            Object.freeze(obj_1);
+                        }
+                    }
+                    return node.object;
+                }
+            }
+        }
+        return value;
+    };
+    ObjectCanon.prototype.sortedKeys = function (obj) {
+        var keys = Object.keys(obj);
+        var node = this.pool.lookupArray(keys);
+        if (!node.keys) {
+            keys.sort();
+            var json = JSON.stringify(keys);
+            if (!(node.keys = this.keysByJSON.get(json))) {
+                this.keysByJSON.set(json, node.keys = { sorted: keys, json: json });
+            }
+        }
+        return node.keys;
+    };
+    return ObjectCanon;
+}());
+var canonicalStringify = Object.assign(function (value) {
+    if (utilities.isNonNullObject(value)) {
+        if (stringifyCanon === void 0) {
+            resetCanonicalStringify();
+        }
+        var canonical = stringifyCanon.admit(value);
+        var json = stringifyCache.get(canonical);
+        if (json === void 0) {
+            stringifyCache.set(canonical, json = JSON.stringify(canonical));
+        }
+        return json;
+    }
+    return JSON.stringify(value);
+}, {
+    reset: resetCanonicalStringify,
+});
+var stringifyCanon;
+var stringifyCache;
+function resetCanonicalStringify() {
+    stringifyCanon = new ObjectCanon;
+    stringifyCache = new (utilities.canUseWeakMap ? WeakMap : Map)();
+}
+
+function execSelectionSetKeyArgs(options) {
+    return [
+        options.selectionSet,
+        options.objectOrReference,
+        options.context,
+        options.context.canonizeResults,
+    ];
+}
+var StoreReader = (function () {
+    function StoreReader(config) {
+        var _this = this;
+        this.knownResults = new (utilities.canUseWeakMap ? WeakMap : Map)();
+        this.config = utilities.compact(config, {
+            addTypename: config.addTypename !== false,
+            canonizeResults: shouldCanonizeResults(config),
+        });
+        this.canon = config.canon || new ObjectCanon;
+        this.executeSelectionSet = optimism.wrap(function (options) {
+            var _a;
+            var canonizeResults = options.context.canonizeResults;
+            var peekArgs = execSelectionSetKeyArgs(options);
+            peekArgs[3] = !canonizeResults;
+            var other = (_a = _this.executeSelectionSet).peek.apply(_a, peekArgs);
+            if (other) {
+                if (canonizeResults) {
+                    return tslib.__assign(tslib.__assign({}, other), { result: _this.canon.admit(other.result) });
+                }
+                return other;
+            }
+            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);
+            return _this.execSelectionSetImpl(options);
+        }, {
+            max: this.config.resultCacheMaxSize,
+            keyArgs: execSelectionSetKeyArgs,
+            makeCacheKey: function (selectionSet, parent, context, canonizeResults) {
+                if (supportsResultCaching(context.store)) {
+                    return context.store.makeCacheKey(selectionSet, utilities.isReference(parent) ? parent.__ref : parent, context.varString, canonizeResults);
+                }
+            }
+        });
+        this.executeSubSelectedArray = optimism.wrap(function (options) {
+            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);
+            return _this.execSubSelectedArrayImpl(options);
+        }, {
+            max: this.config.resultCacheMaxSize,
+            makeCacheKey: function (_a) {
+                var field = _a.field, array = _a.array, context = _a.context;
+                if (supportsResultCaching(context.store)) {
+                    return context.store.makeCacheKey(field, array, context.varString);
+                }
+            }
+        });
+    }
+    StoreReader.prototype.resetCanon = function () {
+        this.canon = new ObjectCanon;
+    };
+    StoreReader.prototype.diffQueryAgainstStore = function (_a) {
+        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;
+        var policies = this.config.cache.policies;
+        variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(utilities.getQueryDefinition(query))), variables);
+        var rootRef = utilities.makeReference(rootId);
+        var merger = new utilities.DeepMerger;
+        var execResult = this.executeSelectionSet({
+            selectionSet: utilities.getMainDefinition(query).selectionSet,
+            objectOrReference: rootRef,
+            enclosingRef: rootRef,
+            context: {
+                store: store,
+                query: query,
+                policies: policies,
+                variables: variables,
+                varString: canonicalStringify(variables),
+                canonizeResults: canonizeResults,
+                fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(query)),
+                merge: function (a, b) {
+                    return merger.merge(a, b);
+                },
+            },
+        });
+        var missing;
+        if (execResult.missing) {
+            missing = [new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables)];
+            if (!returnPartialData) {
+                throw missing[0];
+            }
+        }
+        return {
+            result: execResult.result,
+            complete: !missing,
+            missing: missing,
+        };
+    };
+    StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {
+        if (supportsResultCaching(context.store) &&
+            this.knownResults.get(result) === selectionSet) {
+            var latest = this.executeSelectionSet.peek(selectionSet, parent, context, this.canon.isKnown(result));
+            if (latest && result === latest.result) {
+                return true;
+            }
+        }
+        return false;
+    };
+    StoreReader.prototype.execSelectionSetImpl = function (_a) {
+        var _this = this;
+        var selectionSet = _a.selectionSet, objectOrReference = _a.objectOrReference, enclosingRef = _a.enclosingRef, context = _a.context;
+        if (utilities.isReference(objectOrReference) &&
+            !context.policies.rootTypenamesById[objectOrReference.__ref] &&
+            !context.store.has(objectOrReference.__ref)) {
+            return {
+                result: this.canon.empty,
+                missing: "Dangling reference to missing ".concat(objectOrReference.__ref, " object"),
+            };
+        }
+        var variables = context.variables, policies = context.policies, store = context.store;
+        var typename = store.getFieldValue(objectOrReference, "__typename");
+        var result = {};
+        var missing;
+        if (this.config.addTypename &&
+            typeof typename === "string" &&
+            !policies.rootIdsByTypename[typename]) {
+            result = { __typename: typename };
+        }
+        function handleMissing(result, resultName) {
+            var _a;
+            if (result.missing) {
+                missing = context.merge(missing, (_a = {}, _a[resultName] = result.missing, _a));
+            }
+            return result.result;
+        }
+        var workSet = new Set(selectionSet.selections);
+        workSet.forEach(function (selection) {
+            var _a, _b;
+            if (!utilities.shouldInclude(selection, variables))
+                return;
+            if (utilities.isField(selection)) {
+                var fieldValue = policies.readField({
+                    fieldName: selection.name.value,
+                    field: selection,
+                    variables: context.variables,
+                    from: objectOrReference,
+                }, context);
+                var resultName = utilities.resultKeyNameFromField(selection);
+                if (fieldValue === void 0) {
+                    if (!utilities.addTypenameToDocument.added(selection)) {
+                        missing = context.merge(missing, (_a = {},
+                            _a[resultName] = "Can't find field '".concat(selection.name.value, "' on ").concat(utilities.isReference(objectOrReference)
+                                ? objectOrReference.__ref + " object"
+                                : "object " + JSON.stringify(objectOrReference, null, 2)),
+                            _a));
+                    }
+                }
+                else if (isArray(fieldValue)) {
+                    fieldValue = handleMissing(_this.executeSubSelectedArray({
+                        field: selection,
+                        array: fieldValue,
+                        enclosingRef: enclosingRef,
+                        context: context,
+                    }), resultName);
+                }
+                else if (!selection.selectionSet) {
+                    if (context.canonizeResults) {
+                        fieldValue = _this.canon.pass(fieldValue);
+                    }
+                }
+                else if (fieldValue != null) {
+                    fieldValue = handleMissing(_this.executeSelectionSet({
+                        selectionSet: selection.selectionSet,
+                        objectOrReference: fieldValue,
+                        enclosingRef: utilities.isReference(fieldValue) ? fieldValue : enclosingRef,
+                        context: context,
+                    }), resultName);
+                }
+                if (fieldValue !== void 0) {
+                    result = context.merge(result, (_b = {}, _b[resultName] = fieldValue, _b));
+                }
+            }
+            else {
+                var fragment = utilities.getFragmentFromSelection(selection, context.fragmentMap);
+                if (fragment && policies.fragmentMatches(fragment, typename)) {
+                    fragment.selectionSet.selections.forEach(workSet.add, workSet);
+                }
+            }
+        });
+        var finalResult = { result: result, missing: missing };
+        var frozen = context.canonizeResults
+            ? this.canon.admit(finalResult)
+            : utilities.maybeDeepFreeze(finalResult);
+        if (frozen.result) {
+            this.knownResults.set(frozen.result, selectionSet);
+        }
+        return frozen;
+    };
+    StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {
+        var _this = this;
+        var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;
+        var missing;
+        function handleMissing(childResult, i) {
+            var _a;
+            if (childResult.missing) {
+                missing = context.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));
+            }
+            return childResult.result;
+        }
+        if (field.selectionSet) {
+            array = array.filter(context.store.canRead);
+        }
+        array = array.map(function (item, i) {
+            if (item === null) {
+                return null;
+            }
+            if (isArray(item)) {
+                return handleMissing(_this.executeSubSelectedArray({
+                    field: field,
+                    array: item,
+                    enclosingRef: enclosingRef,
+                    context: context,
+                }), i);
+            }
+            if (field.selectionSet) {
+                return handleMissing(_this.executeSelectionSet({
+                    selectionSet: field.selectionSet,
+                    objectOrReference: item,
+                    enclosingRef: utilities.isReference(item) ? item : enclosingRef,
+                    context: context,
+                }), i);
+            }
+            if (__DEV__) {
+                assertSelectionSetForIdValue(context.store, field, item);
+            }
+            return item;
+        });
+        return {
+            result: context.canonizeResults ? this.canon.admit(array) : array,
+            missing: missing,
+        };
+    };
+    return StoreReader;
+}());
+function firstMissing(tree) {
+    try {
+        JSON.stringify(tree, function (_, value) {
+            if (typeof value === "string")
+                throw value;
+            return value;
+        });
+    }
+    catch (result) {
+        return result;
+    }
+}
+function assertSelectionSetForIdValue(store, field, fieldValue) {
+    if (!field.selectionSet) {
+        var workSet_1 = new Set([fieldValue]);
+        workSet_1.forEach(function (value) {
+            if (utilities.isNonNullObject(value)) {
+                __DEV__ ? globals.invariant(!utilities.isReference(value), "Missing selection set for object of type ".concat(getTypenameFromStoreObject(store, value), " returned for query field ").concat(field.name.value)) : globals.invariant(!utilities.isReference(value), 5);
+                Object.values(value).forEach(workSet_1.add, workSet_1);
+            }
+        });
+    }
+}
+
+var cacheSlot = new context.Slot();
+var cacheInfoMap = new WeakMap();
+function getCacheInfo(cache) {
+    var info = cacheInfoMap.get(cache);
+    if (!info) {
+        cacheInfoMap.set(cache, info = {
+            vars: new Set,
+            dep: optimism.dep(),
+        });
+    }
+    return info;
+}
+function forgetCache(cache) {
+    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });
+}
+function recallCache(cache) {
+    getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });
+}
+function makeVar(value) {
+    var caches = new Set();
+    var listeners = new Set();
+    var rv = function (newValue) {
+        if (arguments.length > 0) {
+            if (value !== newValue) {
+                value = newValue;
+                caches.forEach(function (cache) {
+                    getCacheInfo(cache).dep.dirty(rv);
+                    broadcast(cache);
+                });
+                var oldListeners = Array.from(listeners);
+                listeners.clear();
+                oldListeners.forEach(function (listener) { return listener(value); });
+            }
+        }
+        else {
+            var cache = cacheSlot.getValue();
+            if (cache) {
+                attach(cache);
+                getCacheInfo(cache).dep(rv);
+            }
+        }
+        return value;
+    };
+    rv.onNextChange = function (listener) {
+        listeners.add(listener);
+        return function () {
+            listeners.delete(listener);
+        };
+    };
+    var attach = rv.attachCache = function (cache) {
+        caches.add(cache);
+        getCacheInfo(cache).vars.add(rv);
+        return rv;
+    };
+    rv.forgetCache = function (cache) { return caches.delete(cache); };
+    return rv;
+}
+function broadcast(cache) {
+    if (cache.broadcastWatches) {
+        cache.broadcastWatches();
+    }
+}
+
+var specifierInfoCache = Object.create(null);
+function lookupSpecifierInfo(spec) {
+    var cacheKey = JSON.stringify(spec);
+    return specifierInfoCache[cacheKey] ||
+        (specifierInfoCache[cacheKey] = Object.create(null));
+}
+function keyFieldsFnFromSpecifier(specifier) {
+    var info = lookupSpecifierInfo(specifier);
+    return info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {
+        var extract = function (from, key) { return context.readField(key, from); };
+        var keyObject = context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {
+            var extracted = extractKeyPath(context.storeObject, schemaKeyPath, extract);
+            if (extracted === void 0 &&
+                object !== context.storeObject &&
+                hasOwn.call(object, schemaKeyPath[0])) {
+                extracted = extractKeyPath(object, schemaKeyPath, extractKey);
+            }
+            __DEV__ ? globals.invariant(extracted !== void 0, "Missing field '".concat(schemaKeyPath.join('.'), "' while extracting keyFields from ").concat(JSON.stringify(object))) : globals.invariant(extracted !== void 0, 2);
+            return extracted;
+        });
+        return "".concat(context.typename, ":").concat(JSON.stringify(keyObject));
+    });
+}
+function keyArgsFnFromSpecifier(specifier) {
+    var info = lookupSpecifierInfo(specifier);
+    return info.keyArgsFn || (info.keyArgsFn = function (args, _a) {
+        var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;
+        var collected = collectSpecifierPaths(specifier, function (keyPath) {
+            var firstKey = keyPath[0];
+            var firstChar = firstKey.charAt(0);
+            if (firstChar === "@") {
+                if (field && utilities.isNonEmptyArray(field.directives)) {
+                    var directiveName_1 = firstKey.slice(1);
+                    var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });
+                    var directiveArgs = d && utilities.argumentsObjectFromField(d, variables);
+                    return directiveArgs && extractKeyPath(directiveArgs, keyPath.slice(1));
+                }
+                return;
+            }
+            if (firstChar === "$") {
+                var variableName = firstKey.slice(1);
+                if (variables && hasOwn.call(variables, variableName)) {
+                    var varKeyPath = keyPath.slice(0);
+                    varKeyPath[0] = variableName;
+                    return extractKeyPath(variables, varKeyPath);
+                }
+                return;
+            }
+            if (args) {
+                return extractKeyPath(args, keyPath);
+            }
+        });
+        var suffix = JSON.stringify(collected);
+        if (args || suffix !== "{}") {
+            fieldName += ":" + suffix;
+        }
+        return fieldName;
+    });
+}
+function collectSpecifierPaths(specifier, extractor) {
+    var merger = new utilities.DeepMerger;
+    return getSpecifierPaths(specifier).reduce(function (collected, path) {
+        var _a;
+        var toMerge = extractor(path);
+        if (toMerge !== void 0) {
+            for (var i = path.length - 1; i >= 0; --i) {
+                toMerge = (_a = {}, _a[path[i]] = toMerge, _a);
+            }
+            collected = merger.merge(collected, toMerge);
+        }
+        return collected;
+    }, Object.create(null));
+}
+function getSpecifierPaths(spec) {
+    var info = lookupSpecifierInfo(spec);
+    if (!info.paths) {
+        var paths_1 = info.paths = [];
+        var currentPath_1 = [];
+        spec.forEach(function (s, i) {
+            if (isArray(s)) {
+                getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });
+                currentPath_1.length = 0;
+            }
+            else {
+                currentPath_1.push(s);
+                if (!isArray(spec[i + 1])) {
+                    paths_1.push(currentPath_1.slice(0));
+                    currentPath_1.length = 0;
+                }
+            }
+        });
+    }
+    return info.paths;
+}
+function extractKey(object, key) {
+    return object[key];
+}
+function extractKeyPath(object, path, extract) {
+    extract = extract || extractKey;
+    return normalize(path.reduce(function reducer(obj, key) {
+        return isArray(obj)
+            ? obj.map(function (child) { return reducer(child, key); })
+            : obj && extract(obj, key);
+    }, object));
+}
+function normalize(value) {
+    if (utilities.isNonNullObject(value)) {
+        if (isArray(value)) {
+            return value.map(normalize);
+        }
+        return collectSpecifierPaths(Object.keys(value).sort(), function (path) { return extractKeyPath(value, path); });
+    }
+    return value;
+}
+
+utilities.getStoreKeyName.setStringify(canonicalStringify);
+function argsFromFieldSpecifier(spec) {
+    return spec.args !== void 0 ? spec.args :
+        spec.field ? utilities.argumentsObjectFromField(spec.field, spec.variables) : null;
+}
+var nullKeyFieldsFn = function () { return void 0; };
+var simpleKeyArgsFn = function (_args, context) { return context.fieldName; };
+var mergeTrueFn = function (existing, incoming, _a) {
+    var mergeObjects = _a.mergeObjects;
+    return mergeObjects(existing, incoming);
+};
+var mergeFalseFn = function (_, incoming) { return incoming; };
+var Policies = (function () {
+    function Policies(config) {
+        this.config = config;
+        this.typePolicies = Object.create(null);
+        this.toBeAdded = Object.create(null);
+        this.supertypeMap = new Map();
+        this.fuzzySubtypes = new Map();
+        this.rootIdsByTypename = Object.create(null);
+        this.rootTypenamesById = Object.create(null);
+        this.usingPossibleTypes = false;
+        this.config = tslib.__assign({ dataIdFromObject: defaultDataIdFromObject }, config);
+        this.cache = this.config.cache;
+        this.setRootTypename("Query");
+        this.setRootTypename("Mutation");
+        this.setRootTypename("Subscription");
+        if (config.possibleTypes) {
+            this.addPossibleTypes(config.possibleTypes);
+        }
+        if (config.typePolicies) {
+            this.addTypePolicies(config.typePolicies);
+        }
+    }
+    Policies.prototype.identify = function (object, partialContext) {
+        var _a;
+        var policies = this;
+        var typename = partialContext && (partialContext.typename ||
+            ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename)) || object.__typename;
+        if (typename === this.rootTypenamesById.ROOT_QUERY) {
+            return ["ROOT_QUERY"];
+        }
+        var storeObject = partialContext && partialContext.storeObject || object;
+        var context = tslib.__assign(tslib.__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: partialContext && partialContext.readField || function () {
+                var options = normalizeReadFieldOptions(arguments, storeObject);
+                return policies.readField(options, {
+                    store: policies.cache["data"],
+                    variables: options.variables,
+                });
+            } });
+        var id;
+        var policy = typename && this.getTypePolicy(typename);
+        var keyFn = policy && policy.keyFn || this.config.dataIdFromObject;
+        while (keyFn) {
+            var specifierOrId = keyFn(object, context);
+            if (isArray(specifierOrId)) {
+                keyFn = keyFieldsFnFromSpecifier(specifierOrId);
+            }
+            else {
+                id = specifierOrId;
+                break;
+            }
+        }
+        id = id ? String(id) : void 0;
+        return context.keyObject ? [id, context.keyObject] : [id];
+    };
+    Policies.prototype.addTypePolicies = function (typePolicies) {
+        var _this = this;
+        Object.keys(typePolicies).forEach(function (typename) {
+            var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = tslib.__rest(_a, ["queryType", "mutationType", "subscriptionType"]);
+            if (queryType)
+                _this.setRootTypename("Query", typename);
+            if (mutationType)
+                _this.setRootTypename("Mutation", typename);
+            if (subscriptionType)
+                _this.setRootTypename("Subscription", typename);
+            if (hasOwn.call(_this.toBeAdded, typename)) {
+                _this.toBeAdded[typename].push(incoming);
+            }
+            else {
+                _this.toBeAdded[typename] = [incoming];
+            }
+        });
+    };
+    Policies.prototype.updateTypePolicy = function (typename, incoming) {
+        var _this = this;
+        var existing = this.getTypePolicy(typename);
+        var keyFields = incoming.keyFields, fields = incoming.fields;
+        function setMerge(existing, merge) {
+            existing.merge =
+                typeof merge === "function" ? merge :
+                    merge === true ? mergeTrueFn :
+                        merge === false ? mergeFalseFn :
+                            existing.merge;
+        }
+        setMerge(existing, incoming.merge);
+        existing.keyFn =
+            keyFields === false ? nullKeyFieldsFn :
+                isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields) :
+                    typeof keyFields === "function" ? keyFields :
+                        existing.keyFn;
+        if (fields) {
+            Object.keys(fields).forEach(function (fieldName) {
+                var existing = _this.getFieldPolicy(typename, fieldName, true);
+                var incoming = fields[fieldName];
+                if (typeof incoming === "function") {
+                    existing.read = incoming;
+                }
+                else {
+                    var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;
+                    existing.keyFn =
+                        keyArgs === false ? simpleKeyArgsFn :
+                            isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs) :
+                                typeof keyArgs === "function" ? keyArgs :
+                                    existing.keyFn;
+                    if (typeof read === "function") {
+                        existing.read = read;
+                    }
+                    setMerge(existing, merge);
+                }
+                if (existing.read && existing.merge) {
+                    existing.keyFn = existing.keyFn || simpleKeyArgsFn;
+                }
+            });
+        }
+    };
+    Policies.prototype.setRootTypename = function (which, typename) {
+        if (typename === void 0) { typename = which; }
+        var rootId = "ROOT_" + which.toUpperCase();
+        var old = this.rootTypenamesById[rootId];
+        if (typename !== old) {
+            __DEV__ ? globals.invariant(!old || old === which, "Cannot change root ".concat(which, " __typename more than once")) : globals.invariant(!old || old === which, 3);
+            if (old)
+                delete this.rootIdsByTypename[old];
+            this.rootIdsByTypename[typename] = rootId;
+            this.rootTypenamesById[rootId] = typename;
+        }
+    };
+    Policies.prototype.addPossibleTypes = function (possibleTypes) {
+        var _this = this;
+        this.usingPossibleTypes = true;
+        Object.keys(possibleTypes).forEach(function (supertype) {
+            _this.getSupertypeSet(supertype, true);
+            possibleTypes[supertype].forEach(function (subtype) {
+                _this.getSupertypeSet(subtype, true).add(supertype);
+                var match = subtype.match(TypeOrFieldNameRegExp);
+                if (!match || match[0] !== subtype) {
+                    _this.fuzzySubtypes.set(subtype, new RegExp(subtype));
+                }
+            });
+        });
+    };
+    Policies.prototype.getTypePolicy = function (typename) {
+        var _this = this;
+        if (!hasOwn.call(this.typePolicies, typename)) {
+            var policy_1 = this.typePolicies[typename] = Object.create(null);
+            policy_1.fields = Object.create(null);
+            var supertypes = this.supertypeMap.get(typename);
+            if (supertypes && supertypes.size) {
+                supertypes.forEach(function (supertype) {
+                    var _a = _this.getTypePolicy(supertype), fields = _a.fields, rest = tslib.__rest(_a, ["fields"]);
+                    Object.assign(policy_1, rest);
+                    Object.assign(policy_1.fields, fields);
+                });
+            }
+        }
+        var inbox = this.toBeAdded[typename];
+        if (inbox && inbox.length) {
+            inbox.splice(0).forEach(function (policy) {
+                _this.updateTypePolicy(typename, policy);
+            });
+        }
+        return this.typePolicies[typename];
+    };
+    Policies.prototype.getFieldPolicy = function (typename, fieldName, createIfMissing) {
+        if (typename) {
+            var fieldPolicies = this.getTypePolicy(typename).fields;
+            return fieldPolicies[fieldName] || (createIfMissing && (fieldPolicies[fieldName] = Object.create(null)));
+        }
+    };
+    Policies.prototype.getSupertypeSet = function (subtype, createIfMissing) {
+        var supertypeSet = this.supertypeMap.get(subtype);
+        if (!supertypeSet && createIfMissing) {
+            this.supertypeMap.set(subtype, supertypeSet = new Set());
+        }
+        return supertypeSet;
+    };
+    Policies.prototype.fragmentMatches = function (fragment, typename, result, variables) {
+        var _this = this;
+        if (!fragment.typeCondition)
+            return true;
+        if (!typename)
+            return false;
+        var supertype = fragment.typeCondition.name.value;
+        if (typename === supertype)
+            return true;
+        if (this.usingPossibleTypes &&
+            this.supertypeMap.has(supertype)) {
+            var typenameSupertypeSet = this.getSupertypeSet(typename, true);
+            var workQueue_1 = [typenameSupertypeSet];
+            var maybeEnqueue_1 = function (subtype) {
+                var supertypeSet = _this.getSupertypeSet(subtype, false);
+                if (supertypeSet &&
+                    supertypeSet.size &&
+                    workQueue_1.indexOf(supertypeSet) < 0) {
+                    workQueue_1.push(supertypeSet);
+                }
+            };
+            var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);
+            var checkingFuzzySubtypes = false;
+            for (var i = 0; i < workQueue_1.length; ++i) {
+                var supertypeSet = workQueue_1[i];
+                if (supertypeSet.has(supertype)) {
+                    if (!typenameSupertypeSet.has(supertype)) {
+                        if (checkingFuzzySubtypes) {
+                            __DEV__ && globals.invariant.warn("Inferring subtype ".concat(typename, " of supertype ").concat(supertype));
+                        }
+                        typenameSupertypeSet.add(supertype);
+                    }
+                    return true;
+                }
+                supertypeSet.forEach(maybeEnqueue_1);
+                if (needToCheckFuzzySubtypes &&
+                    i === workQueue_1.length - 1 &&
+                    selectionSetMatchesResult(fragment.selectionSet, result, variables)) {
+                    needToCheckFuzzySubtypes = false;
+                    checkingFuzzySubtypes = true;
+                    this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {
+                        var match = typename.match(regExp);
+                        if (match && match[0] === typename) {
+                            maybeEnqueue_1(fuzzyString);
+                        }
+                    });
+                }
+            }
+        }
+        return false;
+    };
+    Policies.prototype.hasKeyArgs = function (typename, fieldName) {
+        var policy = this.getFieldPolicy(typename, fieldName, false);
+        return !!(policy && policy.keyFn);
+    };
+    Policies.prototype.getStoreFieldName = function (fieldSpec) {
+        var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;
+        var policy = this.getFieldPolicy(typename, fieldName, false);
+        var storeFieldName;
+        var keyFn = policy && policy.keyFn;
+        if (keyFn && typename) {
+            var context = {
+                typename: typename,
+                fieldName: fieldName,
+                field: fieldSpec.field || null,
+                variables: fieldSpec.variables,
+            };
+            var args = argsFromFieldSpecifier(fieldSpec);
+            while (keyFn) {
+                var specifierOrString = keyFn(args, context);
+                if (isArray(specifierOrString)) {
+                    keyFn = keyArgsFnFromSpecifier(specifierOrString);
+                }
+                else {
+                    storeFieldName = specifierOrString || fieldName;
+                    break;
+                }
+            }
+        }
+        if (storeFieldName === void 0) {
+            storeFieldName = fieldSpec.field
+                ? utilities.storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)
+                : utilities.getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));
+        }
+        if (storeFieldName === false) {
+            return fieldName;
+        }
+        return fieldName === fieldNameFromStoreName(storeFieldName)
+            ? storeFieldName
+            : fieldName + ":" + storeFieldName;
+    };
+    Policies.prototype.readField = function (options, context) {
+        var objectOrReference = options.from;
+        if (!objectOrReference)
+            return;
+        var nameOrField = options.field || options.fieldName;
+        if (!nameOrField)
+            return;
+        if (options.typename === void 0) {
+            var typename = context.store.getFieldValue(objectOrReference, "__typename");
+            if (typename)
+                options.typename = typename;
+        }
+        var storeFieldName = this.getStoreFieldName(options);
+        var fieldName = fieldNameFromStoreName(storeFieldName);
+        var existing = context.store.getFieldValue(objectOrReference, storeFieldName);
+        var policy = this.getFieldPolicy(options.typename, fieldName, false);
+        var read = policy && policy.read;
+        if (read) {
+            var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(utilities.isReference(objectOrReference)
+                ? objectOrReference.__ref
+                : objectOrReference, storeFieldName));
+            return cacheSlot.withValue(this.cache, read, [existing, readOptions]);
+        }
+        return existing;
+    };
+    Policies.prototype.getReadFunction = function (typename, fieldName) {
+        var policy = this.getFieldPolicy(typename, fieldName, false);
+        return policy && policy.read;
+    };
+    Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {
+        var policy = this.getFieldPolicy(parentTypename, fieldName, false);
+        var merge = policy && policy.merge;
+        if (!merge && childTypename) {
+            policy = this.getTypePolicy(childTypename);
+            merge = policy && policy.merge;
+        }
+        return merge;
+    };
+    Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {
+        var field = _a.field, typename = _a.typename, merge = _a.merge;
+        if (merge === mergeTrueFn) {
+            return makeMergeObjectsFunction(context.store)(existing, incoming);
+        }
+        if (merge === mergeFalseFn) {
+            return incoming;
+        }
+        if (context.overwrite) {
+            existing = void 0;
+        }
+        return merge(existing, incoming, makeFieldFunctionOptions(this, void 0, { typename: typename, fieldName: field.name.value, field: field, variables: context.variables }, context, storage || Object.create(null)));
+    };
+    return Policies;
+}());
+function makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {
+    var storeFieldName = policies.getStoreFieldName(fieldSpec);
+    var fieldName = fieldNameFromStoreName(storeFieldName);
+    var variables = fieldSpec.variables || context.variables;
+    var _a = context.store, toReference = _a.toReference, canRead = _a.canRead;
+    return {
+        args: argsFromFieldSpecifier(fieldSpec),
+        field: fieldSpec.field || null,
+        fieldName: fieldName,
+        storeFieldName: storeFieldName,
+        variables: variables,
+        isReference: utilities.isReference,
+        toReference: toReference,
+        storage: storage,
+        cache: policies.cache,
+        canRead: canRead,
+        readField: function () {
+            return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, context), context);
+        },
+        mergeObjects: makeMergeObjectsFunction(context.store),
+    };
+}
+function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {
+    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;
+    var options;
+    if (typeof fieldNameOrOptions === "string") {
+        options = {
+            fieldName: fieldNameOrOptions,
+            from: argc > 1 ? from : objectOrReference,
+        };
+    }
+    else {
+        options = tslib.__assign({}, fieldNameOrOptions);
+        if (!hasOwn.call(options, "from")) {
+            options.from = objectOrReference;
+        }
+    }
+    if (__DEV__ && options.from === void 0) {
+        __DEV__ && globals.invariant.warn("Undefined 'from' passed to readField with arguments ".concat(utilities.stringifyForDisplay(Array.from(readFieldArgs))));
+    }
+    if (void 0 === options.variables) {
+        options.variables = variables;
+    }
+    return options;
+}
+function makeMergeObjectsFunction(store) {
+    return function mergeObjects(existing, incoming) {
+        if (isArray(existing) || isArray(incoming)) {
+            throw __DEV__ ? new globals.InvariantError("Cannot automatically merge arrays") : new globals.InvariantError(4);
+        }
+        if (utilities.isNonNullObject(existing) &&
+            utilities.isNonNullObject(incoming)) {
+            var eType = store.getFieldValue(existing, "__typename");
+            var iType = store.getFieldValue(incoming, "__typename");
+            var typesDiffer = eType && iType && eType !== iType;
+            if (typesDiffer) {
+                return incoming;
+            }
+            if (utilities.isReference(existing) &&
+                storeValueIsStoreObject(incoming)) {
+                store.merge(existing.__ref, incoming);
+                return existing;
+            }
+            if (storeValueIsStoreObject(existing) &&
+                utilities.isReference(incoming)) {
+                store.merge(existing, incoming.__ref);
+                return incoming;
+            }
+            if (storeValueIsStoreObject(existing) &&
+                storeValueIsStoreObject(incoming)) {
+                return tslib.__assign(tslib.__assign({}, existing), incoming);
+            }
+        }
+        return incoming;
+    };
+}
+
+function getContextFlavor(context, clientOnly, deferred) {
+    var key = "".concat(clientOnly).concat(deferred);
+    var flavored = context.flavors.get(key);
+    if (!flavored) {
+        context.flavors.set(key, flavored = (context.clientOnly === clientOnly &&
+            context.deferred === deferred) ? context : tslib.__assign(tslib.__assign({}, context), { clientOnly: clientOnly, deferred: deferred }));
+    }
+    return flavored;
+}
+var StoreWriter = (function () {
+    function StoreWriter(cache, reader) {
+        this.cache = cache;
+        this.reader = reader;
+    }
+    StoreWriter.prototype.writeToStore = function (store, _a) {
+        var _this = this;
+        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;
+        var operationDefinition = utilities.getOperationDefinition(query);
+        var merger = makeProcessedFieldsMerger();
+        variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(operationDefinition)), variables);
+        var context = {
+            store: store,
+            written: Object.create(null),
+            merge: function (existing, incoming) {
+                return merger.merge(existing, incoming);
+            },
+            variables: variables,
+            varString: canonicalStringify(variables),
+            fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(query)),
+            overwrite: !!overwrite,
+            incomingById: new Map,
+            clientOnly: false,
+            deferred: false,
+            flavors: new Map,
+        };
+        var ref = this.processSelectionSet({
+            result: result || Object.create(null),
+            dataId: dataId,
+            selectionSet: operationDefinition.selectionSet,
+            mergeTree: { map: new Map },
+            context: context,
+        });
+        if (!utilities.isReference(ref)) {
+            throw __DEV__ ? new globals.InvariantError("Could not identify object ".concat(JSON.stringify(result))) : new globals.InvariantError(6);
+        }
+        context.incomingById.forEach(function (_a, dataId) {
+            var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;
+            var entityRef = utilities.makeReference(dataId);
+            if (mergeTree && mergeTree.map.size) {
+                var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);
+                if (utilities.isReference(applied)) {
+                    return;
+                }
+                storeObject = applied;
+            }
+            if (__DEV__ && !context.overwrite) {
+                var fieldsWithSelectionSets_1 = Object.create(null);
+                fieldNodeSet.forEach(function (field) {
+                    if (field.selectionSet) {
+                        fieldsWithSelectionSets_1[field.name.value] = true;
+                    }
+                });
+                var hasSelectionSet_1 = function (storeFieldName) {
+                    return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] === true;
+                };
+                var hasMergeFunction_1 = function (storeFieldName) {
+                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);
+                    return Boolean(childTree && childTree.info && childTree.info.merge);
+                };
+                Object.keys(storeObject).forEach(function (storeFieldName) {
+                    if (hasSelectionSet_1(storeFieldName) &&
+                        !hasMergeFunction_1(storeFieldName)) {
+                        warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);
+                    }
+                });
+            }
+            store.merge(dataId, storeObject);
+        });
+        store.retain(ref.__ref);
+        return ref;
+    };
+    StoreWriter.prototype.processSelectionSet = function (_a) {
+        var _this = this;
+        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, mergeTree = _a.mergeTree;
+        var policies = this.cache.policies;
+        var incoming = Object.create(null);
+        var typename = (dataId && policies.rootTypenamesById[dataId]) ||
+            utilities.getTypenameFromResult(result, selectionSet, context.fragmentMap) ||
+            (dataId && context.store.get(dataId, "__typename"));
+        if ("string" === typeof typename) {
+            incoming.__typename = typename;
+        }
+        var readField = function () {
+            var options = normalizeReadFieldOptions(arguments, incoming, context.variables);
+            if (utilities.isReference(options.from)) {
+                var info = context.incomingById.get(options.from.__ref);
+                if (info) {
+                    var result_1 = policies.readField(tslib.__assign(tslib.__assign({}, options), { from: info.storeObject }), context);
+                    if (result_1 !== void 0) {
+                        return result_1;
+                    }
+                }
+            }
+            return policies.readField(options, context);
+        };
+        var fieldNodeSet = new Set();
+        this.flattenFields(selectionSet, result, context, typename).forEach(function (context, field) {
+            var _a;
+            var resultFieldKey = utilities.resultKeyNameFromField(field);
+            var value = result[resultFieldKey];
+            fieldNodeSet.add(field);
+            if (value !== void 0) {
+                var storeFieldName = policies.getStoreFieldName({
+                    typename: typename,
+                    fieldName: field.name.value,
+                    field: field,
+                    variables: context.variables,
+                });
+                var childTree = getChildMergeTree(mergeTree, storeFieldName);
+                var incomingValue = _this.processFieldValue(value, field, field.selectionSet
+                    ? getContextFlavor(context, false, false)
+                    : context, childTree);
+                var childTypename = void 0;
+                if (field.selectionSet &&
+                    (utilities.isReference(incomingValue) ||
+                        storeValueIsStoreObject(incomingValue))) {
+                    childTypename = readField("__typename", incomingValue);
+                }
+                var merge = policies.getMergeFunction(typename, field.name.value, childTypename);
+                if (merge) {
+                    childTree.info = {
+                        field: field,
+                        typename: typename,
+                        merge: merge,
+                    };
+                }
+                else {
+                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);
+                }
+                incoming = context.merge(incoming, (_a = {},
+                    _a[storeFieldName] = incomingValue,
+                    _a));
+            }
+            else if (__DEV__ &&
+                !context.clientOnly &&
+                !context.deferred &&
+                !utilities.addTypenameToDocument.added(field) &&
+                !policies.getReadFunction(typename, field.name.value)) {
+                __DEV__ && globals.invariant.error("Missing field '".concat(utilities.resultKeyNameFromField(field), "' while writing result ").concat(JSON.stringify(result, null, 2)).substring(0, 1000));
+            }
+        });
+        try {
+            var _b = policies.identify(result, {
+                typename: typename,
+                selectionSet: selectionSet,
+                fragmentMap: context.fragmentMap,
+                storeObject: incoming,
+                readField: readField,
+            }), id = _b[0], keyObject = _b[1];
+            dataId = dataId || id;
+            if (keyObject) {
+                incoming = context.merge(incoming, keyObject);
+            }
+        }
+        catch (e) {
+            if (!dataId)
+                throw e;
+        }
+        if ("string" === typeof dataId) {
+            var dataRef = utilities.makeReference(dataId);
+            var sets = context.written[dataId] || (context.written[dataId] = []);
+            if (sets.indexOf(selectionSet) >= 0)
+                return dataRef;
+            sets.push(selectionSet);
+            if (this.reader && this.reader.isFresh(result, dataRef, selectionSet, context)) {
+                return dataRef;
+            }
+            var previous_1 = context.incomingById.get(dataId);
+            if (previous_1) {
+                previous_1.storeObject = context.merge(previous_1.storeObject, incoming);
+                previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);
+                fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });
+            }
+            else {
+                context.incomingById.set(dataId, {
+                    storeObject: incoming,
+                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,
+                    fieldNodeSet: fieldNodeSet,
+                });
+            }
+            return dataRef;
+        }
+        return incoming;
+    };
+    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {
+        var _this = this;
+        if (!field.selectionSet || value === null) {
+            return __DEV__ ? utilities.cloneDeep(value) : value;
+        }
+        if (isArray(value)) {
+            return value.map(function (item, i) {
+                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));
+                maybeRecycleChildMergeTree(mergeTree, i);
+                return value;
+            });
+        }
+        return this.processSelectionSet({
+            result: value,
+            selectionSet: field.selectionSet,
+            context: context,
+            mergeTree: mergeTree,
+        });
+    };
+    StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {
+        if (typename === void 0) { typename = utilities.getTypenameFromResult(result, selectionSet, context.fragmentMap); }
+        var fieldMap = new Map();
+        var policies = this.cache.policies;
+        var limitingTrie = new trie.Trie(false);
+        (function flatten(selectionSet, inheritedContext) {
+            var visitedNode = limitingTrie.lookup(selectionSet, inheritedContext.clientOnly, inheritedContext.deferred);
+            if (visitedNode.visited)
+                return;
+            visitedNode.visited = true;
+            selectionSet.selections.forEach(function (selection) {
+                if (!utilities.shouldInclude(selection, context.variables))
+                    return;
+                var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;
+                if (!(clientOnly && deferred) &&
+                    utilities.isNonEmptyArray(selection.directives)) {
+                    selection.directives.forEach(function (dir) {
+                        var name = dir.name.value;
+                        if (name === "client")
+                            clientOnly = true;
+                        if (name === "defer") {
+                            var args = utilities.argumentsObjectFromField(dir, context.variables);
+                            if (!args || args.if !== false) {
+                                deferred = true;
+                            }
+                        }
+                    });
+                }
+                if (utilities.isField(selection)) {
+                    var existing = fieldMap.get(selection);
+                    if (existing) {
+                        clientOnly = clientOnly && existing.clientOnly;
+                        deferred = deferred && existing.deferred;
+                    }
+                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));
+                }
+                else {
+                    var fragment = utilities.getFragmentFromSelection(selection, context.fragmentMap);
+                    if (fragment &&
+                        policies.fragmentMatches(fragment, typename, result, context.variables)) {
+                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));
+                    }
+                }
+            });
+        })(selectionSet, context);
+        return fieldMap;
+    };
+    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {
+        var _a;
+        var _this = this;
+        if (mergeTree.map.size && !utilities.isReference(incoming)) {
+            var e_1 = (!isArray(incoming) &&
+                (utilities.isReference(existing) || storeValueIsStoreObject(existing))) ? existing : void 0;
+            var i_1 = incoming;
+            if (e_1 && !getStorageArgs) {
+                getStorageArgs = [utilities.isReference(e_1) ? e_1.__ref : e_1];
+            }
+            var changedFields_1;
+            var getValue_1 = function (from, name) {
+                return isArray(from)
+                    ? (typeof name === "number" ? from[name] : void 0)
+                    : context.store.getFieldValue(from, String(name));
+            };
+            mergeTree.map.forEach(function (childTree, storeFieldName) {
+                var eVal = getValue_1(e_1, storeFieldName);
+                var iVal = getValue_1(i_1, storeFieldName);
+                if (void 0 === iVal)
+                    return;
+                if (getStorageArgs) {
+                    getStorageArgs.push(storeFieldName);
+                }
+                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);
+                if (aVal !== iVal) {
+                    changedFields_1 = changedFields_1 || new Map;
+                    changedFields_1.set(storeFieldName, aVal);
+                }
+                if (getStorageArgs) {
+                    globals.invariant(getStorageArgs.pop() === storeFieldName);
+                }
+            });
+            if (changedFields_1) {
+                incoming = (isArray(i_1) ? i_1.slice(0) : tslib.__assign({}, i_1));
+                changedFields_1.forEach(function (value, name) {
+                    incoming[name] = value;
+                });
+            }
+        }
+        if (mergeTree.info) {
+            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));
+        }
+        return incoming;
+    };
+    return StoreWriter;
+}());
+var emptyMergeTreePool = [];
+function getChildMergeTree(_a, name) {
+    var map = _a.map;
+    if (!map.has(name)) {
+        map.set(name, emptyMergeTreePool.pop() || { map: new Map });
+    }
+    return map.get(name);
+}
+function mergeMergeTrees(left, right) {
+    if (left === right || !right || mergeTreeIsEmpty(right))
+        return left;
+    if (!left || mergeTreeIsEmpty(left))
+        return right;
+    var info = left.info && right.info ? tslib.__assign(tslib.__assign({}, left.info), right.info) : left.info || right.info;
+    var needToMergeMaps = left.map.size && right.map.size;
+    var map = needToMergeMaps ? new Map :
+        left.map.size ? left.map : right.map;
+    var merged = { info: info, map: map };
+    if (needToMergeMaps) {
+        var remainingRightKeys_1 = new Set(right.map.keys());
+        left.map.forEach(function (leftTree, key) {
+            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));
+            remainingRightKeys_1.delete(key);
+        });
+        remainingRightKeys_1.forEach(function (key) {
+            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));
+        });
+    }
+    return merged;
+}
+function mergeTreeIsEmpty(tree) {
+    return !tree || !(tree.info || tree.map.size);
+}
+function maybeRecycleChildMergeTree(_a, name) {
+    var map = _a.map;
+    var childTree = map.get(name);
+    if (childTree && mergeTreeIsEmpty(childTree)) {
+        emptyMergeTreePool.push(childTree);
+        map.delete(name);
+    }
+}
+var warnings = new Set();
+function warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {
+    var getChild = function (objOrRef) {
+        var child = store.getFieldValue(objOrRef, storeFieldName);
+        return typeof child === "object" && child;
+    };
+    var existing = getChild(existingRef);
+    if (!existing)
+        return;
+    var incoming = getChild(incomingObj);
+    if (!incoming)
+        return;
+    if (utilities.isReference(existing))
+        return;
+    if (equality.equal(existing, incoming))
+        return;
+    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {
+        return;
+    }
+    var parentType = store.getFieldValue(existingRef, "__typename") ||
+        store.getFieldValue(incomingObj, "__typename");
+    var fieldName = fieldNameFromStoreName(storeFieldName);
+    var typeDotName = "".concat(parentType, ".").concat(fieldName);
+    if (warnings.has(typeDotName))
+        return;
+    warnings.add(typeDotName);
+    var childTypenames = [];
+    if (!isArray(existing) &&
+        !isArray(incoming)) {
+        [existing, incoming].forEach(function (child) {
+            var typename = store.getFieldValue(child, "__typename");
+            if (typeof typename === "string" &&
+                !childTypenames.includes(typename)) {
+                childTypenames.push(typename);
+            }
+        });
+    }
+    __DEV__ && globals.invariant.warn("Cache data may be lost when replacing the ".concat(fieldName, " field of a ").concat(parentType, " object.\n\nTo address this problem (which is not a bug in Apollo Client), ").concat(childTypenames.length
+        ? "either ensure all objects of type " +
+            childTypenames.join(" and ") + " have an ID or a custom merge function, or "
+        : "", "define a custom merge function for the ").concat(typeDotName, " field, so InMemoryCache can safely merge these objects:\n\n  existing: ").concat(JSON.stringify(existing).slice(0, 1000), "\n  incoming: ").concat(JSON.stringify(incoming).slice(0, 1000), "\n\nFor more information about these options, please refer to the documentation:\n\n  * Ensuring entity objects have IDs: https://go.apollo.dev/c/generating-unique-identifiers\n  * Defining custom merge functions: https://go.apollo.dev/c/merging-non-normalized-objects\n"));
+}
+
+var InMemoryCache = (function (_super) {
+    tslib.__extends(InMemoryCache, _super);
+    function InMemoryCache(config) {
+        if (config === void 0) { config = {}; }
+        var _this = _super.call(this) || this;
+        _this.watches = new Set();
+        _this.typenameDocumentCache = new Map();
+        _this.makeVar = makeVar;
+        _this.txCount = 0;
+        _this.config = normalizeConfig(config);
+        _this.addTypename = !!_this.config.addTypename;
+        _this.policies = new Policies({
+            cache: _this,
+            dataIdFromObject: _this.config.dataIdFromObject,
+            possibleTypes: _this.config.possibleTypes,
+            typePolicies: _this.config.typePolicies,
+        });
+        _this.init();
+        return _this;
+    }
+    InMemoryCache.prototype.init = function () {
+        var rootStore = this.data = new exports.EntityStore.Root({
+            policies: this.policies,
+            resultCaching: this.config.resultCaching,
+        });
+        this.optimisticData = rootStore.stump;
+        this.resetResultCache();
+    };
+    InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {
+        var _this = this;
+        var previousReader = this.storeReader;
+        this.storeWriter = new StoreWriter(this, this.storeReader = new StoreReader({
+            cache: this,
+            addTypename: this.addTypename,
+            resultCacheMaxSize: this.config.resultCacheMaxSize,
+            canonizeResults: shouldCanonizeResults(this.config),
+            canon: resetResultIdentities
+                ? void 0
+                : previousReader && previousReader.canon,
+        }));
+        this.maybeBroadcastWatch = optimism.wrap(function (c, options) {
+            return _this.broadcastWatch(c, options);
+        }, {
+            max: this.config.resultCacheMaxSize,
+            makeCacheKey: function (c) {
+                var store = c.optimistic ? _this.optimisticData : _this.data;
+                if (supportsResultCaching(store)) {
+                    var optimistic = c.optimistic, rootId = c.rootId, variables = c.variables;
+                    return store.makeCacheKey(c.query, c.callback, canonicalStringify({ optimistic: optimistic, rootId: rootId, variables: variables }));
+                }
+            }
+        });
+        new Set([
+            this.data.group,
+            this.optimisticData.group,
+        ]).forEach(function (group) { return group.resetCaching(); });
+    };
+    InMemoryCache.prototype.restore = function (data) {
+        this.init();
+        if (data)
+            this.data.replace(data);
+        return this;
+    };
+    InMemoryCache.prototype.extract = function (optimistic) {
+        if (optimistic === void 0) { optimistic = false; }
+        return (optimistic ? this.optimisticData : this.data).extract();
+    };
+    InMemoryCache.prototype.read = function (options) {
+        var _a = options.returnPartialData, returnPartialData = _a === void 0 ? false : _a;
+        try {
+            return this.storeReader.diffQueryAgainstStore(tslib.__assign(tslib.__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null;
+        }
+        catch (e) {
+            if (e instanceof MissingFieldError) {
+                return null;
+            }
+            throw e;
+        }
+    };
+    InMemoryCache.prototype.write = function (options) {
+        try {
+            ++this.txCount;
+            return this.storeWriter.writeToStore(this.data, options);
+        }
+        finally {
+            if (!--this.txCount && options.broadcast !== false) {
+                this.broadcastWatches();
+            }
+        }
+    };
+    InMemoryCache.prototype.modify = function (options) {
+        if (hasOwn.call(options, "id") && !options.id) {
+            return false;
+        }
+        var store = options.optimistic
+            ? this.optimisticData
+            : this.data;
+        try {
+            ++this.txCount;
+            return store.modify(options.id || "ROOT_QUERY", options.fields);
+        }
+        finally {
+            if (!--this.txCount && options.broadcast !== false) {
+                this.broadcastWatches();
+            }
+        }
+    };
+    InMemoryCache.prototype.diff = function (options) {
+        return this.storeReader.diffQueryAgainstStore(tslib.__assign(tslib.__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || "ROOT_QUERY", config: this.config }));
+    };
+    InMemoryCache.prototype.watch = function (watch) {
+        var _this = this;
+        if (!this.watches.size) {
+            recallCache(this);
+        }
+        this.watches.add(watch);
+        if (watch.immediate) {
+            this.maybeBroadcastWatch(watch);
+        }
+        return function () {
+            if (_this.watches.delete(watch) && !_this.watches.size) {
+                forgetCache(_this);
+            }
+            _this.maybeBroadcastWatch.forget(watch);
+        };
+    };
+    InMemoryCache.prototype.gc = function (options) {
+        canonicalStringify.reset();
+        var ids = this.optimisticData.gc();
+        if (options && !this.txCount) {
+            if (options.resetResultCache) {
+                this.resetResultCache(options.resetResultIdentities);
+            }
+            else if (options.resetResultIdentities) {
+                this.storeReader.resetCanon();
+            }
+        }
+        return ids;
+    };
+    InMemoryCache.prototype.retain = function (rootId, optimistic) {
+        return (optimistic ? this.optimisticData : this.data).retain(rootId);
+    };
+    InMemoryCache.prototype.release = function (rootId, optimistic) {
+        return (optimistic ? this.optimisticData : this.data).release(rootId);
+    };
+    InMemoryCache.prototype.identify = function (object) {
+        if (utilities.isReference(object))
+            return object.__ref;
+        try {
+            return this.policies.identify(object)[0];
+        }
+        catch (e) {
+            __DEV__ && globals.invariant.warn(e);
+        }
+    };
+    InMemoryCache.prototype.evict = function (options) {
+        if (!options.id) {
+            if (hasOwn.call(options, "id")) {
+                return false;
+            }
+            options = tslib.__assign(tslib.__assign({}, options), { id: "ROOT_QUERY" });
+        }
+        try {
+            ++this.txCount;
+            return this.optimisticData.evict(options, this.data);
+        }
+        finally {
+            if (!--this.txCount && options.broadcast !== false) {
+                this.broadcastWatches();
+            }
+        }
+    };
+    InMemoryCache.prototype.reset = function (options) {
+        var _this = this;
+        this.init();
+        canonicalStringify.reset();
+        if (options && options.discardWatches) {
+            this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });
+            this.watches.clear();
+            forgetCache(this);
+        }
+        else {
+            this.broadcastWatches();
+        }
+        return Promise.resolve();
+    };
+    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {
+        var newOptimisticData = this.optimisticData.removeLayer(idToRemove);
+        if (newOptimisticData !== this.optimisticData) {
+            this.optimisticData = newOptimisticData;
+            this.broadcastWatches();
+        }
+    };
+    InMemoryCache.prototype.batch = function (options) {
+        var _this = this;
+        var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;
+        var updateResult;
+        var perform = function (layer) {
+            var _a = _this, data = _a.data, optimisticData = _a.optimisticData;
+            ++_this.txCount;
+            if (layer) {
+                _this.data = _this.optimisticData = layer;
+            }
+            try {
+                return updateResult = update(_this);
+            }
+            finally {
+                --_this.txCount;
+                _this.data = data;
+                _this.optimisticData = optimisticData;
+            }
+        };
+        var alreadyDirty = new Set();
+        if (onWatchUpdated && !this.txCount) {
+            this.broadcastWatches(tslib.__assign(tslib.__assign({}, options), { onWatchUpdated: function (watch) {
+                    alreadyDirty.add(watch);
+                    return false;
+                } }));
+        }
+        if (typeof optimistic === 'string') {
+            this.optimisticData = this.optimisticData.addLayer(optimistic, perform);
+        }
+        else if (optimistic === false) {
+            perform(this.data);
+        }
+        else {
+            perform();
+        }
+        if (typeof removeOptimistic === "string") {
+            this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);
+        }
+        if (onWatchUpdated && alreadyDirty.size) {
+            this.broadcastWatches(tslib.__assign(tslib.__assign({}, options), { onWatchUpdated: function (watch, diff) {
+                    var result = onWatchUpdated.call(this, watch, diff);
+                    if (result !== false) {
+                        alreadyDirty.delete(watch);
+                    }
+                    return result;
+                } }));
+            if (alreadyDirty.size) {
+                alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });
+            }
+        }
+        else {
+            this.broadcastWatches(options);
+        }
+        return updateResult;
+    };
+    InMemoryCache.prototype.performTransaction = function (update, optimisticId) {
+        return this.batch({
+            update: update,
+            optimistic: optimisticId || (optimisticId !== null),
+        });
+    };
+    InMemoryCache.prototype.transformDocument = function (document) {
+        if (this.addTypename) {
+            var result = this.typenameDocumentCache.get(document);
+            if (!result) {
+                result = utilities.addTypenameToDocument(document);
+                this.typenameDocumentCache.set(document, result);
+                this.typenameDocumentCache.set(result, result);
+            }
+            return result;
+        }
+        return document;
+    };
+    InMemoryCache.prototype.broadcastWatches = function (options) {
+        var _this = this;
+        if (!this.txCount) {
+            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });
+        }
+    };
+    InMemoryCache.prototype.broadcastWatch = function (c, options) {
+        var lastDiff = c.lastDiff;
+        var diff = this.diff(c);
+        if (options) {
+            if (c.optimistic &&
+                typeof options.optimistic === "string") {
+                diff.fromOptimisticTransaction = true;
+            }
+            if (options.onWatchUpdated &&
+                options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {
+                return;
+            }
+        }
+        if (!lastDiff || !equality.equal(lastDiff.result, diff.result)) {
+            c.callback(c.lastDiff = diff, lastDiff);
+        }
+    };
+    return InMemoryCache;
+}(ApolloCache));
+
+exports.isReference = utilities.isReference;
+exports.makeReference = utilities.makeReference;
+exports.ApolloCache = ApolloCache;
+exports.InMemoryCache = InMemoryCache;
+exports.MissingFieldError = MissingFieldError;
+exports.Policies = Policies;
+exports.cacheSlot = cacheSlot;
+exports.canonicalStringify = canonicalStringify;
+exports.defaultDataIdFromObject = defaultDataIdFromObject;
+exports.fieldNameFromStoreName = fieldNameFromStoreName;
+exports.makeVar = makeVar;
+//# sourceMappingURL=cache.cjs.map