react-easy-wall 2.0.0 → 2.0.3

package/dist/cjs/node_modules/@apollo/client/utilities/graphql/storeUtils.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Determines if a given object is a reference object.
+ *
+ * @param obj - The object to check if its a reference object
+ *
+ * @example
+ *
+ * ```ts
+ * import { isReference } from "@apollo/client/utilities";
+ *
+ * isReference({ __ref: "User:1" }); // true
+ * isReference({ __typename: "User", id: 1 }); // false
+ * ```
+ */
+function isReference(obj) {
+    return Boolean(obj && typeof obj === "object" && typeof obj.__ref === "string");
+}
+
+exports.isReference = isReference;
+//# sourceMappingURL=storeUtils.cjs.map

package/dist/cjs/node_modules/@apollo/client/utilities/graphql/storeUtils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storeUtils.cjs","sources":["../../../../../../../node_modules/@apollo/client/utilities/graphql/storeUtils.js"],"sourcesContent":["/**\n * Determines if a given object is a reference object.\n *\n * @param obj - The object to check if its a reference object\n *\n * @example\n *\n * ```ts\n * import { isReference } from \"@apollo/client/utilities\";\n *\n * isReference({ __ref: \"User:1\" }); // true\n * isReference({ __typename: \"User\", id: 1 }); // false\n * ```\n */\nexport function isReference(obj) {\n    return Boolean(obj && typeof obj === \"object\" && typeof obj.__ref === \"string\");\n}\n//# sourceMappingURL=storeUtils.js.map"],"names":[],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,WAAW,CAAC,GAAG,EAAE;AACjC,IAAI,OAAO,OAAO,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ,CAAC;AACnF;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@apollo/client/utilities/graphql/transform.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+var visitor = require('../../../../graphql/language/visitor.cjs');
+var kinds = require('../../../../graphql/language/kinds.cjs');
+
+const TYPENAME_FIELD = {
+    kind: kinds.Kind.FIELD,
+    name: {
+        kind: kinds.Kind.NAME,
+        value: "__typename",
+    },
+};
+/**
+ * Adds `__typename` to all selection sets in the document except for the root
+ * selection set.
+ *
+ * @param doc - The `ASTNode` to add `__typename` to
+ *
+ * @example
+ *
+ * ```ts
+ * const document = gql`
+ *   # ...
+ * `;
+ *
+ * const withTypename = addTypenameToDocument(document);
+ * ```
+ */
+const addTypenameToDocument = Object.assign(function (doc) {
+    return visitor.visit(doc, {
+        SelectionSet: {
+            enter(node, _key, parent) {
+                // Don't add __typename to OperationDefinitions.
+                if (parent &&
+                    parent.kind ===
+                        kinds.Kind.OPERATION_DEFINITION) {
+                    return;
+                }
+                // No changes if no selections.
+                const { selections } = node;
+                if (!selections) {
+                    return;
+                }
+                // If selections already have a __typename, or are part of an
+                // introspection query, do nothing.
+                const skip = selections.some((selection) => {
+                    return (selection.kind === kinds.Kind.FIELD &&
+                        (selection.name.value === "__typename" ||
+                            selection.name.value.lastIndexOf("__", 0) === 0));
+                });
+                if (skip) {
+                    return;
+                }
+                // If this SelectionSet is @export-ed as an input variable, it should
+                // not have a __typename field (see issue #4691).
+                const field = parent;
+                if (field.kind === kinds.Kind.FIELD &&
+                    field.directives &&
+                    field.directives.some((d) => d.name.value === "export")) {
+                    return;
+                }
+                // Create and return a new SelectionSet with a __typename Field.
+                return {
+                    ...node,
+                    selections: [...selections, TYPENAME_FIELD],
+                };
+            },
+        },
+    });
+}, {
+    added(field) {
+        return field === TYPENAME_FIELD;
+    },
+});
+
+exports.addTypenameToDocument = addTypenameToDocument;
+//# sourceMappingURL=transform.cjs.map

package/dist/cjs/node_modules/@apollo/client/utilities/graphql/transform.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.cjs","sources":["../../../../../../../node_modules/@apollo/client/utilities/graphql/transform.js"],"sourcesContent":["import { Kind, visit } from \"graphql\";\nconst TYPENAME_FIELD = {\n    kind: Kind.FIELD,\n    name: {\n        kind: Kind.NAME,\n        value: \"__typename\",\n    },\n};\n/**\n * Adds `__typename` to all selection sets in the document except for the root\n * selection set.\n *\n * @param doc - The `ASTNode` to add `__typename` to\n *\n * @example\n *\n * ```ts\n * const document = gql`\n *   # ...\n * `;\n *\n * const withTypename = addTypenameToDocument(document);\n * ```\n */\nexport const addTypenameToDocument = Object.assign(function (doc) {\n    return visit(doc, {\n        SelectionSet: {\n            enter(node, _key, parent) {\n                // Don't add __typename to OperationDefinitions.\n                if (parent &&\n                    parent.kind ===\n                        Kind.OPERATION_DEFINITION) {\n                    return;\n                }\n                // No changes if no selections.\n                const { selections } = node;\n                if (!selections) {\n                    return;\n                }\n                // If selections already have a __typename, or are part of an\n                // introspection query, do nothing.\n                const skip = selections.some((selection) => {\n                    return (selection.kind === Kind.FIELD &&\n                        (selection.name.value === \"__typename\" ||\n                            selection.name.value.lastIndexOf(\"__\", 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                // If this SelectionSet is @export-ed as an input variable, it should\n                // not have a __typename field (see issue #4691).\n                const field = parent;\n                if (field.kind === Kind.FIELD &&\n                    field.directives &&\n                    field.directives.some((d) => d.name.value === \"export\")) {\n                    return;\n                }\n                // Create and return a new SelectionSet with a __typename Field.\n                return {\n                    ...node,\n                    selections: [...selections, TYPENAME_FIELD],\n                };\n            },\n        },\n    });\n}, {\n    added(field) {\n        return field === TYPENAME_FIELD;\n    },\n});\n//# sourceMappingURL=transform.js.map"],"names":["Kind","visit"],"mappings":";;;;;AACA,MAAM,cAAc,GAAG;AACvB,IAAI,IAAI,EAAEA,UAAI,CAAC,KAAK;AACpB,IAAI,IAAI,EAAE;AACV,QAAQ,IAAI,EAAEA,UAAI,CAAC,IAAI;AACvB,QAAQ,KAAK,EAAE,YAAY;AAC3B,KAAK;AACL,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,GAAG,EAAE;AAClE,IAAI,OAAOC,aAAK,CAAC,GAAG,EAAE;AACtB,QAAQ,YAAY,EAAE;AACtB,YAAY,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE;AACtC;AACA,gBAAgB,IAAI,MAAM;AAC1B,oBAAoB,MAAM,CAAC,IAAI;AAC/B,wBAAwBD,UAAI,CAAC,oBAAoB,EAAE;AACnD,oBAAoB;AACpB,gBAAgB;AAChB;AACA,gBAAgB,MAAM,EAAE,UAAU,EAAE,GAAG,IAAI;AAC3C,gBAAgB,IAAI,CAAC,UAAU,EAAE;AACjC,oBAAoB;AACpB,gBAAgB;AAChB;AACA;AACA,gBAAgB,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,KAAK;AAC5D,oBAAoB,QAAQ,SAAS,CAAC,IAAI,KAAKA,UAAI,CAAC,KAAK;AACzD,yBAAyB,SAAS,CAAC,IAAI,CAAC,KAAK,KAAK,YAAY;AAC9D,4BAA4B,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;AAC5E,gBAAgB,CAAC,CAAC;AAClB,gBAAgB,IAAI,IAAI,EAAE;AAC1B,oBAAoB;AACpB,gBAAgB;AAChB;AACA;AACA,gBAAgB,MAAM,KAAK,GAAG,MAAM;AACpC,gBAAgB,IAAI,KAAK,CAAC,IAAI,KAAKA,UAAI,CAAC,KAAK;AAC7C,oBAAoB,KAAK,CAAC,UAAU;AACpC,oBAAoB,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,KAAK,QAAQ,CAAC,EAAE;AAC7E,oBAAoB;AACpB,gBAAgB;AAChB;AACA,gBAAgB,OAAO;AACvB,oBAAoB,GAAG,IAAI;AAC3B,oBAAoB,UAAU,EAAE,CAAC,GAAG,UAAU,EAAE,cAAc,CAAC;AAC/D,iBAAiB;AACjB,YAAY,CAAC;AACb,SAAS;AACT,KAAK,CAAC;AACN,CAAC,EAAE;AACH,IAAI,KAAK,CAAC,KAAK,EAAE;AACjB,QAAQ,OAAO,KAAK,KAAK,cAAc;AACvC,IAAI,CAAC;AACL,CAAC;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@apollo/client/utilities/internal/DeepMerger.cjs

@@ -0,0 +1,100 @@
+'use strict';
+
+var isNonNullObject = require('./isNonNullObject.cjs');
+
+const { hasOwnProperty } = Object.prototype;
+const defaultReconciler = function (target, source, property) {
+    return this.merge(target[property], source[property]);
+};
+const objForKey = (key) => {
+    return isNaN(+key) ? {} : [];
+};
+/**
+* @internal
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+class DeepMerger {
+    options;
+    reconciler;
+    constructor(options = {}) {
+        this.options = options;
+        this.reconciler = options.reconciler || defaultReconciler;
+    }
+    merge(target, source, mergeOptions = {}) {
+        const atPath = mergeOptions.atPath;
+        if (atPath?.length) {
+            const [head, ...tail] = atPath;
+            if (target === undefined) {
+                target = objForKey(head);
+            }
+            let nestedTarget = target[head];
+            if (nestedTarget === undefined && tail.length) {
+                nestedTarget = objForKey(tail[0]);
+            }
+            const nestedSource = this.merge(nestedTarget, source, {
+                ...mergeOptions,
+                atPath: tail,
+            });
+            if (nestedTarget !== nestedSource) {
+                target = this.shallowCopyForMerge(target);
+                target[head] = nestedSource;
+            }
+            return target;
+        }
+        if (Array.isArray(target) &&
+            Array.isArray(source) &&
+            this.options.arrayMerge === "truncate" &&
+            target.length > source.length) {
+            target = target.slice(0, source.length);
+            this.pastCopies.add(target);
+        }
+        if (isNonNullObject.isNonNullObject(source) && isNonNullObject.isNonNullObject(target)) {
+            Object.keys(source).forEach((sourceKey) => {
+                if (hasOwnProperty.call(target, sourceKey)) {
+                    const targetValue = target[sourceKey];
+                    if (source[sourceKey] !== targetValue) {
+                        const result = this.reconciler(target, source, sourceKey);
+                        // A well-implemented reconciler may return targetValue to indicate
+                        // the merge changed nothing about the structure of the target.
+                        if (result !== targetValue) {
+                            target = this.shallowCopyForMerge(target);
+                            target[sourceKey] = result;
+                        }
+                    }
+                }
+                else {
+                    // If there is no collision, the target can safely share memory with
+                    // the source, and the recursion can terminate here.
+                    target = this.shallowCopyForMerge(target);
+                    target[sourceKey] = source[sourceKey];
+                }
+            });
+            return target;
+        }
+        // If source (or target) is not an object, let source replace target.
+        return source;
+    }
+    isObject = isNonNullObject.isNonNullObject;
+    pastCopies = new Set();
+    shallowCopyForMerge(value) {
+        if (isNonNullObject.isNonNullObject(value)) {
+            if (!this.pastCopies.has(value)) {
+                if (Array.isArray(value)) {
+                    value = value.slice(0);
+                }
+                else {
+                    value = {
+                        __proto__: Object.getPrototypeOf(value),
+                        ...value,
+                    };
+                }
+                this.pastCopies.add(value);
+            }
+        }
+        return value;
+    }
+}
+
+exports.DeepMerger = DeepMerger;
+//# sourceMappingURL=DeepMerger.cjs.map

package/dist/cjs/node_modules/@apollo/client/utilities/internal/DeepMerger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeepMerger.cjs","sources":["../../../../../../../node_modules/@apollo/client/utilities/internal/DeepMerger.js"],"sourcesContent":["import { isNonNullObject } from \"./isNonNullObject.js\";\nconst { hasOwnProperty } = Object.prototype;\nconst defaultReconciler = function (target, source, property) {\n    return this.merge(target[property], source[property]);\n};\nconst objForKey = (key) => {\n    return isNaN(+key) ? {} : [];\n};\n/**\n* @internal\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport class DeepMerger {\n    options;\n    reconciler;\n    constructor(options = {}) {\n        this.options = options;\n        this.reconciler = options.reconciler || defaultReconciler;\n    }\n    merge(target, source, mergeOptions = {}) {\n        const atPath = mergeOptions.atPath;\n        if (atPath?.length) {\n            const [head, ...tail] = atPath;\n            if (target === undefined) {\n                target = objForKey(head);\n            }\n            let nestedTarget = target[head];\n            if (nestedTarget === undefined && tail.length) {\n                nestedTarget = objForKey(tail[0]);\n            }\n            const nestedSource = this.merge(nestedTarget, source, {\n                ...mergeOptions,\n                atPath: tail,\n            });\n            if (nestedTarget !== nestedSource) {\n                target = this.shallowCopyForMerge(target);\n                target[head] = nestedSource;\n            }\n            return target;\n        }\n        if (Array.isArray(target) &&\n            Array.isArray(source) &&\n            this.options.arrayMerge === \"truncate\" &&\n            target.length > source.length) {\n            target = target.slice(0, source.length);\n            this.pastCopies.add(target);\n        }\n        if (isNonNullObject(source) && isNonNullObject(target)) {\n            Object.keys(source).forEach((sourceKey) => {\n                if (hasOwnProperty.call(target, sourceKey)) {\n                    const targetValue = target[sourceKey];\n                    if (source[sourceKey] !== targetValue) {\n                        const result = this.reconciler(target, source, sourceKey);\n                        // A well-implemented reconciler may return targetValue to indicate\n                        // the merge changed nothing about the structure of the target.\n                        if (result !== targetValue) {\n                            target = this.shallowCopyForMerge(target);\n                            target[sourceKey] = result;\n                        }\n                    }\n                }\n                else {\n                    // If there is no collision, the target can safely share memory with\n                    // the source, and the recursion can terminate here.\n                    target = this.shallowCopyForMerge(target);\n                    target[sourceKey] = source[sourceKey];\n                }\n            });\n            return target;\n        }\n        // If source (or target) is not an object, let source replace target.\n        return source;\n    }\n    isObject = isNonNullObject;\n    pastCopies = new Set();\n    shallowCopyForMerge(value) {\n        if (isNonNullObject(value)) {\n            if (!this.pastCopies.has(value)) {\n                if (Array.isArray(value)) {\n                    value = value.slice(0);\n                }\n                else {\n                    value = {\n                        __proto__: Object.getPrototypeOf(value),\n                        ...value,\n                    };\n                }\n                this.pastCopies.add(value);\n            }\n        }\n        return value;\n    }\n}\n//# sourceMappingURL=DeepMerger.js.map\n"],"names":["isNonNullObject"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@apollo/client/utilities/internal/argumentsObjectFromField.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var valueToObjectRepresentation = require('./valueToObjectRepresentation.cjs');
+
+/**
+* @internal
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+function argumentsObjectFromField(field, variables) {
+    if (field.arguments && field.arguments.length) {
+        const argObj = {};
+        field.arguments.forEach(({ name, value }) => valueToObjectRepresentation.valueToObjectRepresentation(argObj, name, value, variables));
+        return argObj;
+    }
+    return null;
+}
+
+exports.argumentsObjectFromField = argumentsObjectFromField;
+//# sourceMappingURL=argumentsObjectFromField.cjs.map

package/dist/cjs/node_modules/@apollo/client/utilities/internal/argumentsObjectFromField.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"argumentsObjectFromField.cjs","sources":["../../../../../../../node_modules/@apollo/client/utilities/internal/argumentsObjectFromField.js"],"sourcesContent":["import { valueToObjectRepresentation } from \"./valueToObjectRepresentation.js\";\n/**\n* @internal\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport function argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        const argObj = {};\n        field.arguments.forEach(({ name, value }) => valueToObjectRepresentation(argObj, name, value, variables));\n        return argObj;\n    }\n    return null;\n}\n//# sourceMappingURL=argumentsObjectFromField.js.map\n"],"names":["valueToObjectRepresentation"],"mappings":";;;;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,wBAAwB,CAAC,KAAK,EAAE,SAAS,EAAE;AAC3D,IAAI,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE;AACnD,QAAQ,MAAM,MAAM,GAAG,EAAE;AACzB,QAAQ,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAKA,uDAA2B,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;AACjH,QAAQ,OAAO,MAAM;AACrB,IAAI;AACJ,IAAI,OAAO,IAAI;AACf;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@apollo/client/utilities/internal/bindCacheKey.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var index = require('../../../../optimism/lib/index.cjs');
+
+/**
+ * A variant of `optimism`'s `defaultMakeCacheKey` function that allows us to
+ * pre-bind some arguments to be part of the cache key Trie path.
+ *
+ * This should always be used in place of `defaultMakeCacheKey` to bind
+ * the `this` context of classes owning wrapped functions, to ensure that
+ * the cache keys are collected from memory when the owning object is garbage collected.
+ *
+ * Without this, cache keys can stay in memory indefinitely, even though the owning
+ * Apollo Client instance is long gone.
+ * This is a risk in long-running processes with `[DocumentNode, string, string]`
+ * style cache keys with persistent document nodes.
+ */
+function bindCacheKey(...prebound) {
+    return index.defaultMakeCacheKey.bind(null, ...prebound);
+}
+
+exports.bindCacheKey = bindCacheKey;
+//# sourceMappingURL=bindCacheKey.cjs.map

package/dist/cjs/node_modules/@apollo/client/utilities/internal/bindCacheKey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindCacheKey.cjs","sources":["../../../../../../../node_modules/@apollo/client/utilities/internal/bindCacheKey.js"],"sourcesContent":["import { defaultMakeCacheKey } from \"optimism\";\n/**\n * A variant of `optimism`'s `defaultMakeCacheKey` function that allows us to\n * pre-bind some arguments to be part of the cache key Trie path.\n *\n * This should always be used in place of `defaultMakeCacheKey` to bind\n * the `this` context of classes owning wrapped functions, to ensure that\n * the cache keys are collected from memory when the owning object is garbage collected.\n *\n * Without this, cache keys can stay in memory indefinitely, even though the owning\n * Apollo Client instance is long gone.\n * This is a risk in long-running processes with `[DocumentNode, string, string]`\n * style cache keys with persistent document nodes.\n */\nexport function bindCacheKey(...prebound) {\n    return defaultMakeCacheKey.bind(null, ...prebound);\n}\n//# sourceMappingURL=bindCacheKey.js.map"],"names":["defaultMakeCacheKey"],"mappings":";;;;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,YAAY,CAAC,GAAG,QAAQ,EAAE;AAC1C,IAAI,OAAOA,yBAAmB,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,QAAQ,CAAC;AACtD;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@apollo/client/utilities/internal/caches.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+var weak = require('../../../../@wry/caches/lib/weak.cjs');
+var strong = require('../../../../@wry/caches/lib/strong.cjs');
+
+const scheduledCleanup = new WeakSet();
+function schedule(cache) {
+    if (cache.size <= (cache.max || -1)) {
+        return;
+    }
+    if (!scheduledCleanup.has(cache)) {
+        scheduledCleanup.add(cache);
+        setTimeout(() => {
+            cache.clean();
+            scheduledCleanup.delete(cache);
+        }, 100);
+    }
+}
+/**
+* @internal
+* A version of WeakCache that will auto-schedule a cleanup of the cache when
+* a new item is added and the cache reached maximum size.
+* Throttled to once per 100ms.
+*
+* @privateRemarks
+* Should be used throughout the rest of the codebase instead of WeakCache,
+* with the notable exception of usage in `wrap` from `optimism` - that one
+* already handles cleanup and should remain a `WeakCache`.
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+const AutoCleanedWeakCache = function (max, dispose) {
+    /*
+    Some builds of `WeakCache` are function prototypes, some are classes.
+    This library still builds with an ES5 target, so we can't extend the
+    real classes.
+    Instead, we have to use this workaround until we switch to a newer build
+    target.
+    */
+    const cache = new weak.WeakCache(max, dispose);
+    cache.set = function (key, value) {
+        const ret = weak.WeakCache.prototype.set.call(this, key, value);
+        schedule(this);
+        return ret;
+    };
+    return cache;
+};
+/**
+* @internal
+* A version of StrongCache that will auto-schedule a cleanup of the cache when
+* a new item is added and the cache reached maximum size.
+* Throttled to once per 100ms.
+*
+* @privateRemarks
+* Should be used throughout the rest of the codebase instead of StrongCache,
+* with the notable exception of usage in `wrap` from `optimism` - that one
+* already handles cleanup and should remain a `StrongCache`.
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+const AutoCleanedStrongCache = function (max, dispose) {
+    /*
+    Some builds of `StrongCache` are function prototypes, some are classes.
+    This library still builds with an ES5 target, so we can't extend the
+    real classes.
+    Instead, we have to use this workaround until we switch to a newer build
+    target.
+    */
+    const cache = new strong.StrongCache(max, dispose);
+    cache.set = function (key, value) {
+        const ret = strong.StrongCache.prototype.set.call(this, key, value);
+        schedule(this);
+        return ret;
+    };
+    return cache;
+};
+
+exports.AutoCleanedStrongCache = AutoCleanedStrongCache;
+exports.AutoCleanedWeakCache = AutoCleanedWeakCache;
+//# sourceMappingURL=caches.cjs.map

package/dist/cjs/node_modules/@apollo/client/utilities/internal/caches.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"caches.cjs","sources":["../../../../../../../node_modules/@apollo/client/utilities/internal/caches.js"],"sourcesContent":["import { StrongCache, WeakCache } from \"@wry/caches\";\nconst scheduledCleanup = new WeakSet();\nfunction schedule(cache) {\n    if (cache.size <= (cache.max || -1)) {\n        return;\n    }\n    if (!scheduledCleanup.has(cache)) {\n        scheduledCleanup.add(cache);\n        setTimeout(() => {\n            cache.clean();\n            scheduledCleanup.delete(cache);\n        }, 100);\n    }\n}\n/**\n* @internal\n* A version of WeakCache that will auto-schedule a cleanup of the cache when\n* a new item is added and the cache reached maximum size.\n* Throttled to once per 100ms.\n*\n* @privateRemarks\n* Should be used throughout the rest of the codebase instead of WeakCache,\n* with the notable exception of usage in `wrap` from `optimism` - that one\n* already handles cleanup and should remain a `WeakCache`.\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport const AutoCleanedWeakCache = function (max, dispose) {\n    /*\n    Some builds of `WeakCache` are function prototypes, some are classes.\n    This library still builds with an ES5 target, so we can't extend the\n    real classes.\n    Instead, we have to use this workaround until we switch to a newer build\n    target.\n    */\n    const cache = new WeakCache(max, dispose);\n    cache.set = function (key, value) {\n        const ret = WeakCache.prototype.set.call(this, key, value);\n        schedule(this);\n        return ret;\n    };\n    return cache;\n};\n/**\n* @internal\n* A version of StrongCache that will auto-schedule a cleanup of the cache when\n* a new item is added and the cache reached maximum size.\n* Throttled to once per 100ms.\n*\n* @privateRemarks\n* Should be used throughout the rest of the codebase instead of StrongCache,\n* with the notable exception of usage in `wrap` from `optimism` - that one\n* already handles cleanup and should remain a `StrongCache`.\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport const AutoCleanedStrongCache = function (max, dispose) {\n    /*\n    Some builds of `StrongCache` are function prototypes, some are classes.\n    This library still builds with an ES5 target, so we can't extend the\n    real classes.\n    Instead, we have to use this workaround until we switch to a newer build\n    target.\n    */\n    const cache = new StrongCache(max, dispose);\n    cache.set = function (key, value) {\n        const ret = StrongCache.prototype.set.call(this, key, value);\n        schedule(this);\n        return ret;\n    };\n    return cache;\n};\n//# sourceMappingURL=caches.js.map\n"],"names":["WeakCache","StrongCache"],"mappings":";;;;;AACA,MAAM,gBAAgB,GAAG,IAAI,OAAO,EAAE;AACtC,SAAS,QAAQ,CAAC,KAAK,EAAE;AACzB,IAAI,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE;AACzC,QAAQ;AACR,IAAI;AACJ,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;AACtC,QAAQ,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC;AACnC,QAAQ,UAAU,CAAC,MAAM;AACzB,YAAY,KAAK,CAAC,KAAK,EAAE;AACzB,YAAY,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC;AAC1C,QAAQ,CAAC,EAAE,GAAG,CAAC;AACf,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,UAAU,GAAG,EAAE,OAAO,EAAE;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,MAAM,KAAK,GAAG,IAAIA,cAAS,CAAC,GAAG,EAAE,OAAO,CAAC;AAC7C,IAAI,KAAK,CAAC,GAAG,GAAG,UAAU,GAAG,EAAE,KAAK,EAAE;AACtC,QAAQ,MAAM,GAAG,GAAGA,cAAS,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC;AAClE,QAAQ,QAAQ,CAAC,IAAI,CAAC;AACtB,QAAQ,OAAO,GAAG;AAClB,IAAI,CAAC;AACL,IAAI,OAAO,KAAK;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,UAAU,GAAG,EAAE,OAAO,EAAE;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,MAAM,KAAK,GAAG,IAAIC,kBAAW,CAAC,GAAG,EAAE,OAAO,CAAC;AAC/C,IAAI,KAAK,CAAC,GAAG,GAAG,UAAU,GAAG,EAAE,KAAK,EAAE;AACtC,QAAQ,MAAM,GAAG,GAAGA,kBAAW,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC;AACpE,QAAQ,QAAQ,CAAC,IAAI,CAAC;AACtB,QAAQ,OAAO,GAAG;AAClB,IAAI,CAAC;AACL,IAAI,OAAO,KAAK;AAChB;;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@apollo/client/utilities/internal/caches.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var weak = require('../../../../@wry/caches/lib/weak.js');
+
+const scheduledCleanup = new WeakSet();
+function schedule(cache) {
+    if (cache.size <= (cache.max || -1)) {
+        return;
+    }
+    if (!scheduledCleanup.has(cache)) {
+        scheduledCleanup.add(cache);
+        setTimeout(() => {
+            cache.clean();
+            scheduledCleanup.delete(cache);
+        }, 100);
+    }
+}
+/**
+* @internal
+* A version of WeakCache that will auto-schedule a cleanup of the cache when
+* a new item is added and the cache reached maximum size.
+* Throttled to once per 100ms.
+*
+* @privateRemarks
+* Should be used throughout the rest of the codebase instead of WeakCache,
+* with the notable exception of usage in `wrap` from `optimism` - that one
+* already handles cleanup and should remain a `WeakCache`.
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+const AutoCleanedWeakCache = function (max, dispose) {
+    /*
+    Some builds of `WeakCache` are function prototypes, some are classes.
+    This library still builds with an ES5 target, so we can't extend the
+    real classes.
+    Instead, we have to use this workaround until we switch to a newer build
+    target.
+    */
+    const cache = new weak.WeakCache(max, dispose);
+    cache.set = function (key, value) {
+        const ret = weak.WeakCache.prototype.set.call(this, key, value);
+        schedule(this);
+        return ret;
+    };
+    return cache;
+};
+
+exports.AutoCleanedWeakCache = AutoCleanedWeakCache;
+//# sourceMappingURL=caches.js.map

package/dist/cjs/node_modules/@apollo/client/utilities/internal/caches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"caches.js","sources":["../../../../../../../node_modules/@apollo/client/utilities/internal/caches.js"],"sourcesContent":["import { StrongCache, WeakCache } from \"@wry/caches\";\nconst scheduledCleanup = new WeakSet();\nfunction schedule(cache) {\n    if (cache.size <= (cache.max || -1)) {\n        return;\n    }\n    if (!scheduledCleanup.has(cache)) {\n        scheduledCleanup.add(cache);\n        setTimeout(() => {\n            cache.clean();\n            scheduledCleanup.delete(cache);\n        }, 100);\n    }\n}\n/**\n* @internal\n* A version of WeakCache that will auto-schedule a cleanup of the cache when\n* a new item is added and the cache reached maximum size.\n* Throttled to once per 100ms.\n*\n* @privateRemarks\n* Should be used throughout the rest of the codebase instead of WeakCache,\n* with the notable exception of usage in `wrap` from `optimism` - that one\n* already handles cleanup and should remain a `WeakCache`.\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport const AutoCleanedWeakCache = function (max, dispose) {\n    /*\n    Some builds of `WeakCache` are function prototypes, some are classes.\n    This library still builds with an ES5 target, so we can't extend the\n    real classes.\n    Instead, we have to use this workaround until we switch to a newer build\n    target.\n    */\n    const cache = new WeakCache(max, dispose);\n    cache.set = function (key, value) {\n        const ret = WeakCache.prototype.set.call(this, key, value);\n        schedule(this);\n        return ret;\n    };\n    return cache;\n};\n/**\n* @internal\n* A version of StrongCache that will auto-schedule a cleanup of the cache when\n* a new item is added and the cache reached maximum size.\n* Throttled to once per 100ms.\n*\n* @privateRemarks\n* Should be used throughout the rest of the codebase instead of StrongCache,\n* with the notable exception of usage in `wrap` from `optimism` - that one\n* already handles cleanup and should remain a `StrongCache`.\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport const AutoCleanedStrongCache = function (max, dispose) {\n    /*\n    Some builds of `StrongCache` are function prototypes, some are classes.\n    This library still builds with an ES5 target, so we can't extend the\n    real classes.\n    Instead, we have to use this workaround until we switch to a newer build\n    target.\n    */\n    const cache = new StrongCache(max, dispose);\n    cache.set = function (key, value) {\n        const ret = StrongCache.prototype.set.call(this, key, value);\n        schedule(this);\n        return ret;\n    };\n    return cache;\n};\n//# sourceMappingURL=caches.js.map\n"],"names":["WeakCache"],"mappings":";;;;AACA,MAAM,gBAAgB,GAAG,IAAI,OAAO,EAAE;AACtC,SAAS,QAAQ,CAAC,KAAK,EAAE;AACzB,IAAI,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE;AACzC,QAAQ;AACR,IAAI;AACJ,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;AACtC,QAAQ,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC;AACnC,QAAQ,UAAU,CAAC,MAAM;AACzB,YAAY,KAAK,CAAC,KAAK,EAAE;AACzB,YAAY,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC;AAC1C,QAAQ,CAAC,EAAE,GAAG,CAAC;AACf,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,UAAU,GAAG,EAAE,OAAO,EAAE;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,MAAM,KAAK,GAAG,IAAIA,cAAS,CAAC,GAAG,EAAE,OAAO,CAAC;AAC7C,IAAI,KAAK,CAAC,GAAG,GAAG,UAAU,GAAG,EAAE,KAAK,EAAE;AACtC,QAAQ,MAAM,GAAG,GAAGA,cAAS,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC;AAClE,QAAQ,QAAQ,CAAC,IAAI,CAAC;AACtB,QAAQ,OAAO,GAAG;AAClB,IAAI,CAAC;AACL,IAAI,OAAO,KAAK;AAChB;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@apollo/client/utilities/internal/canonicalStringify.cjs

@@ -0,0 +1,109 @@
+'use strict';
+
+var sizes = require('../caching/sizes.cjs');
+var caches = require('./caches.cjs');
+
+/**
+ * Serializes a value to JSON with object keys in a consistent, sorted order.
+ *
+ * @remarks
+ *
+ * Unlike `JSON.stringify()`, this function ensures that object keys are always
+ * serialized in the same alphabetical order, regardless of their original order.
+ * This makes it suitable for creating consistent cache keys from objects,
+ * comparing objects by their serialized representation, or generating
+ * deterministic hashes of objects.
+ *
+ * To achieve performant sorting, this function uses a `Map` from JSON-serialized
+ * arrays of keys (in any order) to sorted arrays of the same keys, with a
+ * single sorted array reference shared by all permutations of the keys.
+ *
+ * As a drawback, this function will add a little more memory for every object
+ * encountered that has different (more, less, a different order of) keys than
+ * in the past.
+ *
+ * In a typical application, this extra memory usage should not play a
+ * significant role, as `canonicalStringify` will be called for only a limited
+ * number of object shapes, and the cache will not grow beyond a certain point.
+ * But in some edge cases, this could be a problem. Use canonicalStringify.reset()
+ * as a way to clear the memoization cache.
+ *
+ * @param value - The value to stringify
+ * @returns JSON string with consistently ordered object keys
+ *
+ * @example
+ *
+ * ```ts
+ * import { canonicalStringify } from "@apollo/client/utilities";
+ *
+ * const obj1 = { b: 2, a: 1 };
+ * const obj2 = { a: 1, b: 2 };
+ *
+ * console.log(canonicalStringify(obj1)); // '{"a":1,"b":2}'
+ * console.log(canonicalStringify(obj2)); // '{"a":1,"b":2}'
+ * ```
+ */
+const canonicalStringify = Object.assign(function canonicalStringify(value) {
+    return JSON.stringify(value, stableObjectReplacer);
+}, {
+    reset() {
+        // Clearing the sortingMap will reclaim all cached memory, without
+        // affecting the logical results of canonicalStringify, but potentially
+        // sacrificing performance until the cache is refilled.
+        sortingMap = new caches.AutoCleanedStrongCache(sizes.cacheSizes.canonicalStringify || 1000 /* defaultCacheSizes.canonicalStringify */);
+    },
+});
+// Values are JSON-serialized arrays of object keys (in any order), and values
+// are sorted arrays of the same keys.
+let sortingMap;
+canonicalStringify.reset();
+// The JSON.stringify function takes an optional second argument called a
+// replacer function. This function is called for each key-value pair in the
+// object being stringified, and its return value is used instead of the
+// original value. If the replacer function returns a new value, that value is
+// stringified as JSON instead of the original value of the property.
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#the_replacer_parameter
+function stableObjectReplacer(key, value) {
+    if (value && typeof value === "object") {
+        const proto = Object.getPrototypeOf(value);
+        // We don't want to mess with objects that are not "plain" objects, which
+        // means their prototype is either Object.prototype or null. This check also
+        // prevents needlessly rearranging the indices of arrays.
+        if (proto === Object.prototype || proto === null) {
+            const keys = Object.keys(value);
+            // If keys is already sorted, let JSON.stringify serialize the original
+            // value instead of creating a new object with keys in the same order.
+            if (keys.every(everyKeyInOrder))
+                return value;
+            const unsortedKey = JSON.stringify(keys);
+            let sortedKeys = sortingMap.get(unsortedKey);
+            if (!sortedKeys) {
+                keys.sort();
+                const sortedKey = JSON.stringify(keys);
+                // Checking for sortedKey in the sortingMap allows us to share the same
+                // sorted array reference for all permutations of the same set of keys.
+                sortedKeys = sortingMap.get(sortedKey) || keys;
+                sortingMap.set(unsortedKey, sortedKeys);
+                sortingMap.set(sortedKey, sortedKeys);
+            }
+            const sortedObject = Object.create(proto);
+            // Reassigning the keys in sorted order will cause JSON.stringify to
+            // serialize them in sorted order.
+            sortedKeys.forEach((key) => {
+                sortedObject[key] = value[key];
+            });
+            return sortedObject;
+        }
+    }
+    return value;
+}
+// Since everything that happens in stableObjectReplacer benefits from being as
+// efficient as possible, we use a static function as the callback for
+// keys.every in order to test if the provided keys are already sorted without
+// allocating extra memory for a callback.
+function everyKeyInOrder(key, i, keys) {
+    return i === 0 || keys[i - 1] <= key;
+}
+
+exports.canonicalStringify = canonicalStringify;
+//# sourceMappingURL=canonicalStringify.cjs.map

package/dist/cjs/node_modules/@apollo/client/utilities/internal/canonicalStringify.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalStringify.cjs","sources":["../../../../../../../node_modules/@apollo/client/utilities/internal/canonicalStringify.js"],"sourcesContent":["import { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { cacheSizes } from \"../caching/sizes.js\";\nimport { AutoCleanedStrongCache } from \"./caches.js\";\nimport { registerGlobalCache } from \"./getMemoryInternals.js\";\n/**\n * Serializes a value to JSON with object keys in a consistent, sorted order.\n *\n * @remarks\n *\n * Unlike `JSON.stringify()`, this function ensures that object keys are always\n * serialized in the same alphabetical order, regardless of their original order.\n * This makes it suitable for creating consistent cache keys from objects,\n * comparing objects by their serialized representation, or generating\n * deterministic hashes of objects.\n *\n * To achieve performant sorting, this function uses a `Map` from JSON-serialized\n * arrays of keys (in any order) to sorted arrays of the same keys, with a\n * single sorted array reference shared by all permutations of the keys.\n *\n * As a drawback, this function will add a little more memory for every object\n * encountered that has different (more, less, a different order of) keys than\n * in the past.\n *\n * In a typical application, this extra memory usage should not play a\n * significant role, as `canonicalStringify` will be called for only a limited\n * number of object shapes, and the cache will not grow beyond a certain point.\n * But in some edge cases, this could be a problem. Use canonicalStringify.reset()\n * as a way to clear the memoization cache.\n *\n * @param value - The value to stringify\n * @returns JSON string with consistently ordered object keys\n *\n * @example\n *\n * ```ts\n * import { canonicalStringify } from \"@apollo/client/utilities\";\n *\n * const obj1 = { b: 2, a: 1 };\n * const obj2 = { a: 1, b: 2 };\n *\n * console.log(canonicalStringify(obj1)); // '{\"a\":1,\"b\":2}'\n * console.log(canonicalStringify(obj2)); // '{\"a\":1,\"b\":2}'\n * ```\n */\nexport const canonicalStringify = Object.assign(function canonicalStringify(value) {\n    return JSON.stringify(value, stableObjectReplacer);\n}, {\n    reset() {\n        // Clearing the sortingMap will reclaim all cached memory, without\n        // affecting the logical results of canonicalStringify, but potentially\n        // sacrificing performance until the cache is refilled.\n        sortingMap = new AutoCleanedStrongCache(cacheSizes.canonicalStringify || 1000 /* defaultCacheSizes.canonicalStringify */);\n    },\n});\nif (__DEV__) {\n    registerGlobalCache(\"canonicalStringify\", () => sortingMap.size);\n}\n// Values are JSON-serialized arrays of object keys (in any order), and values\n// are sorted arrays of the same keys.\nlet sortingMap;\ncanonicalStringify.reset();\n// The JSON.stringify function takes an optional second argument called a\n// replacer function. This function is called for each key-value pair in the\n// object being stringified, and its return value is used instead of the\n// original value. If the replacer function returns a new value, that value is\n// stringified as JSON instead of the original value of the property.\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#the_replacer_parameter\nfunction stableObjectReplacer(key, value) {\n    if (value && typeof value === \"object\") {\n        const proto = Object.getPrototypeOf(value);\n        // We don't want to mess with objects that are not \"plain\" objects, which\n        // means their prototype is either Object.prototype or null. This check also\n        // prevents needlessly rearranging the indices of arrays.\n        if (proto === Object.prototype || proto === null) {\n            const keys = Object.keys(value);\n            // If keys is already sorted, let JSON.stringify serialize the original\n            // value instead of creating a new object with keys in the same order.\n            if (keys.every(everyKeyInOrder))\n                return value;\n            const unsortedKey = JSON.stringify(keys);\n            let sortedKeys = sortingMap.get(unsortedKey);\n            if (!sortedKeys) {\n                keys.sort();\n                const sortedKey = JSON.stringify(keys);\n                // Checking for sortedKey in the sortingMap allows us to share the same\n                // sorted array reference for all permutations of the same set of keys.\n                sortedKeys = sortingMap.get(sortedKey) || keys;\n                sortingMap.set(unsortedKey, sortedKeys);\n                sortingMap.set(sortedKey, sortedKeys);\n            }\n            const sortedObject = Object.create(proto);\n            // Reassigning the keys in sorted order will cause JSON.stringify to\n            // serialize them in sorted order.\n            sortedKeys.forEach((key) => {\n                sortedObject[key] = value[key];\n            });\n            return sortedObject;\n        }\n    }\n    return value;\n}\n// Since everything that happens in stableObjectReplacer benefits from being as\n// efficient as possible, we use a static function as the callback for\n// keys.every in order to test if the provided keys are already sorted without\n// allocating extra memory for a callback.\nfunction everyKeyInOrder(key, i, keys) {\n    return i === 0 || keys[i - 1] <= key;\n}\n//# sourceMappingURL=canonicalStringify.js.map"],"names":["AutoCleanedStrongCache","cacheSizes"],"mappings":";;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,kBAAkB,CAAC,KAAK,EAAE;AACnF,IAAI,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,oBAAoB,CAAC;AACtD,CAAC,EAAE;AACH,IAAI,KAAK,GAAG;AACZ;AACA;AACA;AACA,QAAQ,UAAU,GAAG,IAAIA,6BAAsB,CAACC,gBAAU,CAAC,kBAAkB,IAAI,IAAI,4CAA4C;AACjI,IAAI,CAAC;AACL,CAAC;AAID;AACA;AACA,IAAI,UAAU;AACd,kBAAkB,CAAC,KAAK,EAAE;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,oBAAoB,CAAC,GAAG,EAAE,KAAK,EAAE;AAC1C,IAAI,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AAC5C,QAAQ,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC;AAClD;AACA;AACA;AACA,QAAQ,IAAI,KAAK,KAAK,MAAM,CAAC,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE;AAC1D,YAAY,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;AAC3C;AACA;AACA,YAAY,IAAI,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC;AAC3C,gBAAgB,OAAO,KAAK;AAC5B,YAAY,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;AACpD,YAAY,IAAI,UAAU,GAAG,UAAU,CAAC,GAAG,CAAC,WAAW,CAAC;AACxD,YAAY,IAAI,CAAC,UAAU,EAAE;AAC7B,gBAAgB,IAAI,CAAC,IAAI,EAAE;AAC3B,gBAAgB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;AACtD;AACA;AACA,gBAAgB,UAAU,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,IAAI;AAC9D,gBAAgB,UAAU,CAAC,GAAG,CAAC,WAAW,EAAE,UAAU,CAAC;AACvD,gBAAgB,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,UAAU,CAAC;AACrD,YAAY;AACZ,YAAY,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;AACrD;AACA;AACA,YAAY,UAAU,CAAC,OAAO,CAAC,CAAC,GAAG,KAAK;AACxC,gBAAgB,YAAY,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC;AAC9C,YAAY,CAAC,CAAC;AACd,YAAY,OAAO,YAAY;AAC/B,QAAQ;AACR,IAAI;AACJ,IAAI,OAAO,KAAK;AAChB;AACA;AACA;AACA;AACA;AACA,SAAS,eAAe,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE;AACvC,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,GAAG;AACxC;;;;","x_google_ignoreList":[0]}

package/dist/cjs/node_modules/@apollo/client/utilities/internal/checkDocument.cjs

@@ -0,0 +1,62 @@
+'use strict';
+
+var index_production = require('../environment/index.production.cjs');
+var index = require('../invariant/index.cjs');
+var sizes = require('../caching/sizes.cjs');
+var getOperationName = require('./getOperationName.cjs');
+var memoize = require('./memoize.cjs');
+var visitor = require('../../../../graphql/language/visitor.cjs');
+var kinds = require('../../../../graphql/language/kinds.cjs');
+
+// Checks the document for errors and throws an exception if there is an error.
+/**
+* Checks the document for errors and throws an exception if there is an error.
+*
+* @internal
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+const checkDocument = memoize.memoize((doc, expectedType) => {
+    index.invariant(doc && doc.kind === "Document", 1);
+    const operations = doc.definitions.filter((d) => d.kind === "OperationDefinition");
+    if (index_production.__DEV__) ;
+    if (expectedType) {
+        index.invariant(
+            operations.length == 1 && operations[0].operation === expectedType,
+            4,
+            expectedType,
+            expectedType,
+            operations[0].operation
+        );
+    }
+    visitor.visit(doc, {
+        Field(field, _, __, path) {
+            if (field.alias &&
+                (field.alias.value === "__typename" ||
+                    field.alias.value.startsWith("__ac_")) &&
+                field.alias.value !== field.name.value) {
+                // not using `invariant` so path calculation only happens in error case
+                let current = doc, fieldPath = [];
+                for (const key of path) {
+                    current = current[key];
+                    if (current.kind === kinds.Kind.FIELD) {
+                        fieldPath.push(current.alias?.value || current.name.value);
+                    }
+                }
+                fieldPath.splice(-1, 1, field.name.value);
+                throw index.newInvariantError(
+                    5,
+                    field.alias.value,
+                    fieldPath.join("."),
+                    operations[0].operation,
+                    getOperationName.getOperationName(doc, "(anonymous)")
+                );
+            }
+        },
+    });
+}, {
+    max: sizes.cacheSizes["checkDocument"] || 2000 /* defaultCacheSizes["checkDocument"] */,
+});
+
+exports.checkDocument = checkDocument;
+//# sourceMappingURL=checkDocument.cjs.map

package/dist/cjs/node_modules/@apollo/client/utilities/internal/checkDocument.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkDocument.cjs","sources":["../../../../../../../node_modules/@apollo/client/utilities/internal/checkDocument.js"],"sourcesContent":["// Checks the document for errors and throws an exception if there is an error.\nimport { Kind, visit } from \"graphql\";\nimport { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { invariant, newInvariantError, } from \"@apollo/client/utilities/invariant\";\nimport { cacheSizes } from \"../caching/sizes.js\";\nimport { getOperationName } from \"./getOperationName.js\";\nimport { memoize } from \"./memoize.js\";\n/**\n* Checks the document for errors and throws an exception if there is an error.\n*\n* @internal\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport const checkDocument = memoize((doc, expectedType) => {\n    invariant(doc && doc.kind === \"Document\", 1);\n    const operations = doc.definitions.filter((d) => d.kind === \"OperationDefinition\");\n    if (__DEV__) {\n        doc.definitions.forEach((definition) => {\n            if (definition.kind !== \"OperationDefinition\" &&\n                definition.kind !== \"FragmentDefinition\") {\n                throw newInvariantError(2, definition.kind);\n            }\n        });\n        invariant(operations.length <= 1, 3, operations.length);\n    }\n    if (expectedType) {\n        invariant(\n            operations.length == 1 && operations[0].operation === expectedType,\n            4,\n            expectedType,\n            expectedType,\n            operations[0].operation\n        );\n    }\n    visit(doc, {\n        Field(field, _, __, path) {\n            if (field.alias &&\n                (field.alias.value === \"__typename\" ||\n                    field.alias.value.startsWith(\"__ac_\")) &&\n                field.alias.value !== field.name.value) {\n                // not using `invariant` so path calculation only happens in error case\n                let current = doc, fieldPath = [];\n                for (const key of path) {\n                    current = current[key];\n                    if (current.kind === Kind.FIELD) {\n                        fieldPath.push(current.alias?.value || current.name.value);\n                    }\n                }\n                fieldPath.splice(-1, 1, field.name.value);\n                throw newInvariantError(\n                    5,\n                    field.alias.value,\n                    fieldPath.join(\".\"),\n                    operations[0].operation,\n                    getOperationName(doc, \"(anonymous)\")\n                );\n            }\n        },\n    });\n}, {\n    max: cacheSizes[\"checkDocument\"] || 2000 /* defaultCacheSizes[\"checkDocument\"] */,\n});\n//# sourceMappingURL=checkDocument.js.map\n"],"names":["memoize","invariant","__DEV__","visit","Kind","newInvariantError","getOperationName","cacheSizes"],"mappings":";;;;;;;;;;AAAA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,aAAa,GAAGA,eAAO,CAAC,CAAC,GAAG,EAAE,YAAY,KAAK;AAC5D,IAAIC,eAAS,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC,CAAC;AAChD,IAAI,MAAM,UAAU,GAAG,GAAG,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,qBAAqB,CAAC;AACtF,IAAI,IAAIC,wBAAO,EAAE;AASjB,IAAI,IAAI,YAAY,EAAE;AACtB,QAAQD,eAAS;AACjB,YAAY,UAAU,CAAC,MAAM,IAAI,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,YAAY;AAC9E,YAAY,CAAC;AACb,YAAY,YAAY;AACxB,YAAY,YAAY;AACxB,YAAY,UAAU,CAAC,CAAC,CAAC,CAAC;AAC1B,SAAS;AACT,IAAI;AACJ,IAAIE,aAAK,CAAC,GAAG,EAAE;AACf,QAAQ,KAAK,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE;AAClC,YAAY,IAAI,KAAK,CAAC,KAAK;AAC3B,iBAAiB,KAAK,CAAC,KAAK,CAAC,KAAK,KAAK,YAAY;AACnD,oBAAoB,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AAC1D,gBAAgB,KAAK,CAAC,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE;AACxD;AACA,gBAAgB,IAAI,OAAO,GAAG,GAAG,EAAE,SAAS,GAAG,EAAE;AACjD,gBAAgB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;AACxC,oBAAoB,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC;AAC1C,oBAAoB,IAAI,OAAO,CAAC,IAAI,KAAKC,UAAI,CAAC,KAAK,EAAE;AACrD,wBAAwB,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC;AAClF,oBAAoB;AACpB,gBAAgB;AAChB,gBAAgB,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;AACzD,gBAAgB,MAAMC,uBAAiB;AACvC,oBAAoB,CAAC;AACrB,oBAAoB,KAAK,CAAC,KAAK,CAAC,KAAK;AACrC,oBAAoB,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC;AACvC,oBAAoB,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS;AAC3C,oBAAoBC,iCAAgB,CAAC,GAAG,EAAE,aAAa;AACvD,iBAAiB;AACjB,YAAY;AACZ,QAAQ,CAAC;AACT,KAAK,CAAC;AACN,CAAC,EAAE;AACH,IAAI,GAAG,EAAEC,gBAAU,CAAC,eAAe,CAAC,IAAI,IAAI;AAC5C,CAAC;;;;","x_google_ignoreList":[0]}