@adaptic/lumic-utils 1.0.8 → 1.0.10

package/dist/apollo-client.client-DE7JUXjy.js

@@ -1,3693 +0,0 @@
-import { bv as __extends, z as __assign, y as getOperationDefinition, bw as warnDeprecated, v as invariant, bx as muteDeprecations, by as equal, bz as equalByQuery, ag as getQueryDefinition, bA as warnRemovedOption, a2 as compact, a1 as cloneDeep, aH as preventUnhandledRejection, aA as iterateObserversSafely, bB as Slot, O as Observable, bC as isApolloError, bD as ApolloError, a4 as fixObservableSubclass, aj as graphQLResultHasError, Y as canUseWeakMap, H as DeepMerger, ax as isNonEmptyArray, aF as mergeIncrementalData, F as AutoCleanedWeakCache, R as cacheSizes, bE as Trie, J as DocumentTransform, x as newInvariantError, bF as __awaiter, bG as __generator, P as asyncMap, ac as getGraphQLErrorsFromResult, ar as isExecutionPatchIncrementalResult, af as getOperationName, at as isExecutionPatchResult, a5 as getDefaultValues, aM as removeDirectivesFromDocument, K as addNonReactiveToNamedFragments, an as hasDirectives, am as hasClientExports, aq as isDocumentNode, aI as print, ay as isNonNullObject, aC as makeUniqueId, $ as canonicalStringify, G as Concast, a_ as execute, av as isFullyUnmaskedOperation, be as maskOperation, bd as maskFragment, bH as graphQLResultHasProtocolErrors, bI as PROTOCOL_ERRORS_SYMBOL, A as mergeDeep, aK as removeClientSetsFromDocument, Q as buildQueryFromSelectionSet, ae as getMainDefinition, a8 as getFragmentDefinitions, a3 as createFragmentMap, aE as mergeDeepArray, aP as shouldInclude, au as isField, aO as resultKeyNameFromField, aw as isInlineFragment, bm as cacheSlot, N as argumentsObjectFromField, m as isSelectionNode, aG as mergeOptions, b0 as HttpLink, aZ as ApolloLink, bJ as version, bK as getApolloClientMemoryInternals, B as __rest } from './index-CsKfs4nG.js';
-export { bj as InMemoryCache, bL as gql, a$ as split } from './index-CsKfs4nG.js';
-import { W as visit, a8 as BREAK } from './index-Bd84zcTQ.js';
-import 'openai';
-import 'zod';
-import '@aws-sdk/client-s3';
-import '@aws-sdk/client-lambda';
-import 'axios';
-import 'fs';
-import 'path';
-import 'os';
-import 'adm-zip';
-import 'stream';
-import 'fs/promises';
-import 'crypto';
-import 'stream/promises';
-import 'node:path';
-import 'node:fs';
-import 'node:fs/promises';
-import 'graphql-fields';
-import 'date-fns';
-import 'date-fns-tz';
-import 'ms';
-import 'events';
-import 'https';
-import 'http';
-import 'net';
-import 'tls';
-import 'url';
-import 'zlib';
-import 'buffer';
-import 'readline';
-import 'assert';
-import 'tty';
-import 'util';
-import 'pdfkit';
-import 'marked';
-import 'google-auth-library';
-import 'http2';
-import 'process';
-import 'node:async_hooks';
-
-/**
- * The current status of a query’s execution in our system.
- */
-var NetworkStatus;
-(function (NetworkStatus) {
-    /**
-     * The query has never been run before and the query is now currently running. A query will still
-     * have this network status even if a partial data result was returned from the cache, but a
-     * query was dispatched anyway.
-     */
-    NetworkStatus[NetworkStatus["loading"] = 1] = "loading";
-    /**
-     * If `setVariables` was called and a query was fired because of that then the network status
-     * will be `setVariables` until the result of that query comes back.
-     */
-    NetworkStatus[NetworkStatus["setVariables"] = 2] = "setVariables";
-    /**
-     * Indicates that `fetchMore` was called on this query and that the query created is currently in
-     * flight.
-     */
-    NetworkStatus[NetworkStatus["fetchMore"] = 3] = "fetchMore";
-    /**
-     * Similar to the `setVariables` network status. It means that `refetch` was called on a query
-     * and the refetch request is currently in flight.
-     */
-    NetworkStatus[NetworkStatus["refetch"] = 4] = "refetch";
-    /**
-     * Indicates that a polling query is currently in flight. So for example if you are polling a
-     * query every 10 seconds then the network status will switch to `poll` every 10 seconds whenever
-     * a poll request has been sent but not resolved.
-     */
-    NetworkStatus[NetworkStatus["poll"] = 6] = "poll";
-    /**
-     * No request is in flight for this query, and no errors happened. Everything is OK.
-     */
-    NetworkStatus[NetworkStatus["ready"] = 7] = "ready";
-    /**
-     * No request is in flight for this query, but one or more errors were detected.
-     */
-    NetworkStatus[NetworkStatus["error"] = 8] = "error";
-})(NetworkStatus || (NetworkStatus = {}));
-/**
- * Returns true if there is currently a network request in flight according to a given network
- * status.
- */
-function isNetworkRequestInFlight(networkStatus) {
-    return networkStatus ? networkStatus < 7 : false;
-}
-
-var assign = Object.assign, hasOwnProperty$1 = Object.hasOwnProperty;
-var ObservableQuery = /** @class */ (function (_super) {
-    __extends(ObservableQuery, _super);
-    function ObservableQuery(_a) {
-        var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;
-        var _this = this;
-        var startedInactive = ObservableQuery.inactiveOnCreation.getValue();
-        _this = _super.call(this, function (observer) {
-            _this._getOrCreateQuery();
-            // Zen Observable has its own error function, so in order to log correctly
-            // we need to provide a custom error callback.
-            try {
-                var subObserver = observer._subscription._observer;
-                if (subObserver && !subObserver.error) {
-                    subObserver.error = defaultSubscriptionObserverErrorCallback;
-                }
-            }
-            catch (_a) { }
-            var first = !_this.observers.size;
-            _this.observers.add(observer);
-            // Deliver most recent error or result.
-            var last = _this.last;
-            if (last && last.error) {
-                observer.error && observer.error(last.error);
-            }
-            else if (last && last.result) {
-                observer.next && observer.next(_this.maskResult(last.result));
-            }
-            // Initiate observation of this query if it hasn't been reported to
-            // the QueryManager yet.
-            if (first) {
-                // Blindly catching here prevents unhandled promise rejections,
-                // and is safe because the ObservableQuery handles this error with
-                // this.observer.error, so we're not just swallowing the error by
-                // ignoring it here.
-                _this.reobserve().catch(function () { });
-            }
-            return function () {
-                if (_this.observers.delete(observer) && !_this.observers.size) {
-                    _this.tearDownQuery();
-                }
-            };
-        }) || this;
-        _this.observers = new Set();
-        _this.subscriptions = new Set();
-        _this.dirty = false;
-        _this._getOrCreateQuery = function () {
-            if (startedInactive) {
-                queryManager["queries"].set(_this.queryId, queryInfo);
-                startedInactive = false;
-            }
-            return _this.queryManager.getOrCreateQuery(_this.queryId);
-        };
-        // related classes
-        _this.queryInfo = queryInfo;
-        _this.queryManager = queryManager;
-        // active state
-        _this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);
-        _this.isTornDown = false;
-        _this.subscribeToMore = _this.subscribeToMore.bind(_this);
-        _this.maskResult = _this.maskResult.bind(_this);
-        var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? "cache-first" : _d;
-        var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e, 
-        // Make sure we don't store "standby" as the initialFetchPolicy.
-        _f = options.initialFetchPolicy, 
-        // Make sure we don't store "standby" as the initialFetchPolicy.
-        initialFetchPolicy = _f === void 0 ? fetchPolicy === "standby" ? defaultFetchPolicy : (fetchPolicy) : _f;
-        _this.options = __assign(__assign({}, options), { 
-            // Remember the initial options.fetchPolicy so we can revert back to this
-            // policy when variables change. This information can also be specified
-            // (or overridden) by providing options.initialFetchPolicy explicitly.
-            initialFetchPolicy: initialFetchPolicy, 
-            // This ensures this.options.fetchPolicy always has a string value, in
-            // case options.fetchPolicy was not provided.
-            fetchPolicy: fetchPolicy });
-        _this.queryId = queryInfo.queryId || queryManager.generateQueryId();
-        var opDef = getOperationDefinition(_this.query);
-        _this.queryName = opDef && opDef.name && opDef.name.value;
-        return _this;
-    }
-    Object.defineProperty(ObservableQuery.prototype, "query", {
-        // The `query` computed property will always reflect the document transformed
-        // by the last run query. `this.options.query` will always reflect the raw
-        // untransformed query to ensure document transforms with runtime conditionals
-        // are run on the original document.
-        get: function () {
-            return this.lastQuery || this.options.query;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(ObservableQuery.prototype, "variables", {
-        // Computed shorthand for this.options.variables, preserved for
-        // backwards compatibility.
-        /**
-         * An object containing the variables that were provided for the query.
-         */
-        get: function () {
-            return this.options.variables;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * @deprecated `result` will be removed in Apollo Client 4.0.
-     *
-     * **Recommended now**
-     *
-     * If you continue to need this functionality, subscribe to `ObservableQuery`
-     * to get the first value emitted from the observable, then immediately unsubscribe.
-     *
-     * **When upgrading**
-     *
-     * Use RxJS's [`firstResultFrom`](https://rxjs.dev/api/index/function/firstValueFrom) function to mimic this functionality.
-     *
-     * ```ts
-     * const result = await firstValueFrom(from(observableQuery));
-     * ```
-     */
-    ObservableQuery.prototype.result = function () {
-        var _this = this;
-        if (globalThis.__DEV__ !== false) {
-            warnDeprecated("observableQuery.result", function () {
-                globalThis.__DEV__ !== false && invariant.warn(23);
-            });
-        }
-        return new Promise(function (resolve, reject) {
-            // TODO: this code doesn’t actually make sense insofar as the observer
-            // will never exist in this.observers due how zen-observable wraps observables.
-            // https://github.com/zenparsing/zen-observable/blob/master/src/Observable.js#L169
-            var observer = {
-                next: function (result) {
-                    resolve(result);
-                    // Stop the query within the QueryManager if we can before
-                    // this function returns.
-                    //
-                    // We do this in order to prevent observers piling up within
-                    // the QueryManager. Notice that we only fully unsubscribe
-                    // from the subscription in a setTimeout(..., 0)  call. This call can
-                    // actually be handled by the browser at a much later time. If queries
-                    // are fired in the meantime, observers that should have been removed
-                    // from the QueryManager will continue to fire, causing an unnecessary
-                    // performance hit.
-                    _this.observers.delete(observer);
-                    if (!_this.observers.size) {
-                        _this.queryManager.removeQuery(_this.queryId);
-                    }
-                    setTimeout(function () {
-                        subscription.unsubscribe();
-                    }, 0);
-                },
-                error: reject,
-            };
-            var subscription = _this.subscribe(observer);
-        });
-    };
-    /** @internal */
-    ObservableQuery.prototype.resetDiff = function () {
-        this.queryInfo.resetDiff();
-    };
-    ObservableQuery.prototype.getCurrentFullResult = function (saveAsLastResult) {
-        var _this = this;
-        if (saveAsLastResult === void 0) { saveAsLastResult = true; }
-        // Use the last result as long as the variables match this.variables.
-        var lastResult = muteDeprecations("getLastResult", function () {
-            return _this.getLastResult(true);
-        });
-        var networkStatus = this.queryInfo.networkStatus ||
-            (lastResult && lastResult.networkStatus) ||
-            NetworkStatus.ready;
-        var result = __assign(__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });
-        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a;
-        if (
-        // These fetch policies should never deliver data from the cache, unless
-        // redelivering a previously delivered result.
-        skipCacheDataFor(fetchPolicy) ||
-            // If this.options.query has @client(always: true) fields, we cannot
-            // trust diff.result, since it was read from the cache without running
-            // local resolvers (and it's too late to run resolvers now, since we must
-            // return a result synchronously).
-            this.queryManager.getDocumentInfo(this.query).hasForcedResolvers) ;
-        else if (this.waitForOwnResult) {
-            // This would usually be a part of `QueryInfo.getDiff()`.
-            // which we skip in the waitForOwnResult case since we are not
-            // interested in the diff.
-            this.queryInfo["updateWatch"]();
-        }
-        else {
-            var diff = this.queryInfo.getDiff();
-            if (diff.complete || this.options.returnPartialData) {
-                result.data = diff.result;
-            }
-            if (equal(result.data, {})) {
-                result.data = void 0;
-            }
-            if (diff.complete) {
-                // Similar to setting result.partial to false, but taking advantage of the
-                // falsiness of missing fields.
-                delete result.partial;
-                // If the diff is complete, and we're using a FetchPolicy that
-                // terminates after a complete cache read, we can assume the next result
-                // we receive will have NetworkStatus.ready and !loading.
-                if (diff.complete &&
-                    result.networkStatus === NetworkStatus.loading &&
-                    (fetchPolicy === "cache-first" || fetchPolicy === "cache-only")) {
-                    result.networkStatus = NetworkStatus.ready;
-                    result.loading = false;
-                }
-            }
-            else {
-                result.partial = true;
-            }
-            // We need to check for both both `error` and `errors` field because there
-            // are cases where sometimes `error` is set, but not `errors` and
-            // vice-versa. This will be updated in the next major version when
-            // `errors` is deprecated in favor of `error`.
-            if (result.networkStatus === NetworkStatus.ready &&
-                (result.error || result.errors)) {
-                result.networkStatus = NetworkStatus.error;
-            }
-            if (globalThis.__DEV__ !== false &&
-                !diff.complete &&
-                !this.options.partialRefetch &&
-                !result.loading &&
-                !result.data &&
-                !result.error) {
-                logMissingFieldErrors(diff.missing);
-            }
-        }
-        if (saveAsLastResult) {
-            this.updateLastResult(result);
-        }
-        return result;
-    };
-    ObservableQuery.prototype.getCurrentResult = function (saveAsLastResult) {
-        if (saveAsLastResult === void 0) { saveAsLastResult = true; }
-        return this.maskResult(this.getCurrentFullResult(saveAsLastResult));
-    };
-    // Compares newResult to the snapshot we took of this.lastResult when it was
-    // first received.
-    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {
-        if (!this.last) {
-            return true;
-        }
-        var documentInfo = this.queryManager.getDocumentInfo(this.query);
-        var dataMasking = this.queryManager.dataMasking;
-        var query = dataMasking ? documentInfo.nonReactiveQuery : this.query;
-        var resultIsDifferent = dataMasking || documentInfo.hasNonreactiveDirective ?
-            !equalByQuery(query, this.last.result, newResult, this.variables)
-            : !equal(this.last.result, newResult);
-        return (resultIsDifferent || (variables && !equal(this.last.variables, variables)));
-    };
-    ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {
-        var last = this.last;
-        if (last &&
-            last[key] &&
-            (!variablesMustMatch || equal(last.variables, this.variables))) {
-            return last[key];
-        }
-    };
-    /**
-     * @deprecated `getLastResult` will be removed in Apollo Client 4.0. Please
-     * discontinue using this method.
-     */
-    ObservableQuery.prototype.getLastResult = function (variablesMustMatch) {
-        if (globalThis.__DEV__ !== false) {
-            warnDeprecated("getLastResult", function () {
-                globalThis.__DEV__ !== false && invariant.warn(24);
-            });
-        }
-        return this.getLast("result", variablesMustMatch);
-    };
-    /**
-     * @deprecated `getLastError` will be removed in Apollo Client 4.0. Please
-     * discontinue using this method.
-     */
-    ObservableQuery.prototype.getLastError = function (variablesMustMatch) {
-        if (globalThis.__DEV__ !== false) {
-            warnDeprecated("getLastError", function () {
-                globalThis.__DEV__ !== false && invariant.warn(25);
-            });
-        }
-        return this.getLast("error", variablesMustMatch);
-    };
-    /**
-     * @deprecated `resetLastResults` will be removed in Apollo Client 4.0. Please
-     * discontinue using this method.
-     */
-    ObservableQuery.prototype.resetLastResults = function () {
-        if (globalThis.__DEV__ !== false) {
-            warnDeprecated("resetLastResults", function () {
-                globalThis.__DEV__ !== false && invariant.warn(26);
-            });
-        }
-        delete this.last;
-        this.isTornDown = false;
-    };
-    /**
-     * @deprecated `resetQueryStoreErrors` will be removed in Apollo Client 4.0.
-     * Please discontinue using this method.
-     */
-    ObservableQuery.prototype.resetQueryStoreErrors = function () {
-        if (globalThis.__DEV__ !== false) {
-            globalThis.__DEV__ !== false && invariant.warn(27);
-        }
-        this.queryManager.resetErrors(this.queryId);
-    };
-    /**
-     * Update the variables of this observable query, and fetch the new results.
-     * This method should be preferred over `setVariables` in most use cases.
-     *
-     * @param variables - The new set of variables. If there are missing variables,
-     * the previous values of those variables will be used.
-     */
-    ObservableQuery.prototype.refetch = function (variables) {
-        var _a;
-        var reobserveOptions = {
-            // Always disable polling for refetches.
-            pollInterval: 0,
-        };
-        // Unless the provided fetchPolicy always consults the network
-        // (no-cache, network-only, or cache-and-network), override it with
-        // network-only to force the refetch for this fetchQuery call.
-        var fetchPolicy = this.options.fetchPolicy;
-        if (fetchPolicy === "no-cache") {
-            reobserveOptions.fetchPolicy = "no-cache";
-        }
-        else {
-            reobserveOptions.fetchPolicy = "network-only";
-        }
-        if (globalThis.__DEV__ !== false && variables && hasOwnProperty$1.call(variables, "variables")) {
-            var queryDef = getQueryDefinition(this.query);
-            var vars = queryDef.variableDefinitions;
-            if (!vars || !vars.some(function (v) { return v.variable.name.value === "variables"; })) {
-                globalThis.__DEV__ !== false && invariant.warn(
-                    28,
-                    variables,
-                    ((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || queryDef
-                );
-            }
-        }
-        if (variables && !equal(this.options.variables, variables)) {
-            // Update the existing options with new variables
-            reobserveOptions.variables = this.options.variables = __assign(__assign({}, this.options.variables), variables);
-        }
-        this.queryInfo.resetLastWrite();
-        return this.reobserve(reobserveOptions, NetworkStatus.refetch);
-    };
-    /**
-     * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).
-     */
-    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {
-        var _this = this;
-        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : (__assign(__assign(__assign(__assign({}, this.options), { query: this.options.query }), fetchMoreOptions), { variables: __assign(__assign({}, this.options.variables), fetchMoreOptions.variables) })))), { 
-            // The fetchMore request goes immediately to the network and does
-            // not automatically write its result to the cache (hence no-cache
-            // instead of network-only), because we allow the caller of
-            // fetchMore to provide an updateQuery callback that determines how
-            // the data gets written to the cache.
-            fetchPolicy: "no-cache" });
-        combinedOptions.query = this.transformDocument(combinedOptions.query);
-        var qid = this.queryManager.generateQueryId();
-        // If a temporary query is passed to `fetchMore`, we don't want to store
-        // it as the last query result since it may be an optimized query for
-        // pagination. We will however run the transforms on the original document
-        // as well as the document passed in `fetchMoreOptions` to ensure the cache
-        // uses the most up-to-date document which may rely on runtime conditionals.
-        this.lastQuery =
-            fetchMoreOptions.query ?
-                this.transformDocument(this.options.query)
-                : combinedOptions.query;
-        // Simulate a loading result for the original query with
-        // result.networkStatus === NetworkStatus.fetchMore.
-        var queryInfo = this.queryInfo;
-        var originalNetworkStatus = queryInfo.networkStatus;
-        queryInfo.networkStatus = NetworkStatus.fetchMore;
-        if (combinedOptions.notifyOnNetworkStatusChange) {
-            this.observe();
-        }
-        var updatedQuerySet = new Set();
-        var updateQuery = fetchMoreOptions === null || fetchMoreOptions === void 0 ? void 0 : fetchMoreOptions.updateQuery;
-        var isCached = this.options.fetchPolicy !== "no-cache";
-        if (!isCached) {
-            invariant(updateQuery, 29);
-        }
-        return this.queryManager
-            .fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore)
-            .then(function (fetchMoreResult) {
-            _this.queryManager.removeQuery(qid);
-            if (queryInfo.networkStatus === NetworkStatus.fetchMore) {
-                queryInfo.networkStatus = originalNetworkStatus;
-            }
-            if (isCached) {
-                // Performing this cache update inside a cache.batch transaction ensures
-                // any affected cache.watch watchers are notified at most once about any
-                // updates. Most watchers will be using the QueryInfo class, which
-                // responds to notifications by calling reobserveCacheFirst to deliver
-                // fetchMore cache results back to this ObservableQuery.
-                _this.queryManager.cache.batch({
-                    update: function (cache) {
-                        var updateQuery = fetchMoreOptions.updateQuery;
-                        if (updateQuery) {
-                            cache.updateQuery({
-                                query: _this.query,
-                                variables: _this.variables,
-                                returnPartialData: true,
-                                optimistic: false,
-                            }, function (previous) {
-                                return updateQuery(previous, {
-                                    fetchMoreResult: fetchMoreResult.data,
-                                    variables: combinedOptions.variables,
-                                });
-                            });
-                        }
-                        else {
-                            // If we're using a field policy instead of updateQuery, the only
-                            // thing we need to do is write the new data to the cache using
-                            // combinedOptions.variables (instead of this.variables, which is
-                            // what this.updateQuery uses, because it works by abusing the
-                            // original field value, keyed by the original variables).
-                            cache.writeQuery({
-                                query: combinedOptions.query,
-                                variables: combinedOptions.variables,
-                                data: fetchMoreResult.data,
-                            });
-                        }
-                    },
-                    onWatchUpdated: function (watch) {
-                        // Record the DocumentNode associated with any watched query whose
-                        // data were updated by the cache writes above.
-                        updatedQuerySet.add(watch.query);
-                    },
-                });
-            }
-            else {
-                // There is a possibility `lastResult` may not be set when
-                // `fetchMore` is called which would cause this to crash. This should
-                // only happen if we haven't previously reported a result. We don't
-                // quite know what the right behavior should be here since this block
-                // of code runs after the fetch result has executed on the network.
-                // We plan to let it crash in the meantime.
-                //
-                // If we get bug reports due to the `data` property access on
-                // undefined, this should give us a real-world scenario that we can
-                // use to test against and determine the right behavior. If we do end
-                // up changing this behavior, this may require, for example, an
-                // adjustment to the types on `updateQuery` since that function
-                // expects that the first argument always contains previous result
-                // data, but not `undefined`.
-                var lastResult = _this.getLast("result");
-                var data = updateQuery(lastResult.data, {
-                    fetchMoreResult: fetchMoreResult.data,
-                    variables: combinedOptions.variables,
-                });
-                _this.reportResult(__assign(__assign({}, lastResult), { networkStatus: originalNetworkStatus, loading: isNetworkRequestInFlight(originalNetworkStatus), data: data }), _this.variables);
-            }
-            return _this.maskResult(fetchMoreResult);
-        })
-            .finally(function () {
-            // In case the cache writes above did not generate a broadcast
-            // notification (which would have been intercepted by onWatchUpdated),
-            // likely because the written data were the same as what was already in
-            // the cache, we still want fetchMore to deliver its final loading:false
-            // result with the unchanged data.
-            if (isCached && !updatedQuerySet.has(_this.query)) {
-                _this.reobserveCacheFirst();
-            }
-        });
-    };
-    // XXX the subscription variables are separate from the query variables.
-    // if you want to update subscription variables, right now you have to do that separately,
-    // and you can only do it by stopping the subscription and then subscribing again with new variables.
-    /**
-     * A function that enables you to execute a [subscription](https://www.apollographql.com/docs/react/data/subscriptions/), usually to subscribe to specific fields that were included in the query.
-     *
-     * This function returns _another_ function that you can call to terminate the subscription.
-     */
-    ObservableQuery.prototype.subscribeToMore = function (options) {
-        var _this = this;
-        var subscription = this.queryManager
-            .startGraphQLSubscription({
-            query: options.document,
-            variables: options.variables,
-            context: options.context,
-        })
-            .subscribe({
-            next: function (subscriptionData) {
-                var updateQuery = options.updateQuery;
-                if (updateQuery) {
-                    _this.updateQuery(function (previous, updateOptions) {
-                        return updateQuery(previous, __assign({ subscriptionData: subscriptionData }, updateOptions));
-                    });
-                }
-            },
-            error: function (err) {
-                if (options.onError) {
-                    options.onError(err);
-                    return;
-                }
-                globalThis.__DEV__ !== false && invariant.error(30, err);
-            },
-        });
-        this.subscriptions.add(subscription);
-        return function () {
-            if (_this.subscriptions.delete(subscription)) {
-                subscription.unsubscribe();
-            }
-        };
-    };
-    /**
-     * @deprecated `setOptions` will be removed in Apollo Client 4.0. Please use
-     * `observableQuery.reobserve(newOptions)` instead.
-     */
-    ObservableQuery.prototype.setOptions = function (newOptions) {
-        if (globalThis.__DEV__ !== false) {
-            warnRemovedOption(newOptions, "canonizeResults", "setOptions");
-            warnDeprecated("setOptions", function () {
-                globalThis.__DEV__ !== false && invariant.warn(31);
-            });
-        }
-        return this.reobserve(newOptions);
-    };
-    ObservableQuery.prototype.silentSetOptions = function (newOptions) {
-        var mergedOptions = compact(this.options, newOptions || {});
-        assign(this.options, mergedOptions);
-    };
-    /**
-     * Update the variables of this observable query, and fetch the new results
-     * if they've changed. Most users should prefer `refetch` instead of
-     * `setVariables` in order to to be properly notified of results even when
-     * they come from the cache.
-     *
-     * Note: the `next` callback will *not* fire if the variables have not changed
-     * or if the result is coming from cache.
-     *
-     * Note: the promise will return the old results immediately if the variables
-     * have not changed.
-     *
-     * Note: the promise will return null immediately if the query is not active
-     * (there are no subscribers).
-     *
-     * @param variables - The new set of variables. If there are missing variables,
-     * the previous values of those variables will be used.
-     */
-    ObservableQuery.prototype.setVariables = function (variables) {
-        var _this = this;
-        if (equal(this.variables, variables)) {
-            // If we have no observers, then we don't actually want to make a network
-            // request. As soon as someone observes the query, the request will kick
-            // off. For now, we just store any changes. (See #1077)
-            return this.observers.size ?
-                muteDeprecations("observableQuery.result", function () { return _this.result(); })
-                : Promise.resolve();
-        }
-        this.options.variables = variables;
-        // See comment above
-        if (!this.observers.size) {
-            return Promise.resolve();
-        }
-        return this.reobserve({
-            // Reset options.fetchPolicy to its original value.
-            fetchPolicy: this.options.initialFetchPolicy,
-            variables: variables,
-        }, NetworkStatus.setVariables);
-    };
-    /**
-     * A function that enables you to update the query's cached result without executing a followup GraphQL operation.
-     *
-     * See [using updateQuery and updateFragment](https://www.apollographql.com/docs/react/caching/cache-interaction/#using-updatequery-and-updatefragment) for additional information.
-     */
-    ObservableQuery.prototype.updateQuery = function (mapFn) {
-        var queryManager = this.queryManager;
-        var _a = queryManager.cache.diff({
-            query: this.options.query,
-            variables: this.variables,
-            returnPartialData: true,
-            optimistic: false,
-        }), result = _a.result, complete = _a.complete;
-        var newResult = mapFn(result, {
-            variables: this.variables,
-            complete: !!complete,
-            previousData: result,
-        });
-        if (newResult) {
-            queryManager.cache.writeQuery({
-                query: this.options.query,
-                data: newResult,
-                variables: this.variables,
-            });
-            queryManager.broadcastQueries();
-        }
-    };
-    /**
-     * A function that instructs the query to begin re-executing at a specified interval (in milliseconds).
-     */
-    ObservableQuery.prototype.startPolling = function (pollInterval) {
-        this.options.pollInterval = pollInterval;
-        this.updatePolling();
-    };
-    /**
-     * A function that instructs the query to stop polling after a previous call to `startPolling`.
-     */
-    ObservableQuery.prototype.stopPolling = function () {
-        this.options.pollInterval = 0;
-        this.updatePolling();
-    };
-    // Update options.fetchPolicy according to options.nextFetchPolicy.
-    ObservableQuery.prototype.applyNextFetchPolicy = function (reason, 
-    // It's possible to use this method to apply options.nextFetchPolicy to
-    // options.fetchPolicy even if options !== this.options, though that happens
-    // most often when the options are temporary, used for only one request and
-    // then thrown away, so nextFetchPolicy may not end up mattering.
-    options) {
-        if (options.nextFetchPolicy) {
-            var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? "cache-first" : _a, _b = options.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? fetchPolicy : _b;
-            if (fetchPolicy === "standby") ;
-            else if (typeof options.nextFetchPolicy === "function") {
-                // When someone chooses "cache-and-network" or "network-only" as their
-                // initial FetchPolicy, they often do not want future cache updates to
-                // trigger unconditional network requests, which is what repeatedly
-                // applying the "cache-and-network" or "network-only" policies would
-                // seem to imply. Instead, when the cache reports an update after the
-                // initial network request, it may be desirable for subsequent network
-                // requests to be triggered only if the cache result is incomplete. To
-                // that end, the options.nextFetchPolicy option provides an easy way to
-                // update options.fetchPolicy after the initial network request, without
-                // having to call observableQuery.setOptions.
-                options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {
-                    reason: reason,
-                    options: options,
-                    observable: this,
-                    initialFetchPolicy: initialFetchPolicy,
-                });
-            }
-            else if (reason === "variables-changed") {
-                options.fetchPolicy = initialFetchPolicy;
-            }
-            else {
-                options.fetchPolicy = options.nextFetchPolicy;
-            }
-        }
-        return options.fetchPolicy;
-    };
-    ObservableQuery.prototype.fetch = function (options, newNetworkStatus, query) {
-        // TODO Make sure we update the networkStatus (and infer fetchVariables)
-        // before actually committing to the fetch.
-        var queryInfo = this._getOrCreateQuery();
-        queryInfo.setObservableQuery(this);
-        return this.queryManager["fetchConcastWithInfo"](queryInfo, options, newNetworkStatus, query);
-    };
-    // Turns polling on or off based on this.options.pollInterval.
-    ObservableQuery.prototype.updatePolling = function () {
-        var _this = this;
-        // Avoid polling in SSR mode
-        if (this.queryManager.ssrMode) {
-            return;
-        }
-        var _a = this, pollingInfo = _a.pollingInfo, pollInterval = _a.options.pollInterval;
-        if (!pollInterval || !this.hasObservers()) {
-            if (pollingInfo) {
-                clearTimeout(pollingInfo.timeout);
-                delete this.pollingInfo;
-            }
-            return;
-        }
-        if (pollingInfo && pollingInfo.interval === pollInterval) {
-            return;
-        }
-        invariant(pollInterval, 32);
-        var info = pollingInfo || (this.pollingInfo = {});
-        info.interval = pollInterval;
-        var maybeFetch = function () {
-            var _a, _b;
-            if (_this.pollingInfo) {
-                if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus) &&
-                    !((_b = (_a = _this.options).skipPollAttempt) === null || _b === void 0 ? void 0 : _b.call(_a))) {
-                    _this.reobserve({
-                        // Most fetchPolicy options don't make sense to use in a polling context, as
-                        // users wouldn't want to be polling the cache directly. However, network-only and
-                        // no-cache are both useful for when the user wants to control whether or not the
-                        // polled results are written to the cache.
-                        fetchPolicy: _this.options.initialFetchPolicy === "no-cache" ?
-                            "no-cache"
-                            : "network-only",
-                    }, NetworkStatus.poll).then(poll, poll);
-                }
-                else {
-                    poll();
-                }
-            }
-        };
-        var poll = function () {
-            var info = _this.pollingInfo;
-            if (info) {
-                clearTimeout(info.timeout);
-                info.timeout = setTimeout(maybeFetch, info.interval);
-            }
-        };
-        poll();
-    };
-    ObservableQuery.prototype.updateLastResult = function (newResult, variables) {
-        var _this = this;
-        if (variables === void 0) { variables = this.variables; }
-        var error = muteDeprecations("getLastError", function () {
-            return _this.getLastError();
-        });
-        // Preserve this.last.error unless the variables have changed.
-        if (error && this.last && !equal(variables, this.last.variables)) {
-            error = void 0;
-        }
-        return (this.last = __assign({ result: this.queryManager.assumeImmutableResults ?
-                newResult
-                : cloneDeep(newResult), variables: variables }, (error ? { error: error } : null)));
-    };
-    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {
-        var _this = this;
-        this.isTornDown = false;
-        var useDisposableConcast = 
-        // Refetching uses a disposable Concast to allow refetches using different
-        // options/variables, without permanently altering the options of the
-        // original ObservableQuery.
-        newNetworkStatus === NetworkStatus.refetch ||
-            // The fetchMore method does not actually call the reobserve method, but,
-            // if it did, it would definitely use a disposable Concast.
-            newNetworkStatus === NetworkStatus.fetchMore ||
-            // Polling uses a disposable Concast so the polling options (which force
-            // fetchPolicy to be "network-only" or "no-cache") won't override the original options.
-            newNetworkStatus === NetworkStatus.poll;
-        // Save the old variables, since Object.assign may modify them below.
-        var oldVariables = this.options.variables;
-        var oldFetchPolicy = this.options.fetchPolicy;
-        var mergedOptions = compact(this.options, newOptions || {});
-        var options = useDisposableConcast ?
-            // Disposable Concast fetches receive a shallow copy of this.options
-            // (merged with newOptions), leaving this.options unmodified.
-            mergedOptions
-            : assign(this.options, mergedOptions);
-        // Don't update options.query with the transformed query to avoid
-        // overwriting this.options.query when we aren't using a disposable concast.
-        // We want to ensure we can re-run the custom document transforms the next
-        // time a request is made against the original query.
-        var query = this.transformDocument(options.query);
-        this.lastQuery = query;
-        if (!useDisposableConcast) {
-            // We can skip calling updatePolling if we're not changing this.options.
-            this.updatePolling();
-            // Reset options.fetchPolicy to its original value when variables change,
-            // unless a new fetchPolicy was provided by newOptions.
-            if (newOptions &&
-                newOptions.variables &&
-                !equal(newOptions.variables, oldVariables) &&
-                // Don't mess with the fetchPolicy if it's currently "standby".
-                options.fetchPolicy !== "standby" &&
-                // If we're changing the fetchPolicy anyway, don't try to change it here
-                // using applyNextFetchPolicy. The explicit options.fetchPolicy wins.
-                (options.fetchPolicy === oldFetchPolicy ||
-                    // A `nextFetchPolicy` function has even higher priority, though,
-                    // so in that case `applyNextFetchPolicy` must be called.
-                    typeof options.nextFetchPolicy === "function")) {
-                this.applyNextFetchPolicy("variables-changed", options);
-                if (newNetworkStatus === void 0) {
-                    newNetworkStatus = NetworkStatus.setVariables;
-                }
-            }
-        }
-        this.waitForOwnResult && (this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy));
-        var finishWaitingForOwnResult = function () {
-            if (_this.concast === concast) {
-                _this.waitForOwnResult = false;
-            }
-        };
-        var variables = options.variables && __assign({}, options.variables);
-        var _a = this.fetch(options, newNetworkStatus, query), concast = _a.concast, fromLink = _a.fromLink;
-        var observer = {
-            next: function (result) {
-                if (equal(_this.variables, variables)) {
-                    finishWaitingForOwnResult();
-                    _this.reportResult(result, variables);
-                }
-            },
-            error: function (error) {
-                if (equal(_this.variables, variables)) {
-                    // Coming from `getResultsFromLink`, `error` here should always be an `ApolloError`.
-                    // However, calling `concast.cancel` can inject another type of error, so we have to
-                    // wrap it again here.
-                    if (!isApolloError(error)) {
-                        error = new ApolloError({ networkError: error });
-                    }
-                    finishWaitingForOwnResult();
-                    _this.reportError(error, variables);
-                }
-            },
-        };
-        if (!useDisposableConcast && (fromLink || !this.concast)) {
-            // We use the {add,remove}Observer methods directly to avoid wrapping
-            // observer with an unnecessary SubscriptionObserver object.
-            if (this.concast && this.observer) {
-                this.concast.removeObserver(this.observer);
-            }
-            this.concast = concast;
-            this.observer = observer;
-        }
-        concast.addObserver(observer);
-        return concast;
-    };
-    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {
-        return preventUnhandledRejection(this.reobserveAsConcast(newOptions, newNetworkStatus).promise.then(this.maskResult));
-    };
-    ObservableQuery.prototype.resubscribeAfterError = function () {
-        var _this = this;
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        // If `lastError` is set in the current when the subscription is re-created,
-        // the subscription will immediately receive the error, which will
-        // cause it to terminate again. To avoid this, we first clear
-        // the last error/result from the `observableQuery` before re-starting
-        // the subscription, and restore the last value afterwards so that the
-        // subscription has a chance to stay open.
-        var last = this.last;
-        muteDeprecations("resetLastResults", function () { return _this.resetLastResults(); });
-        var subscription = this.subscribe.apply(this, args);
-        this.last = last;
-        return subscription;
-    };
-    // (Re)deliver the current result to this.observers without applying fetch
-    // policies or making network requests.
-    ObservableQuery.prototype.observe = function () {
-        this.reportResult(
-        // Passing false is important so that this.getCurrentResult doesn't
-        // save the fetchMore result as this.lastResult, causing it to be
-        // ignored due to the this.isDifferentFromLastResult check in
-        // this.reportResult.
-        this.getCurrentFullResult(false), this.variables);
-    };
-    ObservableQuery.prototype.reportResult = function (result, variables) {
-        var _this = this;
-        var lastError = muteDeprecations("getLastError", function () {
-            return _this.getLastError();
-        });
-        var isDifferent = this.isDifferentFromLastResult(result, variables);
-        // Update the last result even when isDifferentFromLastResult returns false,
-        // because the query may be using the @nonreactive directive, and we want to
-        // save the the latest version of any nonreactive subtrees (in case
-        // getCurrentResult is called), even though we skip broadcasting changes.
-        if (lastError || !result.partial || this.options.returnPartialData) {
-            this.updateLastResult(result, variables);
-        }
-        if (lastError || isDifferent) {
-            iterateObserversSafely(this.observers, "next", this.maskResult(result));
-        }
-    };
-    ObservableQuery.prototype.reportError = function (error, variables) {
-        var _this = this;
-        // Since we don't get the current result on errors, only the error, we
-        // must mirror the updates that occur in QueryStore.markQueryError here
-        var errorResult = __assign(__assign({}, muteDeprecations("getLastResult", function () { return _this.getLastResult(); })), { error: error, errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false });
-        this.updateLastResult(errorResult, variables);
-        iterateObserversSafely(this.observers, "error", (this.last.error = error));
-    };
-    ObservableQuery.prototype.hasObservers = function () {
-        return this.observers.size > 0;
-    };
-    ObservableQuery.prototype.tearDownQuery = function () {
-        if (this.isTornDown)
-            return;
-        if (this.concast && this.observer) {
-            this.concast.removeObserver(this.observer);
-            delete this.concast;
-            delete this.observer;
-        }
-        this.stopPolling();
-        // stop all active GraphQL subscriptions
-        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });
-        this.subscriptions.clear();
-        this.queryManager.stopQuery(this.queryId);
-        this.observers.clear();
-        this.isTornDown = true;
-    };
-    ObservableQuery.prototype.transformDocument = function (document) {
-        return this.queryManager.transform(document);
-    };
-    ObservableQuery.prototype.maskResult = function (result) {
-        return result && "data" in result ? __assign(__assign({}, result), { data: this.queryManager.maskOperation({
-                document: this.query,
-                data: result.data,
-                fetchPolicy: this.options.fetchPolicy,
-                id: this.queryId,
-            }) }) : result;
-    };
-    /** @internal */
-    ObservableQuery.prototype.resetNotifications = function () {
-        this.cancelNotifyTimeout();
-        this.dirty = false;
-    };
-    ObservableQuery.prototype.cancelNotifyTimeout = function () {
-        if (this.notifyTimeout) {
-            clearTimeout(this.notifyTimeout);
-            this.notifyTimeout = void 0;
-        }
-    };
-    /** @internal */
-    ObservableQuery.prototype.scheduleNotify = function () {
-        var _this = this;
-        if (this.dirty)
-            return;
-        this.dirty = true;
-        if (!this.notifyTimeout) {
-            this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);
-        }
-    };
-    /** @internal */
-    ObservableQuery.prototype.notify = function () {
-        this.cancelNotifyTimeout();
-        if (this.dirty) {
-            if (this.options.fetchPolicy == "cache-only" ||
-                this.options.fetchPolicy == "cache-and-network" ||
-                !isNetworkRequestInFlight(this.queryInfo.networkStatus)) {
-                var diff = this.queryInfo.getDiff();
-                if (diff.fromOptimisticTransaction) {
-                    // If this diff came from an optimistic transaction, deliver the
-                    // current cache data to the ObservableQuery, but don't perform a
-                    // reobservation, since oq.reobserveCacheFirst might make a network
-                    // request, and we never want to trigger network requests in the
-                    // middle of optimistic updates.
-                    this.observe();
-                }
-                else {
-                    // Otherwise, make the ObservableQuery "reobserve" the latest data
-                    // using a temporary fetch policy of "cache-first", so complete cache
-                    // results have a chance to be delivered without triggering additional
-                    // network requests, even when options.fetchPolicy is "network-only"
-                    // or "cache-and-network". All other fetch policies are preserved by
-                    // this method, and are handled by calling oq.reobserve(). If this
-                    // reobservation is spurious, isDifferentFromLastResult still has a
-                    // chance to catch it before delivery to ObservableQuery subscribers.
-                    this.reobserveCacheFirst();
-                }
-            }
-        }
-        this.dirty = false;
-    };
-    // Reobserve with fetchPolicy effectively set to "cache-first", triggering
-    // delivery of any new data from the cache, possibly falling back to the network
-    // if any cache data are missing. This allows _complete_ cache results to be
-    // delivered without also kicking off unnecessary network requests when
-    // this.options.fetchPolicy is "cache-and-network" or "network-only". When
-    // this.options.fetchPolicy is any other policy ("cache-first", "cache-only",
-    // "standby", or "no-cache"), we call this.reobserve() as usual.
-    ObservableQuery.prototype.reobserveCacheFirst = function () {
-        var _a = this.options, fetchPolicy = _a.fetchPolicy, nextFetchPolicy = _a.nextFetchPolicy;
-        if (fetchPolicy === "cache-and-network" || fetchPolicy === "network-only") {
-            return this.reobserve({
-                fetchPolicy: "cache-first",
-                // Use a temporary nextFetchPolicy function that replaces itself with the
-                // previous nextFetchPolicy value and returns the original fetchPolicy.
-                nextFetchPolicy: function (currentFetchPolicy, context) {
-                    // Replace this nextFetchPolicy function in the options object with the
-                    // original this.options.nextFetchPolicy value.
-                    this.nextFetchPolicy = nextFetchPolicy;
-                    // If the original nextFetchPolicy value was a function, give it a
-                    // chance to decide what happens here.
-                    if (typeof this.nextFetchPolicy === "function") {
-                        return this.nextFetchPolicy(currentFetchPolicy, context);
-                    }
-                    // Otherwise go back to the original this.options.fetchPolicy.
-                    return fetchPolicy;
-                },
-            });
-        }
-        return this.reobserve();
-    };
-    /**
-     * @internal
-     * A slot used by the `useQuery` hook to indicate that `client.watchQuery`
-     * should not register the query immediately, but instead wait for the query to
-     * be started registered with the `QueryManager` when `useSyncExternalStore`
-     * actively subscribes to it.
-     */
-    ObservableQuery.inactiveOnCreation = new Slot();
-    return ObservableQuery;
-}(Observable));
-// Necessary because the ObservableQuery constructor has a different
-// signature than the Observable constructor.
-fixObservableSubclass(ObservableQuery);
-function defaultSubscriptionObserverErrorCallback(error) {
-    globalThis.__DEV__ !== false && invariant.error(33, error.message, error.stack);
-}
-function logMissingFieldErrors(missing) {
-    if (globalThis.__DEV__ !== false && missing) {
-        globalThis.__DEV__ !== false && invariant.debug(34, missing);
-    }
-}
-function skipCacheDataFor(fetchPolicy /* `undefined` would mean `"cache-first"` */) {
-    return (fetchPolicy === "network-only" ||
-        fetchPolicy === "no-cache" ||
-        fetchPolicy === "standby");
-}
-
-var destructiveMethodCounts = new (canUseWeakMap ? WeakMap : Map)();
-function wrapDestructiveCacheMethod(cache, methodName) {
-    var original = cache[methodName];
-    if (typeof original === "function") {
-        // @ts-expect-error this is just too generic to be typed correctly
-        cache[methodName] = function () {
-            destructiveMethodCounts.set(cache, 
-            // The %1e15 allows the count to wrap around to 0 safely every
-            // quadrillion evictions, so there's no risk of overflow. To be
-            // clear, this is more of a pedantic principle than something
-            // that matters in any conceivable practical scenario.
-            (destructiveMethodCounts.get(cache) + 1) % 1e15);
-            // @ts-expect-error this is just too generic to be typed correctly
-            return original.apply(this, arguments);
-        };
-    }
-}
-// A QueryInfo object represents a single query managed by the
-// QueryManager, which tracks all QueryInfo objects by queryId in its
-// this.queries Map. QueryInfo objects store the latest results and errors
-// for the given query, and are responsible for reporting those results to
-// the corresponding ObservableQuery, via the QueryInfo.notify method.
-// Results are reported asynchronously whenever setDiff marks the
-// QueryInfo object as dirty, though a call to the QueryManager's
-// broadcastQueries method may trigger the notification before it happens
-// automatically. This class used to be a simple interface type without
-// any field privacy or meaningful methods, which is why it still has so
-// many public fields. The effort to lock down and simplify the QueryInfo
-// interface is ongoing, and further improvements are welcome.
-var QueryInfo = /** @class */ (function () {
-    function QueryInfo(queryManager, queryId) {
-        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }
-        this.queryId = queryId;
-        this.document = null;
-        this.lastRequestId = 1;
-        this.stopped = false;
-        this.observableQuery = null;
-        var cache = (this.cache = queryManager.cache);
-        // Track how often cache.evict is called, since we want eviction to
-        // override the feud-stopping logic in the markResult method, by
-        // causing shouldWrite to return true. Wrapping the cache.evict method
-        // is a bit of a hack, but it saves us from having to make eviction
-        // counting an official part of the ApolloCache API.
-        if (!destructiveMethodCounts.has(cache)) {
-            destructiveMethodCounts.set(cache, 0);
-            wrapDestructiveCacheMethod(cache, "evict");
-            wrapDestructiveCacheMethod(cache, "modify");
-            wrapDestructiveCacheMethod(cache, "reset");
-        }
-    }
-    QueryInfo.prototype.init = function (query) {
-        var networkStatus = query.networkStatus || NetworkStatus.loading;
-        if (this.variables &&
-            this.networkStatus !== NetworkStatus.loading &&
-            !equal(this.variables, query.variables)) {
-            networkStatus = NetworkStatus.setVariables;
-        }
-        if (!equal(query.variables, this.variables)) {
-            this.lastDiff = void 0;
-            // Ensure we don't continue to receive cache updates for old variables
-            this.cancel();
-        }
-        Object.assign(this, {
-            document: query.document,
-            variables: query.variables,
-            networkError: null,
-            graphQLErrors: this.graphQLErrors || [],
-            networkStatus: networkStatus,
-        });
-        if (query.observableQuery) {
-            this.setObservableQuery(query.observableQuery);
-        }
-        if (query.lastRequestId) {
-            this.lastRequestId = query.lastRequestId;
-        }
-        return this;
-    };
-    QueryInfo.prototype.resetDiff = function () {
-        this.lastDiff = void 0;
-    };
-    QueryInfo.prototype.getDiff = function () {
-        var _this = this;
-        var options = this.getDiffOptions();
-        if (this.lastDiff && equal(options, this.lastDiff.options)) {
-            return this.lastDiff.diff;
-        }
-        this.updateWatch(this.variables);
-        var oq = this.observableQuery;
-        if (oq && oq.options.fetchPolicy === "no-cache") {
-            return { complete: false };
-        }
-        var diff = muteDeprecations("canonizeResults", function () {
-            return _this.cache.diff(options);
-        });
-        this.updateLastDiff(diff, options);
-        return diff;
-    };
-    QueryInfo.prototype.updateLastDiff = function (diff, options) {
-        this.lastDiff =
-            diff ?
-                {
-                    diff: diff,
-                    options: options || this.getDiffOptions(),
-                }
-                : void 0;
-    };
-    QueryInfo.prototype.getDiffOptions = function (variables) {
-        var _a;
-        if (variables === void 0) { variables = this.variables; }
-        return {
-            query: this.document,
-            variables: variables,
-            returnPartialData: true,
-            optimistic: true,
-            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,
-        };
-    };
-    QueryInfo.prototype.setDiff = function (diff) {
-        var _this = this;
-        var _a;
-        var oldDiff = this.lastDiff && this.lastDiff.diff;
-        // If we are trying to deliver an incomplete cache result, we avoid
-        // reporting it if the query has errored, otherwise we let the broadcast try
-        // and repair the partial result by refetching the query. This check avoids
-        // a situation where a query that errors and another succeeds with
-        // overlapping data does not report the partial data result to the errored
-        // query.
-        //
-        // See https://github.com/apollographql/apollo-client/issues/11400 for more
-        // information on this issue.
-        if (diff &&
-            !diff.complete &&
-            muteDeprecations("getLastError", function () { var _a; return (_a = _this.observableQuery) === null || _a === void 0 ? void 0 : _a.getLastError(); })) {
-            return;
-        }
-        this.updateLastDiff(diff);
-        if (!equal(oldDiff && oldDiff.result, diff && diff.result)) {
-            (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a["scheduleNotify"]();
-        }
-    };
-    QueryInfo.prototype.setObservableQuery = function (oq) {
-        if (oq === this.observableQuery)
-            return;
-        this.observableQuery = oq;
-        if (oq) {
-            oq["queryInfo"] = this;
-        }
-    };
-    QueryInfo.prototype.stop = function () {
-        var _a;
-        if (!this.stopped) {
-            this.stopped = true;
-            // Cancel the pending notify timeout
-            (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a["resetNotifications"]();
-            this.cancel();
-            var oq = this.observableQuery;
-            if (oq)
-                oq.stopPolling();
-        }
-    };
-    QueryInfo.prototype.cancel = function () {
-        var _a;
-        (_a = this.cancelWatch) === null || _a === void 0 ? void 0 : _a.call(this);
-        this.cancelWatch = void 0;
-    };
-    QueryInfo.prototype.updateWatch = function (variables) {
-        var _this = this;
-        if (variables === void 0) { variables = this.variables; }
-        var oq = this.observableQuery;
-        if (oq && oq.options.fetchPolicy === "no-cache") {
-            return;
-        }
-        var watchOptions = __assign(__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });
-        if (!this.lastWatch || !equal(watchOptions, this.lastWatch)) {
-            this.cancel();
-            this.cancelWatch = this.cache.watch((this.lastWatch = watchOptions));
-        }
-    };
-    QueryInfo.prototype.resetLastWrite = function () {
-        this.lastWrite = void 0;
-    };
-    QueryInfo.prototype.shouldWrite = function (result, variables) {
-        var lastWrite = this.lastWrite;
-        return !(lastWrite &&
-            // If cache.evict has been called since the last time we wrote this
-            // data into the cache, there's a chance writing this result into
-            // the cache will repair what was evicted.
-            lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&
-            equal(variables, lastWrite.variables) &&
-            equal(result.data, lastWrite.result.data));
-    };
-    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {
-        var _this = this;
-        var _a;
-        var merger = new DeepMerger();
-        var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];
-        // Cancel the pending notify timeout (if it exists) to prevent extraneous network
-        // requests. To allow future notify timeouts, diff and dirty are reset as well.
-        (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a["resetNotifications"]();
-        if ("incremental" in result && isNonEmptyArray(result.incremental)) {
-            var mergedData = mergeIncrementalData(this.getDiff().result, result);
-            result.data = mergedData;
-            // Detect the first chunk of a deferred query and merge it with existing
-            // cache data. This ensures a `cache-first` fetch policy that returns
-            // partial cache data or a `cache-and-network` fetch policy that already
-            // has full data in the cache does not complain when trying to merge the
-            // initial deferred server data with existing cache data.
-        }
-        else if ("hasNext" in result && result.hasNext) {
-            var diff = this.getDiff();
-            result.data = merger.merge(diff.result, result.data);
-        }
-        this.graphQLErrors = graphQLErrors;
-        if (options.fetchPolicy === "no-cache") {
-            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));
-        }
-        else if (cacheWriteBehavior !== 0 /* CacheWriteBehavior.FORBID */) {
-            if (shouldWriteResult(result, options.errorPolicy)) {
-                // Using a transaction here so we have a chance to read the result
-                // back from the cache before the watch callback fires as a result
-                // of writeQuery, so we can store the new diff quietly and ignore
-                // it when we receive it redundantly from the watch callback.
-                this.cache.performTransaction(function (cache) {
-                    if (_this.shouldWrite(result, options.variables)) {
-                        cache.writeQuery({
-                            query: document,
-                            data: result.data,
-                            variables: options.variables,
-                            overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,
-                        });
-                        _this.lastWrite = {
-                            result: result,
-                            variables: options.variables,
-                            dmCount: destructiveMethodCounts.get(_this.cache),
-                        };
-                    }
-                    else {
-                        // If result is the same as the last result we received from
-                        // the network (and the variables match too), avoid writing
-                        // result into the cache again. The wisdom of skipping this
-                        // cache write is far from obvious, since any cache write
-                        // could be the one that puts the cache back into a desired
-                        // state, fixing corruption or missing data. However, if we
-                        // always write every network result into the cache, we enable
-                        // feuds between queries competing to update the same data in
-                        // incompatible ways, which can lead to an endless cycle of
-                        // cache broadcasts and useless network requests. As with any
-                        // feud, eventually one side must step back from the brink,
-                        // letting the other side(s) have the last word(s). There may
-                        // be other points where we could break this cycle, such as
-                        // silencing the broadcast for cache.writeQuery (not a good
-                        // idea, since it just delays the feud a bit) or somehow
-                        // avoiding the network request that just happened (also bad,
-                        // because the server could return useful new data). All
-                        // options considered, skipping this cache write seems to be
-                        // the least damaging place to break the cycle, because it
-                        // reflects the intuition that we recently wrote this exact
-                        // result into the cache, so the cache *should* already/still
-                        // contain this data. If some other query has clobbered that
-                        // data in the meantime, that's too bad, but there will be no
-                        // winners if every query blindly reverts to its own version
-                        // of the data. This approach also gives the network a chance
-                        // to return new data, which will be written into the cache as
-                        // usual, notifying only those queries that are directly
-                        // affected by the cache updates, as usual. In the future, an
-                        // even more sophisticated cache could perhaps prevent or
-                        // mitigate the clobbering somehow, but that would make this
-                        // particular cache write even less important, and thus
-                        // skipping it would be even safer than it is today.
-                        if (_this.lastDiff && _this.lastDiff.diff.complete) {
-                            // Reuse data from the last good (complete) diff that we
-                            // received, when possible.
-                            result.data = _this.lastDiff.diff.result;
-                            return;
-                        }
-                        // If the previous this.diff was incomplete, fall through to
-                        // re-reading the latest data with cache.diff, below.
-                    }
-                    var diffOptions = _this.getDiffOptions(options.variables);
-                    var diff = muteDeprecations("canonizeResults", function () {
-                        return cache.diff(diffOptions);
-                    });
-                    // In case the QueryManager stops this QueryInfo before its
-                    // results are delivered, it's important to avoid restarting the
-                    // cache watch when markResult is called. We also avoid updating
-                    // the watch if we are writing a result that doesn't match the current
-                    // variables to avoid race conditions from broadcasting the wrong
-                    // result.
-                    if (!_this.stopped && equal(_this.variables, options.variables)) {
-                        // Any time we're about to update this.diff, we need to make
-                        // sure we've started watching the cache.
-                        _this.updateWatch(options.variables);
-                    }
-                    // If we're allowed to write to the cache, and we can read a
-                    // complete result from the cache, update result.data to be the
-                    // result from the cache, rather than the raw network result.
-                    // Set without setDiff to avoid triggering a notify call, since
-                    // we have other ways of notifying for this result.
-                    _this.updateLastDiff(diff, diffOptions);
-                    if (diff.complete) {
-                        result.data = diff.result;
-                    }
-                });
-            }
-            else {
-                this.lastWrite = void 0;
-            }
-        }
-    };
-    QueryInfo.prototype.markReady = function () {
-        this.networkError = null;
-        return (this.networkStatus = NetworkStatus.ready);
-    };
-    QueryInfo.prototype.markError = function (error) {
-        var _a;
-        this.networkStatus = NetworkStatus.error;
-        this.lastWrite = void 0;
-        (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a["resetNotifications"]();
-        if (error.graphQLErrors) {
-            this.graphQLErrors = error.graphQLErrors;
-        }
-        if (error.networkError) {
-            this.networkError = error.networkError;
-        }
-        return error;
-    };
-    return QueryInfo;
-}());
-function shouldWriteResult(result, errorPolicy) {
-    if (errorPolicy === void 0) { errorPolicy = "none"; }
-    var ignoreErrors = errorPolicy === "ignore" || errorPolicy === "all";
-    var writeWithErrors = !graphQLResultHasError(result);
-    if (!writeWithErrors && ignoreErrors && result.data) {
-        writeWithErrors = true;
-    }
-    return writeWithErrors;
-}
-
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var IGNORE = Object.create(null);
-var QueryManager = /** @class */ (function () {
-    function QueryManager(options) {
-        var _this = this;
-        this.clientAwareness = {};
-        // All the queries that the QueryManager is currently managing (not
-        // including mutations and subscriptions).
-        this.queries = new Map();
-        // Maps from queryId strings to Promise rejection functions for
-        // currently active queries and fetches.
-        // Use protected instead of private field so
-        // @apollo/experimental-nextjs-app-support can access type info.
-        this.fetchCancelFns = new Map();
-        this.transformCache = new AutoCleanedWeakCache(cacheSizes["queryManager.getDocumentInfo"] ||
-            2000 /* defaultCacheSizes["queryManager.getDocumentInfo"] */);
-        this.queryIdCounter = 1;
-        this.requestIdCounter = 1;
-        this.mutationIdCounter = 1;
-        // Use protected instead of private field so
-        // @apollo/experimental-nextjs-app-support can access type info.
-        this.inFlightLinkObservables = new Trie(false);
-        this.noCacheWarningsByQueryId = new Set();
-        var defaultDocumentTransform = new DocumentTransform(function (document) { return _this.cache.transformDocument(document); }, 
-        // Allow the apollo cache to manage its own transform caches
-        { cache: false });
-        this.cache = options.cache;
-        this.link = options.link;
-        this.defaultOptions = options.defaultOptions;
-        this.queryDeduplication = options.queryDeduplication;
-        this.clientAwareness = options.clientAwareness;
-        this.localState = options.localState;
-        this.ssrMode = options.ssrMode;
-        this.assumeImmutableResults = options.assumeImmutableResults;
-        this.dataMasking = options.dataMasking;
-        var documentTransform = options.documentTransform;
-        this.documentTransform =
-            documentTransform ?
-                defaultDocumentTransform
-                    .concat(documentTransform)
-                    // The custom document transform may add new fragment spreads or new
-                    // field selections, so we want to give the cache a chance to run
-                    // again. For example, the InMemoryCache adds __typename to field
-                    // selections and fragments from the fragment registry.
-                    .concat(defaultDocumentTransform)
-                : defaultDocumentTransform;
-        this.defaultContext = options.defaultContext || Object.create(null);
-        if ((this.onBroadcast = options.onBroadcast)) {
-            this.mutationStore = Object.create(null);
-        }
-    }
-    /**
-     * Call this method to terminate any active query processes, making it safe
-     * to dispose of this QueryManager instance.
-     */
-    QueryManager.prototype.stop = function () {
-        var _this = this;
-        this.queries.forEach(function (_info, queryId) {
-            _this.stopQueryNoBroadcast(queryId);
-        });
-        this.cancelPendingFetches(newInvariantError(35));
-    };
-    QueryManager.prototype.cancelPendingFetches = function (error) {
-        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });
-        this.fetchCancelFns.clear();
-    };
-    QueryManager.prototype.mutate = function (_a) {
-        return __awaiter(this, arguments, void 0, function (_b) {
-            var mutationId, hasClientExports, mutationStoreValue, isOptimistic, self;
-            var _c, _d;
-            var mutation = _b.mutation, variables = _b.variables, optimisticResponse = _b.optimisticResponse, updateQueries = _b.updateQueries, _e = _b.refetchQueries, refetchQueries = _e === void 0 ? [] : _e, _f = _b.awaitRefetchQueries, awaitRefetchQueries = _f === void 0 ? false : _f, updateWithProxyFn = _b.update, onQueryUpdated = _b.onQueryUpdated, _g = _b.fetchPolicy, fetchPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.fetchPolicy) || "network-only" : _g, _h = _b.errorPolicy, errorPolicy = _h === void 0 ? ((_d = this.defaultOptions.mutate) === null || _d === void 0 ? void 0 : _d.errorPolicy) || "none" : _h, keepRootFields = _b.keepRootFields, context = _b.context;
-            return __generator(this, function (_j) {
-                switch (_j.label) {
-                    case 0:
-                        invariant(mutation, 36);
-                        invariant(fetchPolicy === "network-only" || fetchPolicy === "no-cache", 37);
-                        mutationId = this.generateMutationId();
-                        mutation = this.cache.transformForLink(this.transform(mutation));
-                        hasClientExports = this.getDocumentInfo(mutation).hasClientExports;
-                        variables = this.getVariables(mutation, variables);
-                        if (!hasClientExports) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.localState.addExportedVariables(mutation, variables, context)];
-                    case 1:
-                        variables = (_j.sent());
-                        _j.label = 2;
-                    case 2:
-                        mutationStoreValue = this.mutationStore &&
-                            (this.mutationStore[mutationId] = {
-                                mutation: mutation,
-                                variables: variables,
-                                loading: true,
-                                error: null,
-                            });
-                        isOptimistic = optimisticResponse &&
-                            this.markMutationOptimistic(optimisticResponse, {
-                                mutationId: mutationId,
-                                document: mutation,
-                                variables: variables,
-                                fetchPolicy: fetchPolicy,
-                                errorPolicy: errorPolicy,
-                                context: context,
-                                updateQueries: updateQueries,
-                                update: updateWithProxyFn,
-                                keepRootFields: keepRootFields,
-                            });
-                        this.broadcastQueries();
-                        self = this;
-                        return [2 /*return*/, new Promise(function (resolve, reject) {
-                                return asyncMap(self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, {}, false), function (result) {
-                                    if (graphQLResultHasError(result) && errorPolicy === "none") {
-                                        throw new ApolloError({
-                                            graphQLErrors: getGraphQLErrorsFromResult(result),
-                                        });
-                                    }
-                                    if (mutationStoreValue) {
-                                        mutationStoreValue.loading = false;
-                                        mutationStoreValue.error = null;
-                                    }
-                                    var storeResult = __assign({}, result);
-                                    if (typeof refetchQueries === "function") {
-                                        refetchQueries = refetchQueries(storeResult);
-                                    }
-                                    if (errorPolicy === "ignore" && graphQLResultHasError(storeResult)) {
-                                        delete storeResult.errors;
-                                    }
-                                    return self.markMutationResult({
-                                        mutationId: mutationId,
-                                        result: storeResult,
-                                        document: mutation,
-                                        variables: variables,
-                                        fetchPolicy: fetchPolicy,
-                                        errorPolicy: errorPolicy,
-                                        context: context,
-                                        update: updateWithProxyFn,
-                                        updateQueries: updateQueries,
-                                        awaitRefetchQueries: awaitRefetchQueries,
-                                        refetchQueries: refetchQueries,
-                                        removeOptimistic: isOptimistic ? mutationId : void 0,
-                                        onQueryUpdated: onQueryUpdated,
-                                        keepRootFields: keepRootFields,
-                                    });
-                                }).subscribe({
-                                    next: function (storeResult) {
-                                        self.broadcastQueries();
-                                        // Since mutations might receive multiple payloads from the
-                                        // ApolloLink chain (e.g. when used with @defer),
-                                        // we resolve with a SingleExecutionResult or after the final
-                                        // ExecutionPatchResult has arrived and we have assembled the
-                                        // multipart response into a single result.
-                                        if (!("hasNext" in storeResult) || storeResult.hasNext === false) {
-                                            resolve(__assign(__assign({}, storeResult), { data: self.maskOperation({
-                                                    document: mutation,
-                                                    data: storeResult.data,
-                                                    fetchPolicy: fetchPolicy,
-                                                    id: mutationId,
-                                                }) }));
-                                        }
-                                    },
-                                    error: function (err) {
-                                        if (mutationStoreValue) {
-                                            mutationStoreValue.loading = false;
-                                            mutationStoreValue.error = err;
-                                        }
-                                        if (isOptimistic) {
-                                            self.cache.removeOptimistic(mutationId);
-                                        }
-                                        self.broadcastQueries();
-                                        reject(err instanceof ApolloError ? err : (new ApolloError({
-                                            networkError: err,
-                                        })));
-                                    },
-                                });
-                            })];
-                }
-            });
-        });
-    };
-    QueryManager.prototype.markMutationResult = function (mutation, cache) {
-        var _this = this;
-        if (cache === void 0) { cache = this.cache; }
-        var result = mutation.result;
-        var cacheWrites = [];
-        var skipCache = mutation.fetchPolicy === "no-cache";
-        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {
-            if (!isExecutionPatchIncrementalResult(result)) {
-                cacheWrites.push({
-                    result: result.data,
-                    dataId: "ROOT_MUTATION",
-                    query: mutation.document,
-                    variables: mutation.variables,
-                });
-            }
-            if (isExecutionPatchIncrementalResult(result) &&
-                isNonEmptyArray(result.incremental)) {
-                var diff = cache.diff({
-                    id: "ROOT_MUTATION",
-                    // The cache complains if passed a mutation where it expects a
-                    // query, so we transform mutations and subscriptions to queries
-                    // (only once, thanks to this.transformCache).
-                    query: this.getDocumentInfo(mutation.document).asQuery,
-                    variables: mutation.variables,
-                    optimistic: false,
-                    returnPartialData: true,
-                });
-                var mergedData = void 0;
-                if (diff.result) {
-                    mergedData = mergeIncrementalData(diff.result, result);
-                }
-                if (typeof mergedData !== "undefined") {
-                    // cast the ExecutionPatchResult to FetchResult here since
-                    // ExecutionPatchResult never has `data` when returned from the server
-                    result.data = mergedData;
-                    cacheWrites.push({
-                        result: mergedData,
-                        dataId: "ROOT_MUTATION",
-                        query: mutation.document,
-                        variables: mutation.variables,
-                    });
-                }
-            }
-            var updateQueries_1 = mutation.updateQueries;
-            if (updateQueries_1) {
-                this.queries.forEach(function (_a, queryId) {
-                    var observableQuery = _a.observableQuery;
-                    var queryName = observableQuery && observableQuery.queryName;
-                    if (!queryName || !hasOwnProperty.call(updateQueries_1, queryName)) {
-                        return;
-                    }
-                    var updater = updateQueries_1[queryName];
-                    var _b = _this.queries.get(queryId), document = _b.document, variables = _b.variables;
-                    // Read the current query result from the store.
-                    var _c = cache.diff({
-                        query: document,
-                        variables: variables,
-                        returnPartialData: true,
-                        optimistic: false,
-                    }), currentQueryResult = _c.result, complete = _c.complete;
-                    if (complete && currentQueryResult) {
-                        // Run our reducer using the current query result and the mutation result.
-                        var nextQueryResult = updater(currentQueryResult, {
-                            mutationResult: result,
-                            queryName: (document && getOperationName(document)) || void 0,
-                            queryVariables: variables,
-                        });
-                        // Write the modified result back into the store if we got a new result.
-                        if (nextQueryResult) {
-                            cacheWrites.push({
-                                result: nextQueryResult,
-                                dataId: "ROOT_QUERY",
-                                query: document,
-                                variables: variables,
-                            });
-                        }
-                    }
-                });
-            }
-        }
-        if (cacheWrites.length > 0 ||
-            (mutation.refetchQueries || "").length > 0 ||
-            mutation.update ||
-            mutation.onQueryUpdated ||
-            mutation.removeOptimistic) {
-            var results_1 = [];
-            this.refetchQueries({
-                updateCache: function (cache) {
-                    if (!skipCache) {
-                        cacheWrites.forEach(function (write) { return cache.write(write); });
-                    }
-                    // If the mutation has some writes associated with it then we need to
-                    // apply those writes to the store by running this reducer again with
-                    // a write action.
-                    var update = mutation.update;
-                    // Determine whether result is a SingleExecutionResult,
-                    // or the final ExecutionPatchResult.
-                    var isFinalResult = !isExecutionPatchResult(result) ||
-                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);
-                    if (update) {
-                        if (!skipCache) {
-                            // Re-read the ROOT_MUTATION data we just wrote into the cache
-                            // (the first cache.write call in the cacheWrites.forEach loop
-                            // above), so field read functions have a chance to run for
-                            // fields within mutation result objects.
-                            var diff = cache.diff({
-                                id: "ROOT_MUTATION",
-                                // The cache complains if passed a mutation where it expects a
-                                // query, so we transform mutations and subscriptions to queries
-                                // (only once, thanks to this.transformCache).
-                                query: _this.getDocumentInfo(mutation.document).asQuery,
-                                variables: mutation.variables,
-                                optimistic: false,
-                                returnPartialData: true,
-                            });
-                            if (diff.complete) {
-                                result = __assign(__assign({}, result), { data: diff.result });
-                                if ("incremental" in result) {
-                                    delete result.incremental;
-                                }
-                                if ("hasNext" in result) {
-                                    delete result.hasNext;
-                                }
-                            }
-                        }
-                        // If we've received the whole response,
-                        // either a SingleExecutionResult or the final ExecutionPatchResult,
-                        // call the update function.
-                        if (isFinalResult) {
-                            update(cache, result, {
-                                context: mutation.context,
-                                variables: mutation.variables,
-                            });
-                        }
-                    }
-                    // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it
-                    // shallow to allow rolling back optimistic evictions.
-                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {
-                        cache.modify({
-                            id: "ROOT_MUTATION",
-                            fields: function (value, _a) {
-                                var fieldName = _a.fieldName, DELETE = _a.DELETE;
-                                return fieldName === "__typename" ? value : DELETE;
-                            },
-                        });
-                    }
-                },
-                include: mutation.refetchQueries,
-                // Write the final mutation.result to the root layer of the cache.
-                optimistic: false,
-                // Remove the corresponding optimistic layer at the same time as we
-                // write the final non-optimistic result.
-                removeOptimistic: mutation.removeOptimistic,
-                // Let the caller of client.mutate optionally determine the refetching
-                // behavior for watched queries after the mutation.update function runs.
-                // If no onQueryUpdated function was provided for this mutation, pass
-                // null instead of undefined to disable the default refetching behavior.
-                onQueryUpdated: mutation.onQueryUpdated || null,
-            }).forEach(function (result) { return results_1.push(result); });
-            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {
-                // Returning a promise here makes the mutation await that promise, so we
-                // include results in that promise's work if awaitRefetchQueries or an
-                // onQueryUpdated function was specified.
-                return Promise.all(results_1).then(function () { return result; });
-            }
-        }
-        return Promise.resolve(result);
-    };
-    QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {
-        var _this = this;
-        var data = typeof optimisticResponse === "function" ?
-            optimisticResponse(mutation.variables, { IGNORE: IGNORE })
-            : optimisticResponse;
-        if (data === IGNORE) {
-            return false;
-        }
-        this.cache.recordOptimisticTransaction(function (cache) {
-            try {
-                _this.markMutationResult(__assign(__assign({}, mutation), { result: { data: data } }), cache);
-            }
-            catch (error) {
-                globalThis.__DEV__ !== false && invariant.error(error);
-            }
-        }, mutation.mutationId);
-        return true;
-    };
-    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {
-        return this.fetchConcastWithInfo(this.getOrCreateQuery(queryId), options, networkStatus).concast.promise;
-    };
-    QueryManager.prototype.getQueryStore = function () {
-        var store = Object.create(null);
-        this.queries.forEach(function (info, queryId) {
-            store[queryId] = {
-                variables: info.variables,
-                networkStatus: info.networkStatus,
-                networkError: info.networkError,
-                graphQLErrors: info.graphQLErrors,
-            };
-        });
-        return store;
-    };
-    QueryManager.prototype.resetErrors = function (queryId) {
-        var queryInfo = this.queries.get(queryId);
-        if (queryInfo) {
-            queryInfo.networkError = undefined;
-            queryInfo.graphQLErrors = [];
-        }
-    };
-    QueryManager.prototype.transform = function (document) {
-        return this.documentTransform.transformDocument(document);
-    };
-    QueryManager.prototype.getDocumentInfo = function (document) {
-        var transformCache = this.transformCache;
-        if (!transformCache.has(document)) {
-            var cacheEntry = {
-                // TODO These three calls (hasClientExports, shouldForceResolvers, and
-                // usesNonreactiveDirective) are performing independent full traversals
-                // of the transformed document. We should consider merging these
-                // traversals into a single pass in the future, though the work is
-                // cached after the first time.
-                hasClientExports: hasClientExports(document),
-                hasForcedResolvers: this.localState.shouldForceResolvers(document),
-                hasNonreactiveDirective: hasDirectives(["nonreactive"], document),
-                nonReactiveQuery: addNonReactiveToNamedFragments(document),
-                clientQuery: this.localState.clientQuery(document),
-                serverQuery: removeDirectivesFromDocument([
-                    { name: "client", remove: true },
-                    { name: "connection" },
-                    { name: "nonreactive" },
-                    { name: "unmask" },
-                ], document),
-                defaultVars: getDefaultValues(getOperationDefinition(document)),
-                // Transform any mutation or subscription operations to query operations
-                // so we can read/write them from/to the cache.
-                asQuery: __assign(__assign({}, document), { definitions: document.definitions.map(function (def) {
-                        if (def.kind === "OperationDefinition" &&
-                            def.operation !== "query") {
-                            return __assign(__assign({}, def), { operation: "query" });
-                        }
-                        return def;
-                    }) }),
-            };
-            transformCache.set(document, cacheEntry);
-        }
-        return transformCache.get(document);
-    };
-    QueryManager.prototype.getVariables = function (document, variables) {
-        return __assign(__assign({}, this.getDocumentInfo(document).defaultVars), variables);
-    };
-    QueryManager.prototype.watchQuery = function (options) {
-        var query = this.transform(options.query);
-        // assign variable default values if supplied
-        // NOTE: We don't modify options.query here with the transformed query to
-        // ensure observable.options.query is set to the raw untransformed query.
-        options = __assign(__assign({}, options), { variables: this.getVariables(query, options.variables) });
-        if (typeof options.notifyOnNetworkStatusChange === "undefined") {
-            options.notifyOnNetworkStatusChange = false;
-        }
-        var queryInfo = new QueryInfo(this);
-        var observable = new ObservableQuery({
-            queryManager: this,
-            queryInfo: queryInfo,
-            options: options,
-        });
-        observable["lastQuery"] = query;
-        if (!ObservableQuery["inactiveOnCreation"].getValue()) {
-            this.queries.set(observable.queryId, queryInfo);
-        }
-        // We give queryInfo the transformed query to ensure the first cache diff
-        // uses the transformed query instead of the raw query
-        queryInfo.init({
-            document: query,
-            observableQuery: observable,
-            variables: observable.variables,
-        });
-        return observable;
-    };
-    QueryManager.prototype.query = function (options, queryId) {
-        var _this = this;
-        if (queryId === void 0) { queryId = this.generateQueryId(); }
-        invariant(options.query, 38);
-        invariant(options.query.kind === "Document", 39);
-        invariant(!options.returnPartialData, 40);
-        invariant(!options.pollInterval, 41);
-        var query = this.transform(options.query);
-        return this.fetchQuery(queryId, __assign(__assign({}, options), { query: query }))
-            .then(function (result) {
-            return result && __assign(__assign({}, result), { data: _this.maskOperation({
-                    document: query,
-                    data: result.data,
-                    fetchPolicy: options.fetchPolicy,
-                    id: queryId,
-                }) });
-        })
-            .finally(function () { return _this.stopQuery(queryId); });
-    };
-    QueryManager.prototype.generateQueryId = function () {
-        return String(this.queryIdCounter++);
-    };
-    QueryManager.prototype.generateRequestId = function () {
-        return this.requestIdCounter++;
-    };
-    QueryManager.prototype.generateMutationId = function () {
-        return String(this.mutationIdCounter++);
-    };
-    QueryManager.prototype.stopQueryInStore = function (queryId) {
-        this.stopQueryInStoreNoBroadcast(queryId);
-        this.broadcastQueries();
-    };
-    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {
-        var queryInfo = this.queries.get(queryId);
-        if (queryInfo)
-            queryInfo.stop();
-    };
-    QueryManager.prototype.clearStore = function (options) {
-        if (options === void 0) { options = {
-            discardWatches: true,
-        }; }
-        // Before we have sent the reset action to the store, we can no longer
-        // rely on the results returned by in-flight requests since these may
-        // depend on values that previously existed in the data portion of the
-        // store. So, we cancel the promises and observers that we have issued
-        // so far and not yet resolved (in the case of queries).
-        this.cancelPendingFetches(newInvariantError(42));
-        this.queries.forEach(function (queryInfo) {
-            if (queryInfo.observableQuery) {
-                // Set loading to true so listeners don't trigger unless they want
-                // results with partial data.
-                queryInfo.networkStatus = NetworkStatus.loading;
-            }
-            else {
-                queryInfo.stop();
-            }
-        });
-        if (this.mutationStore) {
-            this.mutationStore = Object.create(null);
-        }
-        // begin removing data from the store
-        return this.cache.reset(options);
-    };
-    QueryManager.prototype.getObservableQueries = function (include) {
-        var _this = this;
-        if (include === void 0) { include = "active"; }
-        var queries = new Map();
-        var queryNames = new Map();
-        var queryNamesAndQueryStrings = new Map();
-        var legacyQueryOptions = new Set();
-        if (Array.isArray(include)) {
-            include.forEach(function (desc) {
-                if (typeof desc === "string") {
-                    queryNames.set(desc, desc);
-                    queryNamesAndQueryStrings.set(desc, false);
-                }
-                else if (isDocumentNode(desc)) {
-                    var queryString = print(_this.transform(desc));
-                    queryNames.set(queryString, getOperationName(desc));
-                    queryNamesAndQueryStrings.set(queryString, false);
-                }
-                else if (isNonNullObject(desc) && desc.query) {
-                    legacyQueryOptions.add(desc);
-                }
-            });
-        }
-        this.queries.forEach(function (_a, queryId) {
-            var oq = _a.observableQuery, document = _a.document;
-            if (oq) {
-                if (include === "all") {
-                    queries.set(queryId, oq);
-                    return;
-                }
-                var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;
-                if (fetchPolicy === "standby" ||
-                    (include === "active" && !oq.hasObservers())) {
-                    return;
-                }
-                if (include === "active" ||
-                    (queryName && queryNamesAndQueryStrings.has(queryName)) ||
-                    (document && queryNamesAndQueryStrings.has(print(document)))) {
-                    queries.set(queryId, oq);
-                    if (queryName)
-                        queryNamesAndQueryStrings.set(queryName, true);
-                    if (document)
-                        queryNamesAndQueryStrings.set(print(document), true);
-                }
-            }
-        });
-        if (legacyQueryOptions.size) {
-            legacyQueryOptions.forEach(function (options) {
-                // We will be issuing a fresh network request for this query, so we
-                // pre-allocate a new query ID here, using a special prefix to enable
-                // cleaning up these temporary queries later, after fetching.
-                var queryId = makeUniqueId("legacyOneTimeQuery");
-                var queryInfo = _this.getOrCreateQuery(queryId).init({
-                    document: options.query,
-                    variables: options.variables,
-                });
-                var oq = new ObservableQuery({
-                    queryManager: _this,
-                    queryInfo: queryInfo,
-                    options: __assign(__assign({}, options), { fetchPolicy: "network-only" }),
-                });
-                invariant(oq.queryId === queryId);
-                queryInfo.setObservableQuery(oq);
-                queries.set(queryId, oq);
-            });
-        }
-        if (globalThis.__DEV__ !== false && queryNamesAndQueryStrings.size) {
-            queryNamesAndQueryStrings.forEach(function (included, nameOrQueryString) {
-                if (!included) {
-                    var queryName = queryNames.get(nameOrQueryString);
-                    if (queryName) {
-                        globalThis.__DEV__ !== false && invariant.warn(43, queryName);
-                    }
-                    else {
-                        globalThis.__DEV__ !== false && invariant.warn(44);
-                    }
-                }
-            });
-        }
-        return queries;
-    };
-    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {
-        var _this = this;
-        if (includeStandby === void 0) { includeStandby = false; }
-        var observableQueryPromises = [];
-        this.getObservableQueries(includeStandby ? "all" : "active").forEach(function (observableQuery, queryId) {
-            var fetchPolicy = observableQuery.options.fetchPolicy;
-            muteDeprecations("resetLastResults", function () {
-                return observableQuery.resetLastResults();
-            });
-            if (includeStandby ||
-                (fetchPolicy !== "standby" && fetchPolicy !== "cache-only")) {
-                observableQueryPromises.push(observableQuery.refetch());
-            }
-            (_this.queries.get(queryId) || observableQuery["queryInfo"]).setDiff(null);
-        });
-        this.broadcastQueries();
-        return Promise.all(observableQueryPromises);
-    };
-    QueryManager.prototype.startGraphQLSubscription = function (options) {
-        var _this = this;
-        var query = options.query, variables = options.variables;
-        var fetchPolicy = options.fetchPolicy, _a = options.errorPolicy, errorPolicy = _a === void 0 ? "none" : _a, _b = options.context, context = _b === void 0 ? {} : _b, _c = options.extensions, extensions = _c === void 0 ? {} : _c;
-        query = this.transform(query);
-        variables = this.getVariables(query, variables);
-        var makeObservable = function (variables) {
-            return _this.getObservableFromLink(query, context, variables, extensions).map(function (result) {
-                if (fetchPolicy !== "no-cache") {
-                    // the subscription interface should handle not sending us results we no longer subscribe to.
-                    // XXX I don't think we ever send in an object with errors, but we might in the future...
-                    if (shouldWriteResult(result, errorPolicy)) {
-                        _this.cache.write({
-                            query: query,
-                            result: result.data,
-                            dataId: "ROOT_SUBSCRIPTION",
-                            variables: variables,
-                        });
-                    }
-                    _this.broadcastQueries();
-                }
-                var hasErrors = graphQLResultHasError(result);
-                var hasProtocolErrors = graphQLResultHasProtocolErrors(result);
-                if (hasErrors || hasProtocolErrors) {
-                    var errors = {};
-                    if (hasErrors) {
-                        errors.graphQLErrors = result.errors;
-                    }
-                    if (hasProtocolErrors) {
-                        errors.protocolErrors = result.extensions[PROTOCOL_ERRORS_SYMBOL];
-                    }
-                    // `errorPolicy` is a mechanism for handling GraphQL errors, according
-                    // to our documentation, so we throw protocol errors regardless of the
-                    // set error policy.
-                    if (errorPolicy === "none" || hasProtocolErrors) {
-                        throw new ApolloError(errors);
-                    }
-                }
-                if (errorPolicy === "ignore") {
-                    delete result.errors;
-                }
-                return result;
-            });
-        };
-        if (this.getDocumentInfo(query).hasClientExports) {
-            var observablePromise_1 = this.localState
-                .addExportedVariables(query, variables, context)
-                .then(makeObservable);
-            return new Observable(function (observer) {
-                var sub = null;
-                observablePromise_1.then(function (observable) { return (sub = observable.subscribe(observer)); }, observer.error);
-                return function () { return sub && sub.unsubscribe(); };
-            });
-        }
-        return makeObservable(variables);
-    };
-    QueryManager.prototype.stopQuery = function (queryId) {
-        this.stopQueryNoBroadcast(queryId);
-        this.broadcastQueries();
-    };
-    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {
-        this.stopQueryInStoreNoBroadcast(queryId);
-        this.removeQuery(queryId);
-    };
-    QueryManager.prototype.removeQuery = function (queryId) {
-        var _a;
-        // teardown all links
-        // Both `QueryManager.fetchRequest` and `QueryManager.query` create separate promises
-        // that each add their reject functions to fetchCancelFns.
-        // A query created with `QueryManager.query()` could trigger a `QueryManager.fetchRequest`.
-        // The same queryId could have two rejection fns for two promises
-        this.fetchCancelFns.delete(queryId);
-        if (this.queries.has(queryId)) {
-            (_a = this.queries.get(queryId)) === null || _a === void 0 ? void 0 : _a.stop();
-            this.queries.delete(queryId);
-        }
-    };
-    QueryManager.prototype.broadcastQueries = function () {
-        if (this.onBroadcast)
-            this.onBroadcast();
-        this.queries.forEach(function (info) { var _a; return (_a = info.observableQuery) === null || _a === void 0 ? void 0 : _a["notify"](); });
-    };
-    QueryManager.prototype.getLocalState = function () {
-        return this.localState;
-    };
-    QueryManager.prototype.getObservableFromLink = function (query, context, variables, extensions, 
-    // Prefer context.queryDeduplication if specified.
-    deduplication) {
-        var _this = this;
-        var _a;
-        if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }
-        var observable;
-        var _b = this.getDocumentInfo(query), serverQuery = _b.serverQuery, clientQuery = _b.clientQuery;
-        if (serverQuery) {
-            var _c = this, inFlightLinkObservables_1 = _c.inFlightLinkObservables, link = _c.link;
-            var operation = {
-                query: serverQuery,
-                variables: variables,
-                operationName: getOperationName(serverQuery) || void 0,
-                context: this.prepareContext(__assign(__assign({}, context), { forceFetch: !deduplication })),
-                extensions: extensions,
-            };
-            context = operation.context;
-            if (deduplication) {
-                var printedServerQuery_1 = print(serverQuery);
-                var varJson_1 = canonicalStringify(variables);
-                var entry = inFlightLinkObservables_1.lookup(printedServerQuery_1, varJson_1);
-                observable = entry.observable;
-                if (!observable) {
-                    var concast_1 = new Concast([
-                        execute(link, operation),
-                    ]);
-                    observable = entry.observable = concast_1;
-                    concast_1.beforeNext(function cb(method, arg) {
-                        if (method === "next" && "hasNext" in arg && arg.hasNext) {
-                            concast_1.beforeNext(cb);
-                        }
-                        else {
-                            inFlightLinkObservables_1.remove(printedServerQuery_1, varJson_1);
-                        }
-                    });
-                }
-            }
-            else {
-                observable = new Concast([
-                    execute(link, operation),
-                ]);
-            }
-        }
-        else {
-            observable = new Concast([Observable.of({ data: {} })]);
-            context = this.prepareContext(context);
-        }
-        if (clientQuery) {
-            observable = asyncMap(observable, function (result) {
-                return _this.localState.runResolvers({
-                    document: clientQuery,
-                    remoteResult: result,
-                    context: context,
-                    variables: variables,
-                });
-            });
-        }
-        return observable;
-    };
-    QueryManager.prototype.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {
-        var requestId = (queryInfo.lastRequestId = this.generateRequestId());
-        // Performing transformForLink here gives this.cache a chance to fill in
-        // missing fragment definitions (for example) before sending this document
-        // through the link chain.
-        var linkDocument = this.cache.transformForLink(options.query);
-        return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {
-            var graphQLErrors = getGraphQLErrorsFromResult(result);
-            var hasErrors = graphQLErrors.length > 0;
-            var errorPolicy = options.errorPolicy;
-            // If we interrupted this request by calling getResultsFromLink again
-            // with the same QueryInfo object, we ignore the old results.
-            if (requestId >= queryInfo.lastRequestId) {
-                if (hasErrors && errorPolicy === "none") {
-                    // Throwing here effectively calls observer.error.
-                    throw queryInfo.markError(new ApolloError({
-                        graphQLErrors: graphQLErrors,
-                    }));
-                }
-                // Use linkDocument rather than queryInfo.document so the
-                // operation/fragments used to write the result are the same as the
-                // ones used to obtain it from the link.
-                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);
-                queryInfo.markReady();
-            }
-            var aqr = {
-                data: result.data,
-                loading: false,
-                networkStatus: NetworkStatus.ready,
-            };
-            // In the case we start multiple network requests simulatenously, we
-            // want to ensure we properly set `data` if we're reporting on an old
-            // result which will not be caught by the conditional above that ends up
-            // throwing the markError result.
-            if (hasErrors && errorPolicy === "none") {
-                aqr.data = void 0;
-            }
-            if (hasErrors && errorPolicy !== "ignore") {
-                aqr.errors = graphQLErrors;
-                aqr.networkStatus = NetworkStatus.error;
-            }
-            return aqr;
-        }, function (networkError) {
-            var error = isApolloError(networkError) ? networkError : (new ApolloError({ networkError: networkError }));
-            // Avoid storing errors from older interrupted queries.
-            if (requestId >= queryInfo.lastRequestId) {
-                queryInfo.markError(error);
-            }
-            throw error;
-        });
-    };
-    QueryManager.prototype.fetchConcastWithInfo = function (queryInfo, options, 
-    // The initial networkStatus for this fetch, most often
-    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
-    // or setVariables.
-    networkStatus, query) {
-        var _this = this;
-        if (networkStatus === void 0) { networkStatus = NetworkStatus.loading; }
-        if (query === void 0) { query = options.query; }
-        var variables = this.getVariables(query, options.variables);
-        var defaults = this.defaultOptions.watchQuery;
-        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? (defaults && defaults.fetchPolicy) || "cache-first" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? (defaults && defaults.errorPolicy) || "none" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;
-        var normalized = Object.assign({}, options, {
-            query: query,
-            variables: variables,
-            fetchPolicy: fetchPolicy,
-            errorPolicy: errorPolicy,
-            returnPartialData: returnPartialData,
-            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,
-            context: context,
-        });
-        var fromVariables = function (variables) {
-            // Since normalized is always a fresh copy of options, it's safe to
-            // modify its properties here, rather than creating yet another new
-            // WatchQueryOptions object.
-            normalized.variables = variables;
-            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);
-            if (
-            // If we're in standby, postpone advancing options.fetchPolicy using
-            // applyNextFetchPolicy.
-            normalized.fetchPolicy !== "standby" &&
-                // The "standby" policy currently returns [] from fetchQueryByPolicy, so
-                // this is another way to detect when nothing was done/fetched.
-                sourcesWithInfo.sources.length > 0 &&
-                queryInfo.observableQuery) {
-                queryInfo.observableQuery["applyNextFetchPolicy"]("after-fetch", options);
-            }
-            return sourcesWithInfo;
-        };
-        // This cancel function needs to be set before the concast is created,
-        // in case concast creation synchronously cancels the request.
-        var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryInfo.queryId); };
-        this.fetchCancelFns.set(queryInfo.queryId, function (reason) {
-            cleanupCancelFn();
-            // This delay ensures the concast variable has been initialized.
-            setTimeout(function () { return concast.cancel(reason); });
-        });
-        var concast, containsDataFromLink;
-        // If the query has @export(as: ...) directives, then we need to
-        // process those directives asynchronously. When there are no
-        // @export directives (the common case), we deliberately avoid
-        // wrapping the result of this.fetchQueryByPolicy in a Promise,
-        // since the timing of result delivery is (unfortunately) important
-        // for backwards compatibility. TODO This code could be simpler if
-        // we deprecated and removed LocalState.
-        if (this.getDocumentInfo(normalized.query).hasClientExports) {
-            concast = new Concast(this.localState
-                .addExportedVariables(normalized.query, normalized.variables, normalized.context)
-                .then(fromVariables)
-                .then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));
-            // there is just no way we can synchronously get the *right* value here,
-            // so we will assume `true`, which is the behaviour before the bug fix in
-            // #10597. This means that bug is not fixed in that case, and is probably
-            // un-fixable with reasonable effort for the edge case of @export as
-            // directives.
-            containsDataFromLink = true;
-        }
-        else {
-            var sourcesWithInfo = fromVariables(normalized.variables);
-            containsDataFromLink = sourcesWithInfo.fromLink;
-            concast = new Concast(sourcesWithInfo.sources);
-        }
-        concast.promise.then(cleanupCancelFn, cleanupCancelFn);
-        return {
-            concast: concast,
-            fromLink: containsDataFromLink,
-        };
-    };
-    QueryManager.prototype.refetchQueries = function (_a) {
-        var _this = this;
-        var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? makeUniqueId("refetchQueries") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;
-        var includedQueriesById = new Map();
-        if (include) {
-            this.getObservableQueries(include).forEach(function (oq, queryId) {
-                includedQueriesById.set(queryId, {
-                    oq: oq,
-                    lastDiff: (_this.queries.get(queryId) || oq["queryInfo"]).getDiff(),
-                });
-            });
-        }
-        var results = new Map();
-        if (updateCache) {
-            this.cache.batch({
-                update: updateCache,
-                // Since you can perform any combination of cache reads and/or writes in
-                // the cache.batch update function, its optimistic option can be either
-                // a boolean or a string, representing three distinct modes of
-                // operation:
-                //
-                // * false: read/write only the root layer
-                // * true: read/write the topmost layer
-                // * string: read/write a fresh optimistic layer with that ID string
-                //
-                // When typeof optimistic === "string", a new optimistic layer will be
-                // temporarily created within cache.batch with that string as its ID. If
-                // we then pass that same string as the removeOptimistic option, we can
-                // make cache.batch immediately remove the optimistic layer after
-                // running the updateCache function, triggering only one broadcast.
-                //
-                // However, the refetchQueries method accepts only true or false for its
-                // optimistic option (not string). We interpret true to mean a temporary
-                // optimistic layer should be created, to allow efficiently rolling back
-                // the effect of the updateCache function, which involves passing a
-                // string instead of true as the optimistic option to cache.batch, when
-                // refetchQueries receives optimistic: true.
-                //
-                // In other words, we are deliberately not supporting the use case of
-                // writing to an *existing* optimistic layer (using the refetchQueries
-                // updateCache function), since that would potentially interfere with
-                // other optimistic updates in progress. Instead, you can read/write
-                // only the root layer by passing optimistic: false to refetchQueries,
-                // or you can read/write a brand new optimistic layer that will be
-                // automatically removed by passing optimistic: true.
-                optimistic: (optimistic && removeOptimistic) || false,
-                // The removeOptimistic option can also be provided by itself, even if
-                // optimistic === false, to remove some previously-added optimistic
-                // layer safely and efficiently, like we do in markMutationResult.
-                //
-                // If an explicit removeOptimistic string is provided with optimistic:
-                // true, the removeOptimistic string will determine the ID of the
-                // temporary optimistic layer, in case that ever matters.
-                removeOptimistic: removeOptimistic,
-                onWatchUpdated: function (watch, diff, lastDiff) {
-                    var oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;
-                    if (oq) {
-                        if (onQueryUpdated) {
-                            // Since we're about to handle this query now, remove it from
-                            // includedQueriesById, in case it was added earlier because of
-                            // options.include.
-                            includedQueriesById.delete(oq.queryId);
-                            var result = onQueryUpdated(oq, diff, lastDiff);
-                            if (result === true) {
-                                // The onQueryUpdated function requested the default refetching
-                                // behavior by returning true.
-                                result = oq.refetch();
-                            }
-                            // Record the result in the results Map, as long as onQueryUpdated
-                            // did not return false to skip/ignore this result.
-                            if (result !== false) {
-                                results.set(oq, result);
-                            }
-                            // Allow the default cache broadcast to happen, except when
-                            // onQueryUpdated returns false.
-                            return result;
-                        }
-                        if (onQueryUpdated !== null) {
-                            // If we don't have an onQueryUpdated function, and onQueryUpdated
-                            // was not disabled by passing null, make sure this query is
-                            // "included" like any other options.include-specified query.
-                            includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });
-                        }
-                    }
-                },
-            });
-        }
-        if (includedQueriesById.size) {
-            includedQueriesById.forEach(function (_a, queryId) {
-                var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;
-                var result;
-                // If onQueryUpdated is provided, we want to use it for all included
-                // queries, even the QueryOptions ones.
-                if (onQueryUpdated) {
-                    if (!diff) {
-                        diff = muteDeprecations("canonizeResults", function () {
-                            return _this.cache.diff(oq["queryInfo"]["getDiffOptions"]());
-                        });
-                    }
-                    result = onQueryUpdated(oq, diff, lastDiff);
-                }
-                // Otherwise, we fall back to refetching.
-                if (!onQueryUpdated || result === true) {
-                    result = oq.refetch();
-                }
-                if (result !== false) {
-                    results.set(oq, result);
-                }
-                if (queryId.indexOf("legacyOneTimeQuery") >= 0) {
-                    _this.stopQueryNoBroadcast(queryId);
-                }
-            });
-        }
-        if (removeOptimistic) {
-            // In case no updateCache callback was provided (so cache.batch was not
-            // called above, and thus did not already remove the optimistic layer),
-            // remove it here. Since this is a no-op when the layer has already been
-            // removed, we do it even if we called cache.batch above, since it's
-            // possible this.cache is an instance of some ApolloCache subclass other
-            // than InMemoryCache, and does not fully support the removeOptimistic
-            // option for cache.batch.
-            this.cache.removeOptimistic(removeOptimistic);
-        }
-        return results;
-    };
-    QueryManager.prototype.maskOperation = function (options) {
-        var _a, _b, _c;
-        var document = options.document, data = options.data;
-        if (globalThis.__DEV__ !== false) {
-            var fetchPolicy = options.fetchPolicy, id = options.id;
-            var operationType = (_a = getOperationDefinition(document)) === null || _a === void 0 ? void 0 : _a.operation;
-            var operationId = ((_b = operationType === null || operationType === void 0 ? void 0 : operationType[0]) !== null && _b !== void 0 ? _b : "o") + id;
-            if (this.dataMasking &&
-                fetchPolicy === "no-cache" &&
-                !isFullyUnmaskedOperation(document) &&
-                !this.noCacheWarningsByQueryId.has(operationId)) {
-                this.noCacheWarningsByQueryId.add(operationId);
-                globalThis.__DEV__ !== false && invariant.warn(
-                    45,
-                    (_c = getOperationName(document)) !== null && _c !== void 0 ? _c : "Unnamed ".concat(operationType !== null && operationType !== void 0 ? operationType : "operation")
-                );
-            }
-        }
-        return (this.dataMasking ?
-            maskOperation(data, document, this.cache)
-            : data);
-    };
-    QueryManager.prototype.maskFragment = function (options) {
-        var data = options.data, fragment = options.fragment, fragmentName = options.fragmentName;
-        return this.dataMasking ?
-            maskFragment(data, fragment, this.cache, fragmentName)
-            : data;
-    };
-    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a, 
-    // The initial networkStatus for this fetch, most often
-    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,
-    // or setVariables.
-    networkStatus) {
-        var _this = this;
-        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;
-        var oldNetworkStatus = queryInfo.networkStatus;
-        queryInfo.init({
-            document: query,
-            variables: variables,
-            networkStatus: networkStatus,
-        });
-        var readCache = function () { return queryInfo.getDiff(); };
-        var resultsFromCache = function (diff, networkStatus) {
-            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || NetworkStatus.loading; }
-            var data = diff.result;
-            if (globalThis.__DEV__ !== false && !returnPartialData && !equal(data, {})) {
-                logMissingFieldErrors(diff.missing);
-            }
-            var fromData = function (data) {
-                return Observable.of(__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true })));
-            };
-            if (data && _this.getDocumentInfo(query).hasForcedResolvers) {
-                return _this.localState
-                    .runResolvers({
-                    document: query,
-                    remoteResult: { data: data },
-                    context: context,
-                    variables: variables,
-                    onlyRunForcedResolvers: true,
-                })
-                    .then(function (resolved) { return fromData(resolved.data || void 0); });
-            }
-            // Resolves https://github.com/apollographql/apollo-client/issues/10317.
-            // If errorPolicy is 'none' and notifyOnNetworkStatusChange is true,
-            // data was incorrectly returned from the cache on refetch:
-            // if diff.missing exists, we should not return cache data.
-            if (errorPolicy === "none" &&
-                networkStatus === NetworkStatus.refetch &&
-                Array.isArray(diff.missing)) {
-                return fromData(void 0);
-            }
-            return fromData(data);
-        };
-        var cacheWriteBehavior = fetchPolicy === "no-cache" ? 0 /* CacheWriteBehavior.FORBID */
-            // Watched queries must opt into overwriting existing data on refetch,
-            // by passing refetchWritePolicy: "overwrite" in their WatchQueryOptions.
-            : (networkStatus === NetworkStatus.refetch &&
-                refetchWritePolicy !== "merge") ?
-                1 /* CacheWriteBehavior.OVERWRITE */
-                : 2 /* CacheWriteBehavior.MERGE */;
-        var resultsFromLink = function () {
-            return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {
-                query: query,
-                variables: variables,
-                context: context,
-                fetchPolicy: fetchPolicy,
-                errorPolicy: errorPolicy,
-            });
-        };
-        var shouldNotify = notifyOnNetworkStatusChange &&
-            typeof oldNetworkStatus === "number" &&
-            oldNetworkStatus !== networkStatus &&
-            isNetworkRequestInFlight(networkStatus);
-        switch (fetchPolicy) {
-            default:
-            case "cache-first": {
-                var diff = readCache();
-                if (diff.complete) {
-                    return {
-                        fromLink: false,
-                        sources: [resultsFromCache(diff, queryInfo.markReady())],
-                    };
-                }
-                if (returnPartialData || shouldNotify) {
-                    return {
-                        fromLink: true,
-                        sources: [resultsFromCache(diff), resultsFromLink()],
-                    };
-                }
-                return { fromLink: true, sources: [resultsFromLink()] };
-            }
-            case "cache-and-network": {
-                var diff = readCache();
-                if (diff.complete || returnPartialData || shouldNotify) {
-                    return {
-                        fromLink: true,
-                        sources: [resultsFromCache(diff), resultsFromLink()],
-                    };
-                }
-                return { fromLink: true, sources: [resultsFromLink()] };
-            }
-            case "cache-only":
-                return {
-                    fromLink: false,
-                    sources: [resultsFromCache(readCache(), queryInfo.markReady())],
-                };
-            case "network-only":
-                if (shouldNotify) {
-                    return {
-                        fromLink: true,
-                        sources: [resultsFromCache(readCache()), resultsFromLink()],
-                    };
-                }
-                return { fromLink: true, sources: [resultsFromLink()] };
-            case "no-cache":
-                if (shouldNotify) {
-                    return {
-                        fromLink: true,
-                        // Note that queryInfo.getDiff() for no-cache queries does not call
-                        // cache.diff, but instead returns a { complete: false } stub result
-                        // when there is no queryInfo.diff already defined.
-                        sources: [resultsFromCache(queryInfo.getDiff()), resultsFromLink()],
-                    };
-                }
-                return { fromLink: true, sources: [resultsFromLink()] };
-            case "standby":
-                return { fromLink: false, sources: [] };
-        }
-    };
-    QueryManager.prototype.getOrCreateQuery = function (queryId) {
-        if (queryId && !this.queries.has(queryId)) {
-            this.queries.set(queryId, new QueryInfo(this, queryId));
-        }
-        return this.queries.get(queryId);
-    };
-    QueryManager.prototype.prepareContext = function (context) {
-        if (context === void 0) { context = {}; }
-        var newContext = this.localState.prepareContext(context);
-        return __assign(__assign(__assign({}, this.defaultContext), newContext), { clientAwareness: this.clientAwareness });
-    };
-    return QueryManager;
-}());
-
-var LocalState = /** @class */ (function () {
-    function LocalState(_a) {
-        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;
-        this.selectionsToResolveCache = new WeakMap();
-        this.cache = cache;
-        if (client) {
-            this.client = client;
-        }
-        if (resolvers) {
-            this.addResolvers(resolvers);
-        }
-        if (fragmentMatcher) {
-            this.setFragmentMatcher(fragmentMatcher);
-        }
-    }
-    LocalState.prototype.addResolvers = function (resolvers) {
-        var _this = this;
-        this.resolvers = this.resolvers || {};
-        if (Array.isArray(resolvers)) {
-            resolvers.forEach(function (resolverGroup) {
-                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);
-            });
-        }
-        else {
-            this.resolvers = mergeDeep(this.resolvers, resolvers);
-        }
-    };
-    LocalState.prototype.setResolvers = function (resolvers) {
-        this.resolvers = {};
-        this.addResolvers(resolvers);
-    };
-    LocalState.prototype.getResolvers = function () {
-        return this.resolvers || {};
-    };
-    // Run local client resolvers against the incoming query and remote data.
-    // Locally resolved field values are merged with the incoming remote data,
-    // and returned. Note that locally resolved fields will overwrite
-    // remote data using the same field name.
-    LocalState.prototype.runResolvers = function (_a) {
-        return __awaiter(this, arguments, void 0, function (_b) {
-            var document = _b.document, remoteResult = _b.remoteResult, context = _b.context, variables = _b.variables, _c = _b.onlyRunForcedResolvers, onlyRunForcedResolvers = _c === void 0 ? false : _c;
-            return __generator(this, function (_d) {
-                if (document) {
-                    return [2 /*return*/, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (__assign(__assign({}, remoteResult), { data: localResult.result })); })];
-                }
-                return [2 /*return*/, remoteResult];
-            });
-        });
-    };
-    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {
-        this.fragmentMatcher = fragmentMatcher;
-    };
-    LocalState.prototype.getFragmentMatcher = function () {
-        return this.fragmentMatcher;
-    };
-    // Client queries contain everything in the incoming document (if a @client
-    // directive is found).
-    LocalState.prototype.clientQuery = function (document) {
-        if (hasDirectives(["client"], document)) {
-            if (this.resolvers) {
-                return document;
-            }
-        }
-        return null;
-    };
-    // Server queries are stripped of all @client based selection sets.
-    LocalState.prototype.serverQuery = function (document) {
-        return removeClientSetsFromDocument(document);
-    };
-    LocalState.prototype.prepareContext = function (context) {
-        var cache = this.cache;
-        return __assign(__assign({}, context), { cache: cache, 
-            // Getting an entry's cache key is useful for local state resolvers.
-            getCacheKey: function (obj) {
-                return cache.identify(obj);
-            } });
-    };
-    // To support `@client @export(as: "someVar")` syntax, we'll first resolve
-    // @client @export fields locally, then pass the resolved values back to be
-    // used alongside the original operation variables.
-    LocalState.prototype.addExportedVariables = function (document_1) {
-        return __awaiter(this, arguments, void 0, function (document, variables, context) {
-            if (variables === void 0) { variables = {}; }
-            if (context === void 0) { context = {}; }
-            return __generator(this, function (_a) {
-                if (document) {
-                    return [2 /*return*/, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (__assign(__assign({}, variables), data.exportedVariables)); })];
-                }
-                return [2 /*return*/, __assign({}, variables)];
-            });
-        });
-    };
-    LocalState.prototype.shouldForceResolvers = function (document) {
-        var forceResolvers = false;
-        visit(document, {
-            Directive: {
-                enter: function (node) {
-                    if (node.name.value === "client" && node.arguments) {
-                        forceResolvers = node.arguments.some(function (arg) {
-                            return arg.name.value === "always" &&
-                                arg.value.kind === "BooleanValue" &&
-                                arg.value.value === true;
-                        });
-                        if (forceResolvers) {
-                            return BREAK;
-                        }
-                    }
-                },
-            },
-        });
-        return forceResolvers;
-    };
-    // Query the cache and return matching data.
-    LocalState.prototype.buildRootValueFromCache = function (document, variables) {
-        return this.cache.diff({
-            query: buildQueryFromSelectionSet(document),
-            variables: variables,
-            returnPartialData: true,
-            optimistic: false,
-        }).result;
-    };
-    LocalState.prototype.resolveDocument = function (document_1, rootValue_1) {
-        return __awaiter(this, arguments, void 0, function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {
-            var mainDefinition, fragments, fragmentMap, selectionsToResolve, definitionOperation, defaultOperationType, _a, cache, client, execContext, isClientFieldDescendant;
-            if (context === void 0) { context = {}; }
-            if (variables === void 0) { variables = {}; }
-            if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }
-            if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }
-            return __generator(this, function (_b) {
-                mainDefinition = getMainDefinition(document);
-                fragments = getFragmentDefinitions(document);
-                fragmentMap = createFragmentMap(fragments);
-                selectionsToResolve = this.collectSelectionsToResolve(mainDefinition, fragmentMap);
-                definitionOperation = mainDefinition.operation;
-                defaultOperationType = definitionOperation ?
-                    definitionOperation.charAt(0).toUpperCase() +
-                        definitionOperation.slice(1)
-                    : "Query";
-                _a = this, cache = _a.cache, client = _a.client;
-                execContext = {
-                    fragmentMap: fragmentMap,
-                    context: __assign(__assign({}, context), { cache: cache, client: client }),
-                    variables: variables,
-                    fragmentMatcher: fragmentMatcher,
-                    defaultOperationType: defaultOperationType,
-                    exportedVariables: {},
-                    selectionsToResolve: selectionsToResolve,
-                    onlyRunForcedResolvers: onlyRunForcedResolvers,
-                };
-                isClientFieldDescendant = false;
-                return [2 /*return*/, this.resolveSelectionSet(mainDefinition.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (result) { return ({
-                        result: result,
-                        exportedVariables: execContext.exportedVariables,
-                    }); })];
-            });
-        });
-    };
-    LocalState.prototype.resolveSelectionSet = function (selectionSet, isClientFieldDescendant, rootValue, execContext) {
-        return __awaiter(this, void 0, void 0, function () {
-            var fragmentMap, context, variables, resultsToMerge, execute;
-            var _this = this;
-            return __generator(this, function (_a) {
-                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;
-                resultsToMerge = [rootValue];
-                execute = function (selection) { return __awaiter(_this, void 0, void 0, function () {
-                    var fragment, typeCondition;
-                    return __generator(this, function (_a) {
-                        if (!isClientFieldDescendant &&
-                            !execContext.selectionsToResolve.has(selection)) {
-                            // Skip selections without @client directives
-                            // (still processing if one of the ancestors or one of the child fields has @client directive)
-                            return [2 /*return*/];
-                        }
-                        if (!shouldInclude(selection, variables)) {
-                            // Skip this entirely.
-                            return [2 /*return*/];
-                        }
-                        if (isField(selection)) {
-                            return [2 /*return*/, this.resolveField(selection, isClientFieldDescendant, rootValue, execContext).then(function (fieldResult) {
-                                    var _a;
-                                    if (typeof fieldResult !== "undefined") {
-                                        resultsToMerge.push((_a = {},
-                                            _a[resultKeyNameFromField(selection)] = fieldResult,
-                                            _a));
-                                    }
-                                })];
-                        }
-                        if (isInlineFragment(selection)) {
-                            fragment = selection;
-                        }
-                        else {
-                            // This is a named fragment.
-                            fragment = fragmentMap[selection.name.value];
-                            invariant(fragment, 21, selection.name.value);
-                        }
-                        if (fragment && fragment.typeCondition) {
-                            typeCondition = fragment.typeCondition.name.value;
-                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {
-                                return [2 /*return*/, this.resolveSelectionSet(fragment.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (fragmentResult) {
-                                        resultsToMerge.push(fragmentResult);
-                                    })];
-                            }
-                        }
-                        return [2 /*return*/];
-                    });
-                }); };
-                return [2 /*return*/, Promise.all(selectionSet.selections.map(execute)).then(function () {
-                        return mergeDeepArray(resultsToMerge);
-                    })];
-            });
-        });
-    };
-    LocalState.prototype.resolveField = function (field, isClientFieldDescendant, rootValue, execContext) {
-        return __awaiter(this, void 0, void 0, function () {
-            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;
-            var _this = this;
-            return __generator(this, function (_a) {
-                if (!rootValue) {
-                    return [2 /*return*/, null];
-                }
-                variables = execContext.variables;
-                fieldName = field.name.value;
-                aliasedFieldName = resultKeyNameFromField(field);
-                aliasUsed = fieldName !== aliasedFieldName;
-                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];
-                resultPromise = Promise.resolve(defaultResult);
-                // Usually all local resolvers are run when passing through here, but
-                // if we've specifically identified that we only want to run forced
-                // resolvers (that is, resolvers for fields marked with
-                // `@client(always: true)`), then we'll skip running non-forced resolvers.
-                if (!execContext.onlyRunForcedResolvers ||
-                    this.shouldForceResolvers(field)) {
-                    resolverType = rootValue.__typename || execContext.defaultOperationType;
-                    resolverMap = this.resolvers && this.resolvers[resolverType];
-                    if (resolverMap) {
-                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];
-                        if (resolve) {
-                            resultPromise = Promise.resolve(
-                            // In case the resolve function accesses reactive variables,
-                            // set cacheSlot to the current cache instance.
-                            cacheSlot.withValue(this.cache, resolve, [
-                                rootValue,
-                                argumentsObjectFromField(field, variables),
-                                execContext.context,
-                                { field: field, fragmentMap: execContext.fragmentMap },
-                            ]));
-                        }
-                    }
-                }
-                return [2 /*return*/, resultPromise.then(function (result) {
-                        var _a, _b;
-                        if (result === void 0) { result = defaultResult; }
-                        // If an @export directive is associated with the current field, store
-                        // the `as` export variable name and current result for later use.
-                        if (field.directives) {
-                            field.directives.forEach(function (directive) {
-                                if (directive.name.value === "export" && directive.arguments) {
-                                    directive.arguments.forEach(function (arg) {
-                                        if (arg.name.value === "as" && arg.value.kind === "StringValue") {
-                                            execContext.exportedVariables[arg.value.value] = result;
-                                        }
-                                    });
-                                }
-                            });
-                        }
-                        // Handle all scalar types here.
-                        if (!field.selectionSet) {
-                            return result;
-                        }
-                        // From here down, the field has a selection set, which means it's trying
-                        // to query a GraphQLObjectType.
-                        if (result == null) {
-                            // Basically any field in a GraphQL response can be null, or missing
-                            return result;
-                        }
-                        var isClientField = (_b = (_a = field.directives) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.name.value === "client"; })) !== null && _b !== void 0 ? _b : false;
-                        if (Array.isArray(result)) {
-                            return _this.resolveSubSelectedArray(field, isClientFieldDescendant || isClientField, result, execContext);
-                        }
-                        // Returned value is an object, and the query has a sub-selection. Recurse.
-                        if (field.selectionSet) {
-                            return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant || isClientField, result, execContext);
-                        }
-                    })];
-            });
-        });
-    };
-    LocalState.prototype.resolveSubSelectedArray = function (field, isClientFieldDescendant, result, execContext) {
-        var _this = this;
-        return Promise.all(result.map(function (item) {
-            if (item === null) {
-                return null;
-            }
-            // This is a nested array, recurse.
-            if (Array.isArray(item)) {
-                return _this.resolveSubSelectedArray(field, isClientFieldDescendant, item, execContext);
-            }
-            // This is an object, run the selection set on it.
-            if (field.selectionSet) {
-                return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant, item, execContext);
-            }
-        }));
-    };
-    // Collect selection nodes on paths from document root down to all @client directives.
-    // This function takes into account transitive fragment spreads.
-    // Complexity equals to a single `visit` over the full document.
-    LocalState.prototype.collectSelectionsToResolve = function (mainDefinition, fragmentMap) {
-        var isSingleASTNode = function (node) { return !Array.isArray(node); };
-        var selectionsToResolveCache = this.selectionsToResolveCache;
-        function collectByDefinition(definitionNode) {
-            if (!selectionsToResolveCache.has(definitionNode)) {
-                var matches_1 = new Set();
-                selectionsToResolveCache.set(definitionNode, matches_1);
-                visit(definitionNode, {
-                    Directive: function (node, _, __, ___, ancestors) {
-                        if (node.name.value === "client") {
-                            ancestors.forEach(function (node) {
-                                if (isSingleASTNode(node) && isSelectionNode(node)) {
-                                    matches_1.add(node);
-                                }
-                            });
-                        }
-                    },
-                    FragmentSpread: function (spread, _, __, ___, ancestors) {
-                        var fragment = fragmentMap[spread.name.value];
-                        invariant(fragment, 22, spread.name.value);
-                        var fragmentSelections = collectByDefinition(fragment);
-                        if (fragmentSelections.size > 0) {
-                            // Fragment for this spread contains @client directive (either directly or transitively)
-                            // Collect selection nodes on paths from the root down to fields with the @client directive
-                            ancestors.forEach(function (node) {
-                                if (isSingleASTNode(node) && isSelectionNode(node)) {
-                                    matches_1.add(node);
-                                }
-                            });
-                            matches_1.add(spread);
-                            fragmentSelections.forEach(function (selection) {
-                                matches_1.add(selection);
-                            });
-                        }
-                    },
-                });
-            }
-            return selectionsToResolveCache.get(definitionNode);
-        }
-        return collectByDefinition(mainDefinition);
-    };
-    return LocalState;
-}());
-
-var hasSuggestedDevtools = false;
-/**
- * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries
- * and mutations) to a GraphQL spec-compliant server over an `ApolloLink` instance,
- * receive results from the server and cache the results in a store. It also delivers updates
- * to GraphQL queries through `Observable` instances.
- */
-var ApolloClient = /** @class */ (function () {
-    /**
-     * Constructs an instance of `ApolloClient`.
-     *
-     * @example
-     * ```js
-     * import { ApolloClient, InMemoryCache } from '@apollo/client';
-     *
-     * const cache = new InMemoryCache();
-     *
-     * const client = new ApolloClient({
-     *   // Provide required constructor fields
-     *   cache: cache,
-     *   uri: 'http://localhost:4000/',
-     *
-     *   // Provide some optional constructor fields
-     *   name: 'react-web-client',
-     *   version: '1.3',
-     *   queryDeduplication: false,
-     *   defaultOptions: {
-     *     watchQuery: {
-     *       fetchPolicy: 'cache-and-network',
-     *     },
-     *   },
-     * });
-     * ```
-     */
-    function ApolloClient(options) {
-        var _this = this;
-        var _a, _b, _c;
-        this.resetStoreCallbacks = [];
-        this.clearStoreCallbacks = [];
-        if (!options.cache) {
-            throw newInvariantError(16);
-        }
-        var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, documentTransform = options.documentTransform, _d = options.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = options.ssrForceFetchDelay, ssrForceFetchDelay = _e === void 0 ? 0 : _e, 
-        // Expose the client instance as window.__APOLLO_CLIENT__ and call
-        // onBroadcast in queryManager.broadcastQueries to enable browser
-        // devtools, but disable them by default in production.
-        connectToDevTools = options.connectToDevTools, _f = options.queryDeduplication, queryDeduplication = _f === void 0 ? true : _f, defaultOptions = options.defaultOptions, defaultContext = options.defaultContext, _g = options.assumeImmutableResults, assumeImmutableResults = _g === void 0 ? cache.assumeImmutableResults : _g, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwareness = options.clientAwareness, clientAwarenessName = options.name, clientAwarenessVersion = options.version, devtools = options.devtools, dataMasking = options.dataMasking;
-        if (globalThis.__DEV__ !== false) {
-            warnRemovedOption(options, "connectToDevTools", "ApolloClient", "Please use `devtools.enabled` instead.");
-            warnRemovedOption(options, "uri", "ApolloClient", "Please initialize an instance of `HttpLink` with `uri` instead.");
-            warnRemovedOption(options, "credentials", "ApolloClient", "Please initialize an instance of `HttpLink` with `credentials` instead.");
-            warnRemovedOption(options, "headers", "ApolloClient", "Please initialize an instance of `HttpLink` with `headers` instead.");
-            warnRemovedOption(options, "name", "ApolloClient", "Please use the `clientAwareness.name` option instead.");
-            warnRemovedOption(options, "version", "ApolloClient", "Please use the `clientAwareness.version` option instead.");
-            warnRemovedOption(options, "typeDefs", "ApolloClient");
-            if (!options.link) {
-                globalThis.__DEV__ !== false && invariant.warn(17);
-            }
-        }
-        var link = options.link;
-        if (!link) {
-            link =
-                uri ? new HttpLink({ uri: uri, credentials: credentials, headers: headers }) : ApolloLink.empty();
-        }
-        this.link = link;
-        this.cache = cache;
-        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;
-        this.queryDeduplication = queryDeduplication;
-        this.defaultOptions = defaultOptions || Object.create(null);
-        this.typeDefs = typeDefs;
-        this.devtoolsConfig = __assign(__assign({}, devtools), { enabled: (_a = devtools === null || devtools === void 0 ? void 0 : devtools.enabled) !== null && _a !== void 0 ? _a : connectToDevTools });
-        if (this.devtoolsConfig.enabled === undefined) {
-            this.devtoolsConfig.enabled = globalThis.__DEV__ !== false;
-        }
-        if (ssrForceFetchDelay) {
-            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);
-        }
-        this.watchQuery = this.watchQuery.bind(this);
-        this.query = this.query.bind(this);
-        this.mutate = this.mutate.bind(this);
-        this.watchFragment = this.watchFragment.bind(this);
-        this.resetStore = this.resetStore.bind(this);
-        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);
-        this.version = version;
-        this.localState = new LocalState({
-            cache: cache,
-            client: this,
-            resolvers: resolvers,
-            fragmentMatcher: fragmentMatcher,
-        });
-        this.queryManager = new QueryManager({
-            cache: this.cache,
-            link: this.link,
-            defaultOptions: this.defaultOptions,
-            defaultContext: defaultContext,
-            documentTransform: documentTransform,
-            queryDeduplication: queryDeduplication,
-            ssrMode: ssrMode,
-            dataMasking: !!dataMasking,
-            clientAwareness: {
-                name: (_b = clientAwareness === null || clientAwareness === void 0 ? void 0 : clientAwareness.name) !== null && _b !== void 0 ? _b : clientAwarenessName,
-                version: (_c = clientAwareness === null || clientAwareness === void 0 ? void 0 : clientAwareness.version) !== null && _c !== void 0 ? _c : clientAwarenessVersion,
-            },
-            localState: this.localState,
-            assumeImmutableResults: assumeImmutableResults,
-            onBroadcast: this.devtoolsConfig.enabled ?
-                function () {
-                    if (_this.devToolsHookCb) {
-                        _this.devToolsHookCb({
-                            action: {},
-                            state: {
-                                queries: _this.queryManager.getQueryStore(),
-                                mutations: _this.queryManager.mutationStore || {},
-                            },
-                            dataWithOptimisticResults: _this.cache.extract(true),
-                        });
-                    }
-                }
-                : void 0,
-        });
-        if (this.devtoolsConfig.enabled)
-            this.connectToDevTools();
-    }
-    Object.defineProperty(ApolloClient.prototype, "prioritizeCacheValues", {
-        /**
-         * Whether to prioritize cache values over network results when `query` or `watchQuery` is called.
-         * This will essentially turn a `"network-only"` or `"cache-and-network"` fetchPolicy into a `"cache-first"` fetchPolicy,
-         * but without influencing the `fetchPolicy` of the created `ObservableQuery` long-term.
-         *
-         * This can e.g. be used to prioritize the cache during the first render after SSR.
-         */
-        get: function () {
-            return this.disableNetworkFetches;
-        },
-        set: function (value) {
-            this.disableNetworkFetches = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ApolloClient.prototype.connectToDevTools = function () {
-        if (typeof window === "undefined") {
-            return;
-        }
-        var windowWithDevTools = window;
-        var devtoolsSymbol = Symbol.for("apollo.devtools");
-        (windowWithDevTools[devtoolsSymbol] =
-            windowWithDevTools[devtoolsSymbol] || []).push(this);
-        windowWithDevTools.__APOLLO_CLIENT__ = this;
-        /**
-         * Suggest installing the devtools for developers who don't have them
-         */
-        if (!hasSuggestedDevtools && globalThis.__DEV__ !== false) {
-            hasSuggestedDevtools = true;
-            if (window.document &&
-                window.top === window.self &&
-                /^(https?|file):$/.test(window.location.protocol)) {
-                setTimeout(function () {
-                    if (!window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__) {
-                        var nav = window.navigator;
-                        var ua = nav && nav.userAgent;
-                        var url = void 0;
-                        if (typeof ua === "string") {
-                            if (ua.indexOf("Chrome/") > -1) {
-                                url =
-                                    "https://chrome.google.com/webstore/detail/" +
-                                        "apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm";
-                            }
-                            else if (ua.indexOf("Firefox/") > -1) {
-                                url =
-                                    "https://addons.mozilla.org/en-US/firefox/addon/apollo-developer-tools/";
-                            }
-                        }
-                        if (url) {
-                            globalThis.__DEV__ !== false && invariant.log("Download the Apollo DevTools for a better development " +
-                                "experience: %s", url);
-                        }
-                    }
-                }, 10000);
-            }
-        }
-    };
-    Object.defineProperty(ApolloClient.prototype, "documentTransform", {
-        /**
-         * The `DocumentTransform` used to modify GraphQL documents before a request
-         * is made. If a custom `DocumentTransform` is not provided, this will be the
-         * default document transform.
-         */
-        get: function () {
-            return this.queryManager.documentTransform;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Call this method to terminate any active client processes, making it safe
-     * to dispose of this `ApolloClient` instance.
-     */
-    ApolloClient.prototype.stop = function () {
-        this.queryManager.stop();
-    };
-    /**
-     * This watches the cache store of the query according to the options specified and
-     * returns an `ObservableQuery`. We can subscribe to this `ObservableQuery` and
-     * receive updated results through an observer when the cache store changes.
-     *
-     * Note that this method is not an implementation of GraphQL subscriptions. Rather,
-     * it uses Apollo's store in order to reactively deliver updates to your query results.
-     *
-     * For example, suppose you call watchQuery on a GraphQL query that fetches a person's
-     * first and last name and this person has a particular object identifier, provided by
-     * dataIdFromObject. Later, a different query fetches that same person's
-     * first and last name and the first name has now changed. Then, any observers associated
-     * with the results of the first query will be updated with a new result object.
-     *
-     * Note that if the cache does not change, the subscriber will *not* be notified.
-     *
-     * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for
-     * a description of store reactivity.
-     */
-    ApolloClient.prototype.watchQuery = function (options) {
-        if (this.defaultOptions.watchQuery) {
-            options = mergeOptions(this.defaultOptions.watchQuery, options);
-        }
-        // XXX Overwriting options is probably not the best way to do this long term...
-        if (this.disableNetworkFetches &&
-            (options.fetchPolicy === "network-only" ||
-                options.fetchPolicy === "cache-and-network")) {
-            options = __assign(__assign({}, options), { fetchPolicy: "cache-first" });
-        }
-        if (globalThis.__DEV__ !== false) {
-            warnRemovedOption(options, "canonizeResults", "client.watchQuery");
-            warnRemovedOption(options, "partialRefetch", "client.watchQuery");
-        }
-        return this.queryManager.watchQuery(options);
-    };
-    /**
-     * This resolves a single query according to the options specified and
-     * returns a `Promise` which is either resolved with the resulting data
-     * or rejected with an error.
-     *
-     * @param options - An object of type `QueryOptions` that allows us to
-     * describe how this query should be treated e.g. whether it should hit the
-     * server at all or just resolve from the cache, etc.
-     */
-    ApolloClient.prototype.query = function (options) {
-        if (this.defaultOptions.query) {
-            options = mergeOptions(this.defaultOptions.query, options);
-        }
-        invariant(options.fetchPolicy !== "cache-and-network", 18);
-        if (this.disableNetworkFetches && options.fetchPolicy === "network-only") {
-            options = __assign(__assign({}, options), { fetchPolicy: "cache-first" });
-        }
-        if (globalThis.__DEV__ !== false) {
-            warnRemovedOption(options, "canonizeResults", "client.query");
-            warnRemovedOption(options, "notifyOnNetworkStatusChange", "client.query", "This option does not affect `client.query` and can be safely removed.");
-            if (options.fetchPolicy === "standby") {
-                globalThis.__DEV__ !== false && invariant.warn(19);
-            }
-        }
-        return this.queryManager.query(options);
-    };
-    /**
-     * This resolves a single mutation according to the options specified and returns a
-     * Promise which is either resolved with the resulting data or rejected with an
-     * error. In some cases both `data` and `errors` might be undefined, for example
-     * when `errorPolicy` is set to `'ignore'`.
-     *
-     * It takes options as an object with the following keys and values:
-     */
-    ApolloClient.prototype.mutate = function (options) {
-        if (this.defaultOptions.mutate) {
-            options = mergeOptions(this.defaultOptions.mutate, options);
-        }
-        return this.queryManager.mutate(options);
-    };
-    /**
-     * This subscribes to a graphql subscription according to the options specified and returns an
-     * `Observable` which either emits received data or an error.
-     */
-    ApolloClient.prototype.subscribe = function (options) {
-        var _this = this;
-        var id = this.queryManager.generateQueryId();
-        return this.queryManager
-            .startGraphQLSubscription(options)
-            .map(function (result) { return (__assign(__assign({}, result), { data: _this.queryManager.maskOperation({
-                document: options.query,
-                data: result.data,
-                fetchPolicy: options.fetchPolicy,
-                id: id,
-            }) })); });
-    };
-    /**
-     * Tries to read some data from the store in the shape of the provided
-     * GraphQL query without making a network request. This method will start at
-     * the root query. To start at a specific id returned by `dataIdFromObject`
-     * use `readFragment`.
-     *
-     * @param optimistic - Set to `true` to allow `readQuery` to return
-     * optimistic results. Is `false` by default.
-     */
-    ApolloClient.prototype.readQuery = function (options, optimistic) {
-        if (optimistic === void 0) { optimistic = false; }
-        return this.cache.readQuery(options, optimistic);
-    };
-    /**
-     * Watches the cache store of the fragment according to the options specified
-     * and returns an `Observable`. We can subscribe to this
-     * `Observable` and receive updated results through an
-     * observer when the cache store changes.
-     *
-     * You must pass in a GraphQL document with a single fragment or a document
-     * with multiple fragments that represent what you are reading. If you pass
-     * in a document with multiple fragments then you must also specify a
-     * `fragmentName`.
-     *
-     * @since 3.10.0
-     * @param options - An object of type `WatchFragmentOptions` that allows
-     * the cache to identify the fragment and optionally specify whether to react
-     * to optimistic updates.
-     */
-    ApolloClient.prototype.watchFragment = function (options) {
-        var _a;
-        return this.cache.watchFragment(__assign(__assign({}, options), (_a = {}, _a[Symbol.for("apollo.dataMasking")] = this.queryManager.dataMasking, _a)));
-    };
-    /**
-     * Tries to read some data from the store in the shape of the provided
-     * GraphQL fragment without making a network request. This method will read a
-     * GraphQL fragment from any arbitrary id that is currently cached, unlike
-     * `readQuery` which will only read from the root query.
-     *
-     * You must pass in a GraphQL document with a single fragment or a document
-     * with multiple fragments that represent what you are reading. If you pass
-     * in a document with multiple fragments then you must also specify a
-     * `fragmentName`.
-     *
-     * @param optimistic - Set to `true` to allow `readFragment` to return
-     * optimistic results. Is `false` by default.
-     */
-    ApolloClient.prototype.readFragment = function (options, optimistic) {
-        if (optimistic === void 0) { optimistic = false; }
-        return this.cache.readFragment(options, optimistic);
-    };
-    /**
-     * Writes some data in the shape of the provided GraphQL query directly to
-     * the store. This method will start at the root query. To start at a
-     * specific id returned by `dataIdFromObject` then use `writeFragment`.
-     */
-    ApolloClient.prototype.writeQuery = function (options) {
-        var ref = this.cache.writeQuery(options);
-        if (options.broadcast !== false) {
-            this.queryManager.broadcastQueries();
-        }
-        return ref;
-    };
-    /**
-     * Writes some data in the shape of the provided GraphQL fragment directly to
-     * the store. This method will write to a GraphQL fragment from any arbitrary
-     * id that is currently cached, unlike `writeQuery` which will only write
-     * from the root query.
-     *
-     * You must pass in a GraphQL document with a single fragment or a document
-     * with multiple fragments that represent what you are writing. If you pass
-     * in a document with multiple fragments then you must also specify a
-     * `fragmentName`.
-     */
-    ApolloClient.prototype.writeFragment = function (options) {
-        var ref = this.cache.writeFragment(options);
-        if (options.broadcast !== false) {
-            this.queryManager.broadcastQueries();
-        }
-        return ref;
-    };
-    ApolloClient.prototype.__actionHookForDevTools = function (cb) {
-        this.devToolsHookCb = cb;
-    };
-    ApolloClient.prototype.__requestRaw = function (payload) {
-        return execute(this.link, payload);
-    };
-    /**
-     * Resets your entire store by clearing out your cache and then re-executing
-     * all of your active queries. This makes it so that you may guarantee that
-     * there is no data left in your store from a time before you called this
-     * method.
-     *
-     * `resetStore()` is useful when your user just logged out. You’ve removed the
-     * user session, and you now want to make sure that any references to data you
-     * might have fetched while the user session was active is gone.
-     *
-     * It is important to remember that `resetStore()` *will* refetch any active
-     * queries. This means that any components that might be mounted will execute
-     * their queries again using your network interface. If you do not want to
-     * re-execute any queries then you should make sure to stop watching any
-     * active queries.
-     */
-    ApolloClient.prototype.resetStore = function () {
-        var _this = this;
-        return Promise.resolve()
-            .then(function () {
-            return _this.queryManager.clearStore({
-                discardWatches: false,
-            });
-        })
-            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })
-            .then(function () { return _this.reFetchObservableQueries(); });
-    };
-    /**
-     * Remove all data from the store. Unlike `resetStore`, `clearStore` will
-     * not refetch any active queries.
-     */
-    ApolloClient.prototype.clearStore = function () {
-        var _this = this;
-        return Promise.resolve()
-            .then(function () {
-            return _this.queryManager.clearStore({
-                discardWatches: true,
-            });
-        })
-            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });
-    };
-    /**
-     * Allows callbacks to be registered that are executed when the store is
-     * reset. `onResetStore` returns an unsubscribe function that can be used
-     * to remove registered callbacks.
-     */
-    ApolloClient.prototype.onResetStore = function (cb) {
-        var _this = this;
-        this.resetStoreCallbacks.push(cb);
-        return function () {
-            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });
-        };
-    };
-    /**
-     * Allows callbacks to be registered that are executed when the store is
-     * cleared. `onClearStore` returns an unsubscribe function that can be used
-     * to remove registered callbacks.
-     */
-    ApolloClient.prototype.onClearStore = function (cb) {
-        var _this = this;
-        this.clearStoreCallbacks.push(cb);
-        return function () {
-            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });
-        };
-    };
-    /**
-     * Refetches all of your active queries.
-     *
-     * `reFetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage
-     *
-     * It is important to remember that `reFetchObservableQueries()` *will* refetch any active
-     * queries. This means that any components that might be mounted will execute
-     * their queries again using your network interface. If you do not want to
-     * re-execute any queries then you should make sure to stop watching any
-     * active queries.
-     * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
-     */
-    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {
-        return this.queryManager.reFetchObservableQueries(includeStandby);
-    };
-    /**
-     * Refetches specified active queries. Similar to "reFetchObservableQueries()" but with a specific list of queries.
-     *
-     * `refetchQueries()` is useful for use cases to imperatively refresh a selection of queries.
-     *
-     * It is important to remember that `refetchQueries()` *will* refetch specified active
-     * queries. This means that any components that might be mounted will execute
-     * their queries again using your network interface. If you do not want to
-     * re-execute any queries then you should make sure to stop watching any
-     * active queries.
-     */
-    ApolloClient.prototype.refetchQueries = function (options) {
-        var map = this.queryManager.refetchQueries(options);
-        var queries = [];
-        var results = [];
-        map.forEach(function (result, obsQuery) {
-            queries.push(obsQuery);
-            results.push(result);
-        });
-        var result = Promise.all(results);
-        // In case you need the raw results immediately, without awaiting
-        // Promise.all(results):
-        result.queries = queries;
-        result.results = results;
-        // If you decide to ignore the result Promise because you're using
-        // result.queries and result.results instead, you shouldn't have to worry
-        // about preventing uncaught rejections for the Promise.all result.
-        result.catch(function (error) {
-            globalThis.__DEV__ !== false && invariant.debug(20, error);
-        });
-        return result;
-    };
-    /**
-     * Get all currently active `ObservableQuery` objects, in a `Map` keyed by
-     * query ID strings.
-     *
-     * An "active" query is one that has observers and a `fetchPolicy` other than
-     * "standby" or "cache-only".
-     *
-     * You can include all `ObservableQuery` objects (including the inactive ones)
-     * by passing "all" instead of "active", or you can include just a subset of
-     * active queries by passing an array of query names or DocumentNode objects.
-     */
-    ApolloClient.prototype.getObservableQueries = function (include) {
-        if (include === void 0) { include = "active"; }
-        return this.queryManager.getObservableQueries(include);
-    };
-    /**
-     * Exposes the cache's complete state, in a serializable format for later restoration.
-     */
-    ApolloClient.prototype.extract = function (optimistic) {
-        return this.cache.extract(optimistic);
-    };
-    /**
-     * Replaces existing state in the cache (if any) with the values expressed by
-     * `serializedState`.
-     *
-     * Called when hydrating a cache (server side rendering, or offline storage),
-     * and also (potentially) during hot reloads.
-     */
-    ApolloClient.prototype.restore = function (serializedState) {
-        return this.cache.restore(serializedState);
-    };
-    /**
-     * Add additional local resolvers.
-     *
-     * @deprecated `addResolvers` will been removed in Apollo Client 4.0. It is
-     * safe to continue using this method in Apollo Client 3.x.
-     *
-     * **Recommended now**
-     *
-     * No action needed
-     *
-     * **When upgrading**
-     *
-     * Use `client.localState.addResolvers(resolvers)`. Alternatively, store
-     * the `LocalState` instance in a separate variable and call `addResolvers` on
-     * that.
-     */
-    ApolloClient.prototype.addResolvers = function (resolvers) {
-        this.localState.addResolvers(resolvers);
-    };
-    /**
-     * Set (override existing) local resolvers.
-     *
-     * @deprecated `setResolvers` will been removed in Apollo Client 4.0. It is
-     * safe to continue using this method in Apollo Client 3.x.
-     *
-     * **Recommended now**
-     *
-     * If possible, stop using the `setResolvers` method.
-     *
-     * **When upgrading**
-     *
-     * Remove the use of `setResolvers`.
-     */
-    ApolloClient.prototype.setResolvers = function (resolvers) {
-        this.localState.setResolvers(resolvers);
-    };
-    /**
-     * Get all registered local resolvers.
-     *
-     * @deprecated `getResolvers` will be removed in Apollo Client 4.0. It is
-     * safe to continue using this method in Apollo Client 3.x.
-     *
-     * **Recommended now**
-     *
-     * If possible, stop using the `getResolvers` method.
-     *
-     * **When upgrading**
-     *
-     * Remove the use of `getResolvers`.
-     */
-    ApolloClient.prototype.getResolvers = function () {
-        return this.localState.getResolvers();
-    };
-    /**
-     * Set a custom local state fragment matcher.
-     *
-     * @deprecated Custom fragment matchers will no longer be supported in Apollo
-     * Client 4.0 and has been replaced by `cache.fragmentMatches`. It is safe to
-     * continue using `setLocalStateFragmentMatcher` in Apollo Client 3.x.
-     *
-     * **Recommended now**
-     *
-     * No action needed
-     *
-     * **When upgrading**
-     *
-     * Leverage `possibleTypes` with `InMemoryCache` to ensure fragments match
-     * correctly. Ensure `possibleTypes` include local types if needed. If working
-     * with a 3rd party cache implementation, ensure the 3rd party cache implements
-     * the `cache.fragmentMatches` method. This function should no longer be used.
-     */
-    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {
-        this.localState.setFragmentMatcher(fragmentMatcher);
-    };
-    /**
-     * Define a new ApolloLink (or link chain) that Apollo Client will use.
-     */
-    ApolloClient.prototype.setLink = function (newLink) {
-        this.link = this.queryManager.link = newLink;
-    };
-    Object.defineProperty(ApolloClient.prototype, "defaultContext", {
-        get: function () {
-            return this.queryManager.defaultContext;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return ApolloClient;
-}());
-if (globalThis.__DEV__ !== false) {
-    ApolloClient.prototype.getMemoryInternals = getApolloClientMemoryInternals;
-}
-
-function setContext(setter) {
-    return new ApolloLink(function (operation, forward) {
-        var request = __rest(operation, []);
-        return new Observable(function (observer) {
-            var handle;
-            var closed = false;
-            Promise.resolve(request)
-                .then(function (req) { return setter(req, operation.getContext()); })
-                .then(operation.setContext)
-                .then(function () {
-                // if the observer is already closed, no need to subscribe.
-                if (closed)
-                    return;
-                handle = forward(operation).subscribe({
-                    next: observer.next.bind(observer),
-                    error: observer.error.bind(observer),
-                    complete: observer.complete.bind(observer),
-                });
-            })
-                .catch(observer.error.bind(observer));
-            return function () {
-                closed = true;
-                if (handle)
-                    handle.unsubscribe();
-            };
-        });
-    });
-}
-
-function onError(errorHandler) {
-    return new ApolloLink(function (operation, forward) {
-        return new Observable(function (observer) {
-            var sub;
-            var retriedSub;
-            var retriedResult;
-            try {
-                sub = forward(operation).subscribe({
-                    next: function (result) {
-                        if (result.errors) {
-                            retriedResult = errorHandler({
-                                graphQLErrors: result.errors,
-                                response: result,
-                                operation: operation,
-                                forward: forward,
-                            });
-                        }
-                        else if (graphQLResultHasProtocolErrors(result)) {
-                            retriedResult = errorHandler({
-                                protocolErrors: result.extensions[PROTOCOL_ERRORS_SYMBOL],
-                                response: result,
-                                operation: operation,
-                                forward: forward,
-                            });
-                        }
-                        if (retriedResult) {
-                            retriedSub = retriedResult.subscribe({
-                                next: observer.next.bind(observer),
-                                error: observer.error.bind(observer),
-                                complete: observer.complete.bind(observer),
-                            });
-                            return;
-                        }
-                        observer.next(result);
-                    },
-                    error: function (networkError) {
-                        retriedResult = errorHandler({
-                            operation: operation,
-                            networkError: networkError,
-                            //Network errors can return GraphQL errors on for example a 403
-                            graphQLErrors: (networkError &&
-                                networkError.result &&
-                                networkError.result.errors) ||
-                                void 0,
-                            forward: forward,
-                        });
-                        if (retriedResult) {
-                            retriedSub = retriedResult.subscribe({
-                                next: observer.next.bind(observer),
-                                error: observer.error.bind(observer),
-                                complete: observer.complete.bind(observer),
-                            });
-                            return;
-                        }
-                        observer.error(networkError);
-                    },
-                    complete: function () {
-                        // disable the previous sub from calling complete on observable
-                        // if retry is in flight.
-                        if (!retriedResult) {
-                            observer.complete.bind(observer)();
-                        }
-                    },
-                });
-            }
-            catch (e) {
-                errorHandler({ networkError: e, operation: operation, forward: forward });
-                observer.error(e);
-            }
-            return function () {
-                if (sub)
-                    sub.unsubscribe();
-                if (retriedSub)
-                    sub.unsubscribe();
-            };
-        });
-    });
-}
-/** @class */ ((function (_super) {
-    __extends(ErrorLink, _super);
-    function ErrorLink(errorHandler) {
-        var _this = _super.call(this) || this;
-        _this.link = onError(errorHandler);
-        return _this;
-    }
-    ErrorLink.prototype.request = function (operation, forward) {
-        return this.link.request(operation, forward);
-    };
-    return ErrorLink;
-})(ApolloLink));
-
-export { ApolloClient, ApolloError, HttpLink, onError, setContext };
-//# sourceMappingURL=apollo-client.client-DE7JUXjy.js.map