react-easy-wall 2.0.13 → 3.0.0

package/dist/esm/node_modules/@apollo/client/cache/core/types/common.js

@@ -1,31 +0,0 @@
-class MissingFieldError extends Error {
-    message;
-    path;
-    query;
-    variables;
-    constructor(message, path, query, variables) {
-        // 'Error' breaks prototype chain here
-        super(message);
-        this.message = message;
-        this.path = path;
-        this.query = query;
-        this.variables = variables;
-        this.name = "MissingFieldError";
-        if (Array.isArray(this.path)) {
-            this.missing = this.message;
-            for (let i = this.path.length - 1; i >= 0; --i) {
-                this.missing = { [this.path[i]]: this.missing };
-            }
-        }
-        else {
-            this.missing = this.path;
-        }
-        // We're not using `Object.setPrototypeOf` here as it isn't fully supported
-        // on Android (see issue #3236).
-        this.__proto__ = MissingFieldError.prototype;
-    }
-    missing;
-}
-
-export { MissingFieldError };
-//# sourceMappingURL=common.js.map

package/dist/esm/node_modules/@apollo/client/cache/core/types/common.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.js","sources":["../../../../../../../../node_modules/@apollo/client/cache/core/types/common.js"],"sourcesContent":["export class MissingFieldError extends Error {\n    message;\n    path;\n    query;\n    variables;\n    constructor(message, path, query, variables) {\n        // 'Error' breaks prototype chain here\n        super(message);\n        this.message = message;\n        this.path = path;\n        this.query = query;\n        this.variables = variables;\n        this.name = \"MissingFieldError\";\n        if (Array.isArray(this.path)) {\n            this.missing = this.message;\n            for (let i = this.path.length - 1; i >= 0; --i) {\n                this.missing = { [this.path[i]]: this.missing };\n            }\n        }\n        else {\n            this.missing = this.path;\n        }\n        // We're not using `Object.setPrototypeOf` here as it isn't fully supported\n        // on Android (see issue #3236).\n        this.__proto__ = MissingFieldError.prototype;\n    }\n    missing;\n}\n//# sourceMappingURL=common.js.map"],"names":[],"mappings":"AAAO,MAAM,iBAAiB,SAAS,KAAK,CAAC;AAC7C,IAAI,OAAO;AACX,IAAI,IAAI;AACR,IAAI,KAAK;AACT,IAAI,SAAS;AACb,IAAI,WAAW,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE;AACjD;AACA,QAAQ,KAAK,CAAC,OAAO,CAAC;AACtB,QAAQ,IAAI,CAAC,OAAO,GAAG,OAAO;AAC9B,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI;AACxB,QAAQ,IAAI,CAAC,KAAK,GAAG,KAAK;AAC1B,QAAQ,IAAI,CAAC,SAAS,GAAG,SAAS;AAClC,QAAQ,IAAI,CAAC,IAAI,GAAG,mBAAmB;AACvC,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;AACtC,YAAY,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO;AACvC,YAAY,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE;AAC5D,gBAAgB,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE;AAC/D,YAAY;AACZ,QAAQ;AACR,aAAa;AACb,YAAY,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI;AACpC,QAAQ;AACR;AACA;AACA,QAAQ,IAAI,CAAC,SAAS,GAAG,iBAAiB,CAAC,SAAS;AACpD,IAAI;AACJ,IAAI,OAAO;AACX;;;;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/@apollo/client/cache/inmemory/entityStore.js

@@ -1,638 +0,0 @@
-import { equal } from '../../../../@wry/equality/lib/index.js';
-import { Trie } from '../../../../@wry/trie/lib/index.js';
-import '../../../../optimism/lib/entry.js';
-import '../../../../optimism/lib/context.js';
-import { dep } from '../../../../optimism/lib/dep.js';
-import { isReference } from '../../utilities/graphql/storeUtils.js';
-import { invariant } from '../../utilities/invariant/index.js';
-import { hasOwn, fieldNameFromStoreName } from './helpers.js';
-import { maybeDeepFreeze } from '../../utilities/internal/maybeDeepFreeze.js';
-import { makeReference } from '../../utilities/internal/makeReference.js';
-import { DeepMerger } from '../../utilities/internal/DeepMerger.js';
-import { isNonNullObject } from '../../utilities/internal/isNonNullObject.js';
-
-const DELETE = {};
-const delModifier = () => DELETE;
-const INVALIDATE = {};
-class EntityStore {
-    policies;
-    group;
-    data = {};
-    constructor(policies, group) {
-        this.policies = policies;
-        this.group = group;
-    }
-    // Although the EntityStore class is abstract, it contains concrete
-    // implementations of the various NormalizedCache interface methods that
-    // are inherited by the Root and Layer subclasses.
-    toObject() {
-        return { ...this.data };
-    }
-    has(dataId) {
-        return this.lookup(dataId, true) !== void 0;
-    }
-    get(dataId, fieldName) {
-        this.group.depend(dataId, fieldName);
-        if (hasOwn.call(this.data, dataId)) {
-            const 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);
-        }
-    }
-    lookup(dataId, dependOnExistence) {
-        // The has method (above) calls lookup with dependOnExistence = true, so
-        // that it can later be invalidated when we add or remove a StoreObject for
-        // this dataId. Any consumer who cares about the contents of the StoreObject
-        // should not rely on this dependency, since the contents could change
-        // without the object being added or removed.
-        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 {};
-        }
-    }
-    merge(older, newer) {
-        let dataId;
-        // Convert unexpected references to ID strings.
-        if (isReference(older))
-            older = older.__ref;
-        if (isReference(newer))
-            newer = newer.__ref;
-        const existing = typeof older === "string" ? this.lookup((dataId = older)) : older;
-        const incoming = typeof newer === "string" ? this.lookup((dataId = newer)) : newer;
-        // If newer was a string ID, but that ID was not defined in this store,
-        // then there are no fields to be merged, so we're done.
-        if (!incoming)
-            return;
-        invariant(typeof dataId === "string", 99);
-        const merged = new DeepMerger({
-            reconciler: storeObjectReconciler,
-        }).merge(existing, incoming);
-        // Even if merged === existing, existing may have come from a lower
-        // layer, so we always need to set this.data[dataId] on this level.
-        this.data[dataId] = merged;
-        if (merged !== existing) {
-            delete this.refs[dataId];
-            if (this.group.caching) {
-                const fieldsToDirty = {};
-                // If we added a new StoreObject where there was previously none, dirty
-                // anything that depended on the existence of this dataId, such as the
-                // EntityStore#has method.
-                if (!existing)
-                    fieldsToDirty.__exists = 1;
-                // Now invalidate dependents who called getFieldValue for any fields
-                // that are changing as a result of this merge.
-                Object.keys(incoming).forEach((storeFieldName) => {
-                    if (!existing ||
-                        existing[storeFieldName] !== merged[storeFieldName]) {
-                        // Always dirty the full storeFieldName, which may include
-                        // serialized arguments following the fieldName prefix.
-                        fieldsToDirty[storeFieldName] = 1;
-                        // Also dirty fieldNameFromStoreName(storeFieldName) if it's
-                        // different from storeFieldName and this field does not have
-                        // keyArgs configured, because that means the cache can't make
-                        // any assumptions about how field values with the same field
-                        // name but different arguments might be interrelated, so it
-                        // must err on the side of invalidating all field values that
-                        // share the same short fieldName, regardless of arguments.
-                        const fieldName = fieldNameFromStoreName(storeFieldName);
-                        if (fieldName !== storeFieldName &&
-                            !this.policies.hasKeyArgs(merged.__typename, fieldName)) {
-                            fieldsToDirty[fieldName] = 1;
-                        }
-                        // If merged[storeFieldName] has become undefined, and this is the
-                        // Root layer, actually delete the property from the merged object,
-                        // which is guaranteed to have been created fresh in this method.
-                        if (merged[storeFieldName] === void 0 && !(this instanceof Layer)) {
-                            delete merged[storeFieldName];
-                        }
-                    }
-                });
-                if (fieldsToDirty.__typename &&
-                    !(existing && existing.__typename) &&
-                    // Since we return default root __typename strings
-                    // automatically from store.get, we don't need to dirty the
-                    // ROOT_QUERY.__typename field if merged.__typename is equal
-                    // to the default string (usually "Query").
-                    this.policies.rootTypenamesById[dataId] === merged.__typename) {
-                    delete fieldsToDirty.__typename;
-                }
-                Object.keys(fieldsToDirty).forEach((fieldName) => this.group.dirty(dataId, fieldName));
-            }
-        }
-    }
-    modify(dataId, fields, exact) {
-        const storeObject = this.lookup(dataId);
-        if (storeObject) {
-            const changedFields = {};
-            let needToMerge = false;
-            let allDeleted = true;
-            const sharedDetails = {
-                DELETE,
-                INVALIDATE,
-                isReference,
-                toReference: this.toReference,
-                canRead: this.canRead,
-                readField: (fieldNameOrOptions, from) => this.policies.readField(typeof fieldNameOrOptions === "string" ?
-                    {
-                        fieldName: fieldNameOrOptions,
-                        from: from || makeReference(dataId),
-                    }
-                    : fieldNameOrOptions, { store: this }),
-            };
-            Object.keys(storeObject).forEach((storeFieldName) => {
-                const fieldName = fieldNameFromStoreName(storeFieldName);
-                let fieldValue = storeObject[storeFieldName];
-                if (fieldValue === void 0)
-                    return;
-                const modify = typeof fields === "function" ? fields : (fields[storeFieldName] || (exact ? undefined : fields[fieldName]));
-                if (modify) {
-                    let newValue = modify === delModifier ? DELETE : (modify(maybeDeepFreeze(fieldValue), {
-                        ...sharedDetails,
-                        fieldName,
-                        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[storeFieldName] = newValue;
-                            needToMerge = true;
-                            fieldValue = newValue;
-                        }
-                    }
-                }
-                if (fieldValue !== void 0) {
-                    allDeleted = false;
-                }
-            });
-            if (needToMerge) {
-                this.merge(dataId, changedFields);
-                if (allDeleted) {
-                    if (this instanceof Layer) {
-                        this.data[dataId] = void 0;
-                    }
-                    else {
-                        delete this.data[dataId];
-                    }
-                    this.group.dirty(dataId, "__exists");
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    // If called with only one argument, removes the entire entity
-    // identified by dataId. If called with a fieldName as well, removes all
-    // fields of that entity whose names match fieldName according to the
-    // fieldNameFromStoreName helper function. If called with a fieldName
-    // and variables, removes all fields of that entity whose names match fieldName
-    // and whose arguments when cached exactly match the variables passed.
-    delete(dataId, fieldName, args) {
-        const storeObject = this.lookup(dataId);
-        if (storeObject) {
-            const typename = this.getFieldValue(storeObject, "__typename");
-            const storeFieldName = fieldName && args ?
-                this.policies.getStoreFieldName({ typename, fieldName, args })
-                : fieldName;
-            return this.modify(dataId, storeFieldName ?
-                {
-                    [storeFieldName]: delModifier,
-                }
-                : delModifier, !!args);
-        }
-        return false;
-    }
-    evict(options, limit) {
-        let 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;
-            }
-            // Always invalidate the field to trigger rereading of watched
-            // queries, even if no cache data was modified by the eviction,
-            // because queries may depend on computed fields with custom read
-            // functions, whose values are not stored in the EntityStore.
-            if (options.fieldName || evicted) {
-                this.group.dirty(options.id, options.fieldName || "__exists");
-            }
-        }
-        return evicted;
-    }
-    clear() {
-        this.replace(null);
-    }
-    extract() {
-        const obj = this.toObject();
-        const extraRootIds = [];
-        this.getRootIdSet().forEach((id) => {
-            if (!hasOwn.call(this.policies.rootTypenamesById, id)) {
-                extraRootIds.push(id);
-            }
-        });
-        if (extraRootIds.length) {
-            obj.__META = { extraRootIds: extraRootIds.sort() };
-        }
-        return obj;
-    }
-    replace(newData) {
-        Object.keys(this.data).forEach((dataId) => {
-            if (!(newData && hasOwn.call(newData, dataId))) {
-                this.delete(dataId);
-            }
-        });
-        if (newData) {
-            const { __META, ...rest } = newData;
-            Object.keys(rest).forEach((dataId) => {
-                this.merge(dataId, rest[dataId]);
-            });
-            if (__META) {
-                __META.extraRootIds.forEach(this.retain, this);
-            }
-        }
-    }
-    // Maps root entity IDs to the number of times they have been retained, minus
-    // the number of times they have been released. Retained entities keep other
-    // entities they reference (even indirectly) from being garbage collected.
-    rootIds = {};
-    retain(rootId) {
-        return (this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1);
-    }
-    release(rootId) {
-        if (this.rootIds[rootId] > 0) {
-            const count = --this.rootIds[rootId];
-            if (!count)
-                delete this.rootIds[rootId];
-            return count;
-        }
-        return 0;
-    }
-    // Return a Set<string> of all the ID strings that have been retained by
-    // this layer/root *and* any layers/roots beneath it.
-    getRootIdSet(ids = new Set()) {
-        Object.keys(this.rootIds).forEach(ids.add, ids);
-        if (this instanceof Layer) {
-            this.parent.getRootIdSet(ids);
-        }
-        else {
-            // Official singleton IDs like ROOT_QUERY and ROOT_MUTATION are
-            // always considered roots for garbage collection, regardless of
-            // their retainment counts in this.rootIds.
-            Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);
-        }
-        return ids;
-    }
-    // The goal of garbage collection is to remove IDs from the Root layer of the
-    // store that are no longer reachable starting from any IDs that have been
-    // explicitly retained (see retain and release, above). Returns an array of
-    // dataId strings that were removed from the store.
-    gc() {
-        const ids = this.getRootIdSet();
-        const snapshot = this.toObject();
-        ids.forEach((id) => {
-            if (hasOwn.call(snapshot, id)) {
-                // Because we are iterating over an ECMAScript Set, the IDs we add here
-                // will be visited in later iterations of the forEach loop only if they
-                // were not previously contained by the Set.
-                Object.keys(this.findChildRefIds(id)).forEach(ids.add, ids);
-                // By removing IDs from the snapshot object here, we protect them from
-                // getting removed from the root store layer below.
-                delete snapshot[id];
-            }
-        });
-        const idsToRemove = Object.keys(snapshot);
-        if (idsToRemove.length) {
-            let root = this;
-            while (root instanceof Layer)
-                root = root.parent;
-            idsToRemove.forEach((id) => root.delete(id));
-        }
-        return idsToRemove;
-    }
-    // Lazily tracks { __ref: <dataId> } strings contained by this.data[dataId].
-    refs = {};
-    findChildRefIds(dataId) {
-        if (!hasOwn.call(this.refs, dataId)) {
-            const found = (this.refs[dataId] = {});
-            const root = this.data[dataId];
-            if (!root)
-                return found;
-            const workSet = new Set([root]);
-            // Within the store, only arrays and objects can contain child entity
-            // references, so we can prune the traversal using this predicate:
-            workSet.forEach((obj) => {
-                if (isReference(obj)) {
-                    found[obj.__ref] = true;
-                    // In rare cases, a { __ref } Reference object may have other fields.
-                    // This often indicates a mismerging of References with StoreObjects,
-                    // but garbage collection should not be fooled by a stray __ref
-                    // property in a StoreObject (ignoring all the other fields just
-                    // because the StoreObject looks like a Reference). To avoid this
-                    // premature termination of findChildRefIds recursion, we fall through
-                    // to the code below, which will handle any other properties of obj.
-                }
-                if (isNonNullObject(obj)) {
-                    Object.keys(obj).forEach((key) => {
-                        const child = obj[key];
-                        // No need to add primitive values to the workSet, since they cannot
-                        // contain reference objects.
-                        if (isNonNullObject(child)) {
-                            workSet.add(child);
-                        }
-                    });
-                }
-            });
-        }
-        return this.refs[dataId];
-    }
-    makeCacheKey() {
-        return this.group.keyMaker.lookupArray(arguments);
-    }
-    // Bound function that can be passed around to provide easy access to fields
-    // of Reference objects as well as ordinary objects.
-    getFieldValue = (objectOrReference, storeFieldName) => maybeDeepFreeze(isReference(objectOrReference) ?
-        this.get(objectOrReference.__ref, storeFieldName)
-        : objectOrReference && objectOrReference[storeFieldName]);
-    // Returns true for non-normalized StoreObjects and non-dangling
-    // References, indicating that readField(name, objOrRef) has a chance of
-    // working. Useful for filtering out dangling references from lists.
-    canRead = (objOrRef) => {
-        return isReference(objOrRef) ?
-            this.has(objOrRef.__ref)
-            : typeof objOrRef === "object";
-    };
-    // Bound function that converts an id or an object with a __typename and
-    // primary key fields to a Reference object. If called with a Reference object,
-    // that same Reference object is returned. Pass true for mergeIntoStore to persist
-    // an object into the store.
-    toReference = (objOrIdOrRef, mergeIntoStore) => {
-        if (typeof objOrIdOrRef === "string") {
-            return makeReference(objOrIdOrRef);
-        }
-        if (isReference(objOrIdOrRef)) {
-            return objOrIdOrRef;
-        }
-        const [id] = this.policies.identify(objOrIdOrRef);
-        if (id) {
-            const ref = makeReference(id);
-            if (mergeIntoStore) {
-                this.merge(id, objOrIdOrRef);
-            }
-            return ref;
-        }
-    };
-    get supportsResultCaching() {
-        return this.group.caching;
-    }
-}
-// A single CacheGroup represents a set of one or more EntityStore objects,
-// typically the Root store in a CacheGroup by itself, and all active Layer
-// stores in a group together. A single EntityStore object belongs to only
-// one CacheGroup, store.group. The CacheGroup is responsible for tracking
-// dependencies, so store.group is helpful for generating unique keys for
-// cached results that need to be invalidated when/if those dependencies
-// change. If we used the EntityStore objects themselves as cache keys (that
-// is, store rather than store.group), the cache would become unnecessarily
-// fragmented by all the different Layer objects. Instead, the CacheGroup
-// approach allows all optimistic Layer objects in the same linked list to
-// belong to one CacheGroup, with the non-optimistic Root object belonging
-// to another CacheGroup, allowing resultCaching dependencies to be tracked
-// separately for optimistic and non-optimistic entity data.
-class CacheGroup {
-    caching;
-    parent;
-    d = null;
-    // Used by the EntityStore#makeCacheKey method to compute cache keys
-    // specific to this CacheGroup.
-    keyMaker;
-    constructor(caching, parent = null) {
-        this.caching = caching;
-        this.parent = parent;
-        this.resetCaching();
-    }
-    resetCaching() {
-        this.d = this.caching ? dep() : null;
-        this.keyMaker = new Trie();
-    }
-    depend(dataId, storeFieldName) {
-        if (this.d) {
-            this.d(makeDepKey(dataId, storeFieldName));
-            const fieldName = fieldNameFromStoreName(storeFieldName);
-            if (fieldName !== storeFieldName) {
-                // Fields with arguments that contribute extra identifying
-                // information to the fieldName (thus forming the storeFieldName)
-                // depend not only on the full storeFieldName but also on the
-                // short fieldName, so the field can be invalidated using either
-                // level of specificity.
-                this.d(makeDepKey(dataId, fieldName));
-            }
-            if (this.parent) {
-                this.parent.depend(dataId, storeFieldName);
-            }
-        }
-    }
-    dirty(dataId, storeFieldName) {
-        if (this.d) {
-            this.d.dirty(makeDepKey(dataId, storeFieldName), 
-            // When storeFieldName === "__exists", that means the entity identified
-            // by dataId has either disappeared from the cache or was newly added,
-            // so the result caching system would do well to "forget everything it
-            // knows" about that object. To achieve that kind of invalidation, we
-            // not only dirty the associated result cache entry, but also remove it
-            // completely from the dependency graph. For the optimism implementation
-            // details, see https://github.com/benjamn/optimism/pull/195.
-            storeFieldName === "__exists" ? "forget" : "setDirty");
-        }
-    }
-}
-function makeDepKey(dataId, storeFieldName) {
-    // Since field names cannot have '#' characters in them, this method
-    // of joining the field name and the ID should be unambiguous, and much
-    // cheaper than JSON.stringify([dataId, fieldName]).
-    return storeFieldName + "#" + dataId;
-}
-function maybeDependOnExistenceOfEntity(store, entityId) {
-    if (supportsResultCaching(store)) {
-        // We use this pseudo-field __exists elsewhere in the EntityStore code to
-        // represent changes in the existence of the entity object identified by
-        // entityId. This dependency gets reliably dirtied whenever an object with
-        // this ID is deleted (or newly created) within this group, so any result
-        // cache entries (for example, StoreReader#executeSelectionSet results) that
-        // depend on __exists for this entityId will get dirtied as well, leading to
-        // the eventual recomputation (instead of reuse) of those result objects the
-        // next time someone reads them from the cache.
-        store.group.depend(entityId, "__exists");
-    }
-}
-class Root extends EntityStore {
-    constructor({ policies, resultCaching = true, seed, }) {
-        super(policies, new CacheGroup(resultCaching));
-        if (seed)
-            this.replace(seed);
-    }
-    stump = new Stump(this);
-    addLayer(layerId, replay) {
-        // Adding an optimistic Layer on top of the Root actually adds the Layer
-        // on top of the Stump, so the Stump always comes between the Root and
-        // any Layer objects that we've added.
-        return this.stump.addLayer(layerId, replay);
-    }
-    removeLayer() {
-        // Never remove the root layer.
-        return this;
-    }
-    storageTrie = new Trie();
-    getStorage() {
-        return this.storageTrie.lookupArray(arguments);
-    }
-}
-EntityStore.Root = Root;
-// Not exported, since all Layer instances are created by the addLayer method
-// of the EntityStore.Root class.
-class Layer extends EntityStore {
-    id;
-    parent;
-    replay;
-    group;
-    constructor(id, parent, replay, group) {
-        super(parent.policies, group);
-        this.id = id;
-        this.parent = parent;
-        this.replay = replay;
-        this.group = group;
-        replay(this);
-    }
-    addLayer(layerId, replay) {
-        return new Layer(layerId, this, replay, this.group);
-    }
-    removeLayer(layerId) {
-        // Remove all instances of the given id, not just the first one.
-        const parent = this.parent.removeLayer(layerId);
-        if (layerId === this.id) {
-            if (this.group.caching) {
-                // Dirty every ID we're removing. Technically we might be able to avoid
-                // dirtying fields that have values in higher layers, but we don't have
-                // easy access to higher layers here, and we're about to recreate those
-                // layers anyway (see parent.addLayer below).
-                Object.keys(this.data).forEach((dataId) => {
-                    const ownStoreObject = this.data[dataId];
-                    const parentStoreObject = parent["lookup"](dataId);
-                    if (!parentStoreObject) {
-                        // The StoreObject identified by dataId was defined in this layer
-                        // but will be undefined in the parent layer, so we can delete the
-                        // whole entity using this.delete(dataId). Since we're about to
-                        // throw this layer away, the only goal of this deletion is to dirty
-                        // the removed fields.
-                        this.delete(dataId);
-                    }
-                    else if (!ownStoreObject) {
-                        // This layer had an entry for dataId but it was undefined, which
-                        // means the entity was deleted in this layer, and it's about to
-                        // become undeleted when we remove this layer, so we need to dirty
-                        // all fields that are about to be reexposed.
-                        this.group.dirty(dataId, "__exists");
-                        Object.keys(parentStoreObject).forEach((storeFieldName) => {
-                            this.group.dirty(dataId, storeFieldName);
-                        });
-                    }
-                    else if (ownStoreObject !== parentStoreObject) {
-                        // If ownStoreObject is not exactly the same as parentStoreObject,
-                        // dirty any fields whose values will change as a result of this
-                        // removal.
-                        Object.keys(ownStoreObject).forEach((storeFieldName) => {
-                            if (!equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {
-                                this.group.dirty(dataId, storeFieldName);
-                            }
-                        });
-                    }
-                });
-            }
-            return parent;
-        }
-        // No changes are necessary if the parent chain remains identical.
-        if (parent === this.parent)
-            return this;
-        // Recreate this layer on top of the new parent.
-        return parent.addLayer(this.id, this.replay);
-    }
-    toObject() {
-        return {
-            ...this.parent.toObject(),
-            ...this.data,
-        };
-    }
-    findChildRefIds(dataId) {
-        const fromParent = this.parent.findChildRefIds(dataId);
-        return hasOwn.call(this.data, dataId) ?
-            {
-                ...fromParent,
-                ...super.findChildRefIds(dataId),
-            }
-            : fromParent;
-    }
-    getStorage(...args) {
-        let p = this.parent;
-        while (p.parent)
-            p = p.parent;
-        return p.getStorage(...args);
-    }
-}
-// Represents a Layer permanently installed just above the Root, which allows
-// reading optimistically (and registering optimistic dependencies) even when
-// no optimistic layers are currently active. The stump.group CacheGroup object
-// is shared by any/all Layer objects added on top of the Stump.
-class Stump extends Layer {
-    constructor(root) {
-        super("EntityStore.Stump", root, () => { }, new CacheGroup(root.group.caching, root.group));
-    }
-    removeLayer() {
-        // Never remove the Stump layer.
-        return this;
-    }
-    merge(older, newer) {
-        // We never want to write any data into the Stump, so we forward any merge
-        // calls to the Root instead. Another option here would be to throw an
-        // exception, but the toReference(object, true) function can sometimes
-        // trigger Stump writes (which used to be Root writes, before the Stump
-        // concept was introduced).
-        return this.parent.merge(older, newer);
-    }
-}
-function storeObjectReconciler(existingObject, incomingObject, property) {
-    const existingValue = existingObject[property];
-    const incomingValue = incomingObject[property];
-    // Wherever there is a key collision, prefer the incoming value, unless
-    // it is deeply equal to the existing value. It's worth checking deep
-    // equality here (even though blindly returning incoming would be
-    // logically correct) because preserving the referential identity of
-    // existing data can prevent needless rereading and rerendering.
-    return equal(existingValue, incomingValue) ? existingValue : incomingValue;
-}
-function supportsResultCaching(store) {
-    // When result caching is disabled, store.depend will be null.
-    return !!(store && store.supportsResultCaching);
-}
-
-export { EntityStore, maybeDependOnExistenceOfEntity, supportsResultCaching };
-//# sourceMappingURL=entityStore.js.map