@apollo/client 3.13.4 → 4.0.0-alpha.0

package/utilities/utilities.cjs

@@ -1,1809 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var globals = require('./globals');
-var graphql = require('graphql');
-var trie = require('@wry/trie');
-var tslib = require('tslib');
-var caches = require('@wry/caches');
-var optimism = require('optimism');
-var zenObservableTs = require('zen-observable-ts');
-require('symbol-observable');
-
-function shouldInclude(_a, variables) {
-    var directives = _a.directives;
-    if (!directives || !directives.length) {
-        return true;
-    }
-    return getInclusionDirectives(directives).every(function (_a) {
-        var directive = _a.directive, ifArgument = _a.ifArgument;
-        var evaledValue = false;
-        if (ifArgument.value.kind === "Variable") {
-            evaledValue =
-                variables && variables[ifArgument.value.name.value];
-            globals.invariant(evaledValue !== void 0, 78, directive.name.value);
-        }
-        else {
-            evaledValue = ifArgument.value.value;
-        }
-        return directive.name.value === "skip" ? !evaledValue : evaledValue;
-    });
-}
-function getDirectiveNames(root) {
-    var names = [];
-    graphql.visit(root, {
-        Directive: function (node) {
-            names.push(node.name.value);
-        },
-    });
-    return names;
-}
-var hasAnyDirectives = function (names, root) {
-    return hasDirectives(names, root, false);
-};
-var hasAllDirectives = function (names, root) {
-    return hasDirectives(names, root, true);
-};
-function hasDirectives(names, root, all) {
-    var nameSet = new Set(names);
-    var uniqueCount = nameSet.size;
-    graphql.visit(root, {
-        Directive: function (node) {
-            if (nameSet.delete(node.name.value) && (!all || !nameSet.size)) {
-                return graphql.BREAK;
-            }
-        },
-    });
-    return all ? !nameSet.size : nameSet.size < uniqueCount;
-}
-function hasClientExports(document) {
-    return document && hasDirectives(["client", "export"], document, true);
-}
-function isInclusionDirective(_a) {
-    var value = _a.name.value;
-    return value === "skip" || value === "include";
-}
-function getInclusionDirectives(directives) {
-    var result = [];
-    if (directives && directives.length) {
-        directives.forEach(function (directive) {
-            if (!isInclusionDirective(directive))
-                return;
-            var directiveArguments = directive.arguments;
-            var directiveName = directive.name.value;
-            globals.invariant(directiveArguments && directiveArguments.length === 1, 79, directiveName);
-            var ifArgument = directiveArguments[0];
-            globals.invariant(ifArgument.name && ifArgument.name.value === "if", 80, directiveName);
-            var ifValue = ifArgument.value;
-            globals.invariant(ifValue &&
-                (ifValue.kind === "Variable" || ifValue.kind === "BooleanValue"), 81, directiveName);
-            result.push({ directive: directive, ifArgument: ifArgument });
-        });
-    }
-    return result;
-}
-function getFragmentMaskMode(fragment) {
-    var _a, _b;
-    var directive = (_a = fragment.directives) === null || _a === void 0 ? void 0 : _a.find(function (_a) {
-        var name = _a.name;
-        return name.value === "unmask";
-    });
-    if (!directive) {
-        return "mask";
-    }
-    var modeArg = (_b = directive.arguments) === null || _b === void 0 ? void 0 : _b.find(function (_a) {
-        var name = _a.name;
-        return name.value === "mode";
-    });
-    if (globalThis.__DEV__ !== false) {
-        if (modeArg) {
-            if (modeArg.value.kind === graphql.Kind.VARIABLE) {
-                globalThis.__DEV__ !== false && globals.invariant.warn(82);
-            }
-            else if (modeArg.value.kind !== graphql.Kind.STRING) {
-                globalThis.__DEV__ !== false && globals.invariant.warn(83);
-            }
-            else if (modeArg.value.value !== "migrate") {
-                globalThis.__DEV__ !== false && globals.invariant.warn(84, modeArg.value.value);
-            }
-        }
-    }
-    if (modeArg &&
-        "value" in modeArg.value &&
-        modeArg.value.value === "migrate") {
-        return "migrate";
-    }
-    return "unmask";
-}
-
-var isReactNative = globals.maybe(function () { return navigator.product; }) == "ReactNative";
-var canUseWeakMap = typeof WeakMap === "function" &&
-    !(isReactNative && !global.HermesInternal);
-var canUseWeakSet = typeof WeakSet === "function";
-var canUseSymbol = typeof Symbol === "function" && typeof Symbol.for === "function";
-var canUseAsyncIteratorSymbol = canUseSymbol && Symbol.asyncIterator;
-var canUseDOM = typeof globals.maybe(function () { return window.document.createElement; }) === "function";
-var usingJSDOM =
-globals.maybe(function () { return navigator.userAgent.indexOf("jsdom") >= 0; }) || false;
-var canUseLayoutEffect = (canUseDOM || isReactNative) && !usingJSDOM;
-
-function isNonNullObject(obj) {
-    return obj !== null && typeof obj === "object";
-}
-function isPlainObject(obj) {
-    return (obj !== null &&
-        typeof obj === "object" &&
-        (Object.getPrototypeOf(obj) === Object.prototype ||
-            Object.getPrototypeOf(obj) === null));
-}
-
-function getFragmentQueryDocument(document, fragmentName) {
-    var actualFragmentName = fragmentName;
-    var fragments = [];
-    document.definitions.forEach(function (definition) {
-        if (definition.kind === "OperationDefinition") {
-            throw globals.newInvariantError(
-                85,
-                definition.operation,
-                definition.name ? " named '".concat(definition.name.value, "'") : ""
-            );
-        }
-        if (definition.kind === "FragmentDefinition") {
-            fragments.push(definition);
-        }
-    });
-    if (typeof actualFragmentName === "undefined") {
-        globals.invariant(fragments.length === 1, 86, fragments.length);
-        actualFragmentName = fragments[0].name.value;
-    }
-    var query = tslib.__assign(tslib.__assign({}, document), { definitions: tslib.__spreadArray([
-            {
-                kind: "OperationDefinition",
-                operation: "query",
-                selectionSet: {
-                    kind: "SelectionSet",
-                    selections: [
-                        {
-                            kind: "FragmentSpread",
-                            name: {
-                                kind: "Name",
-                                value: actualFragmentName,
-                            },
-                        },
-                    ],
-                },
-            }
-        ], document.definitions, true) });
-    return query;
-}
-function createFragmentMap(fragments) {
-    if (fragments === void 0) { fragments = []; }
-    var symTable = {};
-    fragments.forEach(function (fragment) {
-        symTable[fragment.name.value] = fragment;
-    });
-    return symTable;
-}
-function getFragmentFromSelection(selection, fragmentMap) {
-    switch (selection.kind) {
-        case "InlineFragment":
-            return selection;
-        case "FragmentSpread": {
-            var fragmentName = selection.name.value;
-            if (typeof fragmentMap === "function") {
-                return fragmentMap(fragmentName);
-            }
-            var fragment = fragmentMap && fragmentMap[fragmentName];
-            globals.invariant(fragment, 87, fragmentName);
-            return fragment || null;
-        }
-        default:
-            return null;
-    }
-}
-function isFullyUnmaskedOperation(document) {
-    var isUnmasked = true;
-    graphql.visit(document, {
-        FragmentSpread: function (node) {
-            isUnmasked =
-                !!node.directives &&
-                    node.directives.some(function (directive) { return directive.name.value === "unmask"; });
-            if (!isUnmasked) {
-                return graphql.BREAK;
-            }
-        },
-    });
-    return isUnmasked;
-}
-
-var scheduledCleanup = new WeakSet();
-function schedule(cache) {
-    if (cache.size <= (cache.max || -1)) {
-        return;
-    }
-    if (!scheduledCleanup.has(cache)) {
-        scheduledCleanup.add(cache);
-        setTimeout(function () {
-            cache.clean();
-            scheduledCleanup.delete(cache);
-        }, 100);
-    }
-}
-var AutoCleanedWeakCache = function (max, dispose) {
-    var cache = new caches.WeakCache(max, dispose);
-    cache.set = function (key, value) {
-        var ret = caches.WeakCache.prototype.set.call(this, key, value);
-        schedule(this);
-        return ret;
-    };
-    return cache;
-};
-var AutoCleanedStrongCache = function (max, dispose) {
-    var cache = new caches.StrongCache(max, dispose);
-    cache.set = function (key, value) {
-        var ret = caches.StrongCache.prototype.set.call(this, key, value);
-        schedule(this);
-        return ret;
-    };
-    return cache;
-};
-
-var cacheSizeSymbol = Symbol.for("apollo.cacheSize");
-var cacheSizes = tslib.__assign({}, globals.global[cacheSizeSymbol]);
-
-var globalCaches = {};
-function registerGlobalCache(name, getSize) {
-    globalCaches[name] = getSize;
-}
-
-var canonicalStringify = Object.assign(function canonicalStringify(value) {
-    return JSON.stringify(value, stableObjectReplacer);
-}, {
-    reset: function () {
-        sortingMap = new AutoCleanedStrongCache(cacheSizes.canonicalStringify || 1000 );
-    },
-});
-if (globalThis.__DEV__ !== false) {
-    registerGlobalCache("canonicalStringify", function () { return sortingMap.size; });
-}
-var sortingMap;
-canonicalStringify.reset();
-function stableObjectReplacer(key, value) {
-    if (value && typeof value === "object") {
-        var proto = Object.getPrototypeOf(value);
-        if (proto === Object.prototype || proto === null) {
-            var keys = Object.keys(value);
-            if (keys.every(everyKeyInOrder))
-                return value;
-            var unsortedKey = JSON.stringify(keys);
-            var sortedKeys = sortingMap.get(unsortedKey);
-            if (!sortedKeys) {
-                keys.sort();
-                var sortedKey = JSON.stringify(keys);
-                sortedKeys = sortingMap.get(sortedKey) || keys;
-                sortingMap.set(unsortedKey, sortedKeys);
-                sortingMap.set(sortedKey, sortedKeys);
-            }
-            var sortedObject_1 = Object.create(proto);
-            sortedKeys.forEach(function (key) {
-                sortedObject_1[key] = value[key];
-            });
-            return sortedObject_1;
-        }
-    }
-    return value;
-}
-function everyKeyInOrder(key, i, keys) {
-    return i === 0 || keys[i - 1] <= key;
-}
-
-function makeReference(id) {
-    return { __ref: String(id) };
-}
-function isReference(obj) {
-    return Boolean(obj && typeof obj === "object" && typeof obj.__ref === "string");
-}
-function isDocumentNode(value) {
-    return (isNonNullObject(value) &&
-        value.kind === "Document" &&
-        Array.isArray(value.definitions));
-}
-function isStringValue(value) {
-    return value.kind === "StringValue";
-}
-function isBooleanValue(value) {
-    return value.kind === "BooleanValue";
-}
-function isIntValue(value) {
-    return value.kind === "IntValue";
-}
-function isFloatValue(value) {
-    return value.kind === "FloatValue";
-}
-function isVariable(value) {
-    return value.kind === "Variable";
-}
-function isObjectValue(value) {
-    return value.kind === "ObjectValue";
-}
-function isListValue(value) {
-    return value.kind === "ListValue";
-}
-function isEnumValue(value) {
-    return value.kind === "EnumValue";
-}
-function isNullValue(value) {
-    return value.kind === "NullValue";
-}
-function valueToObjectRepresentation(argObj, name, value, variables) {
-    if (isIntValue(value) || isFloatValue(value)) {
-        argObj[name.value] = Number(value.value);
-    }
-    else if (isBooleanValue(value) || isStringValue(value)) {
-        argObj[name.value] = value.value;
-    }
-    else if (isObjectValue(value)) {
-        var nestedArgObj_1 = {};
-        value.fields.map(function (obj) {
-            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);
-        });
-        argObj[name.value] = nestedArgObj_1;
-    }
-    else if (isVariable(value)) {
-        var variableValue = (variables || {})[value.name.value];
-        argObj[name.value] = variableValue;
-    }
-    else if (isListValue(value)) {
-        argObj[name.value] = value.values.map(function (listValue) {
-            var nestedArgArrayObj = {};
-            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);
-            return nestedArgArrayObj[name.value];
-        });
-    }
-    else if (isEnumValue(value)) {
-        argObj[name.value] = value.value;
-    }
-    else if (isNullValue(value)) {
-        argObj[name.value] = null;
-    }
-    else {
-        throw globals.newInvariantError(96, name.value, value.kind);
-    }
-}
-function storeKeyNameFromField(field, variables) {
-    var directivesObj = null;
-    if (field.directives) {
-        directivesObj = {};
-        field.directives.forEach(function (directive) {
-            directivesObj[directive.name.value] = {};
-            if (directive.arguments) {
-                directive.arguments.forEach(function (_a) {
-                    var name = _a.name, value = _a.value;
-                    return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);
-                });
-            }
-        });
-    }
-    var argObj = null;
-    if (field.arguments && field.arguments.length) {
-        argObj = {};
-        field.arguments.forEach(function (_a) {
-            var name = _a.name, value = _a.value;
-            return valueToObjectRepresentation(argObj, name, value, variables);
-        });
-    }
-    return getStoreKeyName(field.name.value, argObj, directivesObj);
-}
-var KNOWN_DIRECTIVES = [
-    "connection",
-    "include",
-    "skip",
-    "client",
-    "rest",
-    "export",
-    "nonreactive",
-];
-var storeKeyNameStringify = canonicalStringify;
-var getStoreKeyName = Object.assign(function (fieldName, args, directives) {
-    if (args &&
-        directives &&
-        directives["connection"] &&
-        directives["connection"]["key"]) {
-        if (directives["connection"]["filter"] &&
-            directives["connection"]["filter"].length > 0) {
-            var filterKeys = directives["connection"]["filter"] ?
-                directives["connection"]["filter"]
-                : [];
-            filterKeys.sort();
-            var filteredArgs_1 = {};
-            filterKeys.forEach(function (key) {
-                filteredArgs_1[key] = args[key];
-            });
-            return "".concat(directives["connection"]["key"], "(").concat(storeKeyNameStringify(filteredArgs_1), ")");
-        }
-        else {
-            return directives["connection"]["key"];
-        }
-    }
-    var completeFieldName = fieldName;
-    if (args) {
-        var stringifiedArgs = storeKeyNameStringify(args);
-        completeFieldName += "(".concat(stringifiedArgs, ")");
-    }
-    if (directives) {
-        Object.keys(directives).forEach(function (key) {
-            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)
-                return;
-            if (directives[key] && Object.keys(directives[key]).length) {
-                completeFieldName += "@".concat(key, "(").concat(storeKeyNameStringify(directives[key]), ")");
-            }
-            else {
-                completeFieldName += "@".concat(key);
-            }
-        });
-    }
-    return completeFieldName;
-}, {
-    setStringify: function (s) {
-        var previous = storeKeyNameStringify;
-        storeKeyNameStringify = s;
-        return previous;
-    },
-});
-function argumentsObjectFromField(field, variables) {
-    if (field.arguments && field.arguments.length) {
-        var argObj_1 = {};
-        field.arguments.forEach(function (_a) {
-            var name = _a.name, value = _a.value;
-            return valueToObjectRepresentation(argObj_1, name, value, variables);
-        });
-        return argObj_1;
-    }
-    return null;
-}
-function resultKeyNameFromField(field) {
-    return field.alias ? field.alias.value : field.name.value;
-}
-function getTypenameFromResult(result, selectionSet, fragmentMap) {
-    var fragments;
-    for (var _i = 0, _a = selectionSet.selections; _i < _a.length; _i++) {
-        var selection = _a[_i];
-        if (isField(selection)) {
-            if (selection.name.value === "__typename") {
-                return result[resultKeyNameFromField(selection)];
-            }
-        }
-        else if (fragments) {
-            fragments.push(selection);
-        }
-        else {
-            fragments = [selection];
-        }
-    }
-    if (typeof result.__typename === "string") {
-        return result.__typename;
-    }
-    if (fragments) {
-        for (var _b = 0, fragments_1 = fragments; _b < fragments_1.length; _b++) {
-            var selection = fragments_1[_b];
-            var typename = getTypenameFromResult(result, getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);
-            if (typeof typename === "string") {
-                return typename;
-            }
-        }
-    }
-}
-function isField(selection) {
-    return selection.kind === "Field";
-}
-function isInlineFragment(selection) {
-    return selection.kind === "InlineFragment";
-}
-
-function checkDocument(doc) {
-    globals.invariant(doc && doc.kind === "Document", 88);
-    var operations = doc.definitions
-        .filter(function (d) { return d.kind !== "FragmentDefinition"; })
-        .map(function (definition) {
-        if (definition.kind !== "OperationDefinition") {
-            throw globals.newInvariantError(89, definition.kind);
-        }
-        return definition;
-    });
-    globals.invariant(operations.length <= 1, 90, operations.length);
-    return doc;
-}
-function getOperationDefinition(doc) {
-    checkDocument(doc);
-    return doc.definitions.filter(function (definition) {
-        return definition.kind === "OperationDefinition";
-    })[0];
-}
-function getOperationName(doc) {
-    return (doc.definitions
-        .filter(function (definition) {
-        return definition.kind === "OperationDefinition" && !!definition.name;
-    })
-        .map(function (x) { return x.name.value; })[0] || null);
-}
-function getFragmentDefinitions(doc) {
-    return doc.definitions.filter(function (definition) {
-        return definition.kind === "FragmentDefinition";
-    });
-}
-function getQueryDefinition(doc) {
-    var queryDef = getOperationDefinition(doc);
-    globals.invariant(queryDef && queryDef.operation === "query", 91);
-    return queryDef;
-}
-function getFragmentDefinition(doc) {
-    globals.invariant(doc.kind === "Document", 92);
-    globals.invariant(doc.definitions.length <= 1, 93);
-    var fragmentDef = doc.definitions[0];
-    globals.invariant(fragmentDef.kind === "FragmentDefinition", 94);
-    return fragmentDef;
-}
-function getMainDefinition(queryDoc) {
-    checkDocument(queryDoc);
-    var fragmentDefinition;
-    for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {
-        var definition = _a[_i];
-        if (definition.kind === "OperationDefinition") {
-            var operation = definition.operation;
-            if (operation === "query" ||
-                operation === "mutation" ||
-                operation === "subscription") {
-                return definition;
-            }
-        }
-        if (definition.kind === "FragmentDefinition" && !fragmentDefinition) {
-            fragmentDefinition = definition;
-        }
-    }
-    if (fragmentDefinition) {
-        return fragmentDefinition;
-    }
-    throw globals.newInvariantError(95);
-}
-function getDefaultValues(definition) {
-    var defaultValues = Object.create(null);
-    var defs = definition && definition.variableDefinitions;
-    if (defs && defs.length) {
-        defs.forEach(function (def) {
-            if (def.defaultValue) {
-                valueToObjectRepresentation(defaultValues, def.variable.name, def.defaultValue);
-            }
-        });
-    }
-    return defaultValues;
-}
-
-function identity(document) {
-    return document;
-}
-var DocumentTransform =  (function () {
-    function DocumentTransform(transform, options) {
-        if (options === void 0) { options = Object.create(null); }
-        this.resultCache = canUseWeakSet ? new WeakSet() : new Set();
-        this.transform = transform;
-        if (options.getCacheKey) {
-            this.getCacheKey = options.getCacheKey;
-        }
-        this.cached = options.cache !== false;
-        this.resetCache();
-    }
-    DocumentTransform.prototype.getCacheKey = function (document) {
-        return [document];
-    };
-    DocumentTransform.identity = function () {
-        return new DocumentTransform(identity, { cache: false });
-    };
-    DocumentTransform.split = function (predicate, left, right) {
-        if (right === void 0) { right = DocumentTransform.identity(); }
-        return Object.assign(new DocumentTransform(function (document) {
-            var documentTransform = predicate(document) ? left : right;
-            return documentTransform.transformDocument(document);
-        },
-        { cache: false }), { left: left, right: right });
-    };
-    DocumentTransform.prototype.resetCache = function () {
-        var _this = this;
-        if (this.cached) {
-            var stableCacheKeys_1 = new trie.Trie(canUseWeakMap);
-            this.performWork = optimism.wrap(DocumentTransform.prototype.performWork.bind(this), {
-                makeCacheKey: function (document) {
-                    var cacheKeys = _this.getCacheKey(document);
-                    if (cacheKeys) {
-                        globals.invariant(Array.isArray(cacheKeys), 77);
-                        return stableCacheKeys_1.lookupArray(cacheKeys);
-                    }
-                },
-                max: cacheSizes["documentTransform.cache"],
-                cache: (caches.WeakCache),
-            });
-        }
-    };
-    DocumentTransform.prototype.performWork = function (document) {
-        checkDocument(document);
-        return this.transform(document);
-    };
-    DocumentTransform.prototype.transformDocument = function (document) {
-        if (this.resultCache.has(document)) {
-            return document;
-        }
-        var transformedDocument = this.performWork(document);
-        this.resultCache.add(transformedDocument);
-        return transformedDocument;
-    };
-    DocumentTransform.prototype.concat = function (otherTransform) {
-        var _this = this;
-        return Object.assign(new DocumentTransform(function (document) {
-            return otherTransform.transformDocument(_this.transformDocument(document));
-        },
-        { cache: false }), {
-            left: this,
-            right: otherTransform,
-        });
-    };
-    return DocumentTransform;
-}());
-
-var printCache;
-var print = Object.assign(function (ast) {
-    var result = printCache.get(ast);
-    if (!result) {
-        result = graphql.print(ast);
-        printCache.set(ast, result);
-    }
-    return result;
-}, {
-    reset: function () {
-        printCache = new AutoCleanedWeakCache(cacheSizes.print || 2000 );
-    },
-});
-print.reset();
-if (globalThis.__DEV__ !== false) {
-    registerGlobalCache("print", function () { return (printCache ? printCache.size : 0); });
-}
-
-var isArray = Array.isArray;
-function isNonEmptyArray(value) {
-    return Array.isArray(value) && value.length > 0;
-}
-
-var TYPENAME_FIELD = {
-    kind: graphql.Kind.FIELD,
-    name: {
-        kind: graphql.Kind.NAME,
-        value: "__typename",
-    },
-};
-function isEmpty(op, fragmentMap) {
-    return (!op ||
-        op.selectionSet.selections.every(function (selection) {
-            return selection.kind === graphql.Kind.FRAGMENT_SPREAD &&
-                isEmpty(fragmentMap[selection.name.value], fragmentMap);
-        }));
-}
-function nullIfDocIsEmpty(doc) {
-    return (isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))) ?
-        null
-        : doc;
-}
-function getDirectiveMatcher(configs) {
-    var names = new Map();
-    var tests = new Map();
-    configs.forEach(function (directive) {
-        if (directive) {
-            if (directive.name) {
-                names.set(directive.name, directive);
-            }
-            else if (directive.test) {
-                tests.set(directive.test, directive);
-            }
-        }
-    });
-    return function (directive) {
-        var config = names.get(directive.name.value);
-        if (!config && tests.size) {
-            tests.forEach(function (testConfig, test) {
-                if (test(directive)) {
-                    config = testConfig;
-                }
-            });
-        }
-        return config;
-    };
-}
-function makeInUseGetterFunction(defaultKey) {
-    var map = new Map();
-    return function inUseGetterFunction(key) {
-        if (key === void 0) { key = defaultKey; }
-        var inUse = map.get(key);
-        if (!inUse) {
-            map.set(key, (inUse = {
-                variables: new Set(),
-                fragmentSpreads: new Set(),
-            }));
-        }
-        return inUse;
-    };
-}
-function removeDirectivesFromDocument(directives, doc) {
-    checkDocument(doc);
-    var getInUseByOperationName = makeInUseGetterFunction("");
-    var getInUseByFragmentName = makeInUseGetterFunction("");
-    var getInUse = function (ancestors) {
-        for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {
-            if (isArray(ancestor))
-                continue;
-            if (ancestor.kind === graphql.Kind.OPERATION_DEFINITION) {
-                return getInUseByOperationName(ancestor.name && ancestor.name.value);
-            }
-            if (ancestor.kind === graphql.Kind.FRAGMENT_DEFINITION) {
-                return getInUseByFragmentName(ancestor.name.value);
-            }
-        }
-        globalThis.__DEV__ !== false && globals.invariant.error(97);
-        return null;
-    };
-    var operationCount = 0;
-    for (var i = doc.definitions.length - 1; i >= 0; --i) {
-        if (doc.definitions[i].kind === graphql.Kind.OPERATION_DEFINITION) {
-            ++operationCount;
-        }
-    }
-    var directiveMatcher = getDirectiveMatcher(directives);
-    var shouldRemoveField = function (nodeDirectives) {
-        return isNonEmptyArray(nodeDirectives) &&
-            nodeDirectives
-                .map(directiveMatcher)
-                .some(function (config) { return config && config.remove; });
-    };
-    var originalFragmentDefsByPath = new Map();
-    var firstVisitMadeChanges = false;
-    var fieldOrInlineFragmentVisitor = {
-        enter: function (node) {
-            if (shouldRemoveField(node.directives)) {
-                firstVisitMadeChanges = true;
-                return null;
-            }
-        },
-    };
-    var docWithoutDirectiveSubtrees = graphql.visit(doc, {
-        Field: fieldOrInlineFragmentVisitor,
-        InlineFragment: fieldOrInlineFragmentVisitor,
-        VariableDefinition: {
-            enter: function () {
-                return false;
-            },
-        },
-        Variable: {
-            enter: function (node, _key, _parent, _path, ancestors) {
-                var inUse = getInUse(ancestors);
-                if (inUse) {
-                    inUse.variables.add(node.name.value);
-                }
-            },
-        },
-        FragmentSpread: {
-            enter: function (node, _key, _parent, _path, ancestors) {
-                if (shouldRemoveField(node.directives)) {
-                    firstVisitMadeChanges = true;
-                    return null;
-                }
-                var inUse = getInUse(ancestors);
-                if (inUse) {
-                    inUse.fragmentSpreads.add(node.name.value);
-                }
-            },
-        },
-        FragmentDefinition: {
-            enter: function (node, _key, _parent, path) {
-                originalFragmentDefsByPath.set(JSON.stringify(path), node);
-            },
-            leave: function (node, _key, _parent, path) {
-                var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));
-                if (node === originalNode) {
-                    return node;
-                }
-                if (
-                operationCount > 0 &&
-                    node.selectionSet.selections.every(function (selection) {
-                        return selection.kind === graphql.Kind.FIELD &&
-                            selection.name.value === "__typename";
-                    })) {
-                    getInUseByFragmentName(node.name.value).removed = true;
-                    firstVisitMadeChanges = true;
-                    return null;
-                }
-            },
-        },
-        Directive: {
-            leave: function (node) {
-                if (directiveMatcher(node)) {
-                    firstVisitMadeChanges = true;
-                    return null;
-                }
-            },
-        },
-    });
-    if (!firstVisitMadeChanges) {
-        return doc;
-    }
-    var populateTransitiveVars = function (inUse) {
-        if (!inUse.transitiveVars) {
-            inUse.transitiveVars = new Set(inUse.variables);
-            if (!inUse.removed) {
-                inUse.fragmentSpreads.forEach(function (childFragmentName) {
-                    populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach(function (varName) {
-                        inUse.transitiveVars.add(varName);
-                    });
-                });
-            }
-        }
-        return inUse;
-    };
-    var allFragmentNamesUsed = new Set();
-    docWithoutDirectiveSubtrees.definitions.forEach(function (def) {
-        if (def.kind === graphql.Kind.OPERATION_DEFINITION) {
-            populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function (childFragmentName) {
-                allFragmentNamesUsed.add(childFragmentName);
-            });
-        }
-        else if (def.kind === graphql.Kind.FRAGMENT_DEFINITION &&
-            operationCount === 0 &&
-            !getInUseByFragmentName(def.name.value).removed) {
-            allFragmentNamesUsed.add(def.name.value);
-        }
-    });
-    allFragmentNamesUsed.forEach(function (fragmentName) {
-        populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function (childFragmentName) {
-            allFragmentNamesUsed.add(childFragmentName);
-        });
-    });
-    var fragmentWillBeRemoved = function (fragmentName) {
-        return !!(
-        (!allFragmentNamesUsed.has(fragmentName) ||
-            getInUseByFragmentName(fragmentName).removed));
-    };
-    var enterVisitor = {
-        enter: function (node) {
-            if (fragmentWillBeRemoved(node.name.value)) {
-                return null;
-            }
-        },
-    };
-    return nullIfDocIsEmpty(graphql.visit(docWithoutDirectiveSubtrees, {
-        FragmentSpread: enterVisitor,
-        FragmentDefinition: enterVisitor,
-        OperationDefinition: {
-            leave: function (node) {
-                if (node.variableDefinitions) {
-                    var usedVariableNames_1 = populateTransitiveVars(
-                    getInUseByOperationName(node.name && node.name.value)).transitiveVars;
-                    if (usedVariableNames_1.size < node.variableDefinitions.length) {
-                        return tslib.__assign(tslib.__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {
-                                return usedVariableNames_1.has(varDef.variable.name.value);
-                            }) });
-                    }
-                }
-            },
-        },
-    }));
-}
-var addTypenameToDocument = Object.assign(function (doc) {
-    return graphql.visit(doc, {
-        SelectionSet: {
-            enter: function (node, _key, parent) {
-                if (parent &&
-                    parent.kind ===
-                        graphql.Kind.OPERATION_DEFINITION) {
-                    return;
-                }
-                var selections = node.selections;
-                if (!selections) {
-                    return;
-                }
-                var skip = selections.some(function (selection) {
-                    return (isField(selection) &&
-                        (selection.name.value === "__typename" ||
-                            selection.name.value.lastIndexOf("__", 0) === 0));
-                });
-                if (skip) {
-                    return;
-                }
-                var field = parent;
-                if (isField(field) &&
-                    field.directives &&
-                    field.directives.some(function (d) { return d.name.value === "export"; })) {
-                    return;
-                }
-                return tslib.__assign(tslib.__assign({}, node), { selections: tslib.__spreadArray(tslib.__spreadArray([], selections, true), [TYPENAME_FIELD], false) });
-            },
-        },
-    });
-}, {
-    added: function (field) {
-        return field === TYPENAME_FIELD;
-    },
-});
-var connectionRemoveConfig = {
-    test: function (directive) {
-        var willRemove = directive.name.value === "connection";
-        if (willRemove) {
-            if (!directive.arguments ||
-                !directive.arguments.some(function (arg) { return arg.name.value === "key"; })) {
-                globalThis.__DEV__ !== false && globals.invariant.warn(98);
-            }
-        }
-        return willRemove;
-    },
-};
-function removeConnectionDirectiveFromDocument(doc) {
-    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));
-}
-function getArgumentMatcher(config) {
-    return function argumentMatcher(argument) {
-        return config.some(function (aConfig) {
-            return argument.value &&
-                argument.value.kind === graphql.Kind.VARIABLE &&
-                argument.value.name &&
-                (aConfig.name === argument.value.name.value ||
-                    (aConfig.test && aConfig.test(argument)));
-        });
-    };
-}
-function removeArgumentsFromDocument(config, doc) {
-    var argMatcher = getArgumentMatcher(config);
-    return nullIfDocIsEmpty(graphql.visit(doc, {
-        OperationDefinition: {
-            enter: function (node) {
-                return tslib.__assign(tslib.__assign({}, node), {
-                    variableDefinitions: node.variableDefinitions ?
-                        node.variableDefinitions.filter(function (varDef) {
-                            return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });
-                        })
-                        : [] });
-            },
-        },
-        Field: {
-            enter: function (node) {
-                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });
-                if (shouldRemoveField) {
-                    var argMatchCount_1 = 0;
-                    if (node.arguments) {
-                        node.arguments.forEach(function (arg) {
-                            if (argMatcher(arg)) {
-                                argMatchCount_1 += 1;
-                            }
-                        });
-                    }
-                    if (argMatchCount_1 === 1) {
-                        return null;
-                    }
-                }
-            },
-        },
-        Argument: {
-            enter: function (node) {
-                if (argMatcher(node)) {
-                    return null;
-                }
-            },
-        },
-    }));
-}
-function removeFragmentSpreadFromDocument(config, doc) {
-    function enter(node) {
-        if (config.some(function (def) { return def.name === node.name.value; })) {
-            return null;
-        }
-    }
-    return nullIfDocIsEmpty(graphql.visit(doc, {
-        FragmentSpread: { enter: enter },
-        FragmentDefinition: { enter: enter },
-    }));
-}
-function buildQueryFromSelectionSet(document) {
-    var definition = getMainDefinition(document);
-    var definitionOperation = definition.operation;
-    if (definitionOperation === "query") {
-        return document;
-    }
-    var modifiedDoc = graphql.visit(document, {
-        OperationDefinition: {
-            enter: function (node) {
-                return tslib.__assign(tslib.__assign({}, node), { operation: "query" });
-            },
-        },
-    });
-    return modifiedDoc;
-}
-function removeClientSetsFromDocument(document) {
-    checkDocument(document);
-    var modifiedDoc = removeDirectivesFromDocument([
-        {
-            test: function (directive) { return directive.name.value === "client"; },
-            remove: true,
-        },
-    ], document);
-    return modifiedDoc;
-}
-function addNonReactiveToNamedFragments(document) {
-    checkDocument(document);
-    return graphql.visit(document, {
-        FragmentSpread: function (node) {
-            var _a;
-            if ((_a = node.directives) === null || _a === void 0 ? void 0 : _a.some(function (directive) { return directive.name.value === "unmask"; })) {
-                return;
-            }
-            return tslib.__assign(tslib.__assign({}, node), { directives: tslib.__spreadArray(tslib.__spreadArray([], (node.directives || []), true), [
-                    {
-                        kind: graphql.Kind.DIRECTIVE,
-                        name: { kind: graphql.Kind.NAME, value: "nonreactive" },
-                    },
-                ], false) });
-        },
-    });
-}
-
-function isOperation(document, operation) {
-    var _a;
-    return ((_a = getOperationDefinition(document)) === null || _a === void 0 ? void 0 : _a.operation) === operation;
-}
-function isMutationOperation(document) {
-    return isOperation(document, "mutation");
-}
-function isQueryOperation(document) {
-    return isOperation(document, "query");
-}
-function isSubscriptionOperation(document) {
-    return isOperation(document, "subscription");
-}
-
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-function mergeDeep() {
-    var sources = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        sources[_i] = arguments[_i];
-    }
-    return mergeDeepArray(sources);
-}
-function mergeDeepArray(sources) {
-    var target = sources[0] || {};
-    var count = sources.length;
-    if (count > 1) {
-        var merger = new DeepMerger();
-        for (var i = 1; i < count; ++i) {
-            target = merger.merge(target, sources[i]);
-        }
-    }
-    return target;
-}
-var defaultReconciler = function (target, source, property) {
-    return this.merge(target[property], source[property]);
-};
-var DeepMerger =  (function () {
-    function DeepMerger(reconciler) {
-        if (reconciler === void 0) { reconciler = defaultReconciler; }
-        this.reconciler = reconciler;
-        this.isObject = isNonNullObject;
-        this.pastCopies = new Set();
-    }
-    DeepMerger.prototype.merge = function (target, source) {
-        var _this = this;
-        var context = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            context[_i - 2] = arguments[_i];
-        }
-        if (isNonNullObject(source) && isNonNullObject(target)) {
-            Object.keys(source).forEach(function (sourceKey) {
-                if (hasOwnProperty.call(target, sourceKey)) {
-                    var targetValue = target[sourceKey];
-                    if (source[sourceKey] !== targetValue) {
-                        var result = _this.reconciler.apply(_this, tslib.__spreadArray([target,
-                            source,
-                            sourceKey], context, false));
-                        if (result !== targetValue) {
-                            target = _this.shallowCopyForMerge(target);
-                            target[sourceKey] = result;
-                        }
-                    }
-                }
-                else {
-                    target = _this.shallowCopyForMerge(target);
-                    target[sourceKey] = source[sourceKey];
-                }
-            });
-            return target;
-        }
-        return source;
-    };
-    DeepMerger.prototype.shallowCopyForMerge = function (value) {
-        if (isNonNullObject(value)) {
-            if (!this.pastCopies.has(value)) {
-                if (Array.isArray(value)) {
-                    value = value.slice(0);
-                }
-                else {
-                    value = tslib.__assign({ __proto__: Object.getPrototypeOf(value) }, value);
-                }
-                this.pastCopies.add(value);
-            }
-        }
-        return value;
-    };
-    return DeepMerger;
-}());
-
-function concatPagination(keyArgs) {
-    if (keyArgs === void 0) { keyArgs = false; }
-    return {
-        keyArgs: keyArgs,
-        merge: function (existing, incoming) {
-            return existing ? tslib.__spreadArray(tslib.__spreadArray([], existing, true), incoming, true) : incoming;
-        },
-    };
-}
-function offsetLimitPagination(keyArgs) {
-    if (keyArgs === void 0) { keyArgs = false; }
-    return {
-        keyArgs: keyArgs,
-        merge: function (existing, incoming, _a) {
-            var args = _a.args;
-            var merged = existing ? existing.slice(0) : [];
-            if (incoming) {
-                if (args) {
-                    var _b = args.offset, offset = _b === void 0 ? 0 : _b;
-                    for (var i = 0; i < incoming.length; ++i) {
-                        merged[offset + i] = incoming[i];
-                    }
-                }
-                else {
-                    merged.push.apply(merged, incoming);
-                }
-            }
-            return merged;
-        },
-    };
-}
-function relayStylePagination(keyArgs) {
-    if (keyArgs === void 0) { keyArgs = false; }
-    return {
-        keyArgs: keyArgs,
-        read: function (existing, _a) {
-            var canRead = _a.canRead, readField = _a.readField;
-            if (!existing)
-                return existing;
-            var edges = [];
-            var firstEdgeCursor = "";
-            var lastEdgeCursor = "";
-            existing.edges.forEach(function (edge) {
-                if (canRead(readField("node", edge))) {
-                    edges.push(edge);
-                    if (edge.cursor) {
-                        firstEdgeCursor = firstEdgeCursor || edge.cursor || "";
-                        lastEdgeCursor = edge.cursor || lastEdgeCursor;
-                    }
-                }
-            });
-            if (edges.length > 1 && firstEdgeCursor === lastEdgeCursor) {
-                firstEdgeCursor = "";
-            }
-            var _b = existing.pageInfo || {}, startCursor = _b.startCursor, endCursor = _b.endCursor;
-            return tslib.__assign(tslib.__assign({}, getExtras(existing)), { edges: edges, pageInfo: tslib.__assign(tslib.__assign({}, existing.pageInfo), {
-                    startCursor: startCursor || firstEdgeCursor, endCursor: endCursor || lastEdgeCursor }) });
-        },
-        merge: function (existing, incoming, _a) {
-            var args = _a.args, isReference = _a.isReference, readField = _a.readField;
-            if (!existing) {
-                existing = makeEmptyData();
-            }
-            if (!incoming) {
-                return existing;
-            }
-            var incomingEdges = incoming.edges ?
-                incoming.edges.map(function (edge) {
-                    if (isReference((edge = tslib.__assign({}, edge)))) {
-                        edge.cursor = readField("cursor", edge);
-                    }
-                    return edge;
-                })
-                : [];
-            if (incoming.pageInfo) {
-                var pageInfo_1 = incoming.pageInfo;
-                var startCursor = pageInfo_1.startCursor, endCursor = pageInfo_1.endCursor;
-                var firstEdge = incomingEdges[0];
-                var lastEdge = incomingEdges[incomingEdges.length - 1];
-                if (firstEdge && startCursor) {
-                    firstEdge.cursor = startCursor;
-                }
-                if (lastEdge && endCursor) {
-                    lastEdge.cursor = endCursor;
-                }
-                var firstCursor = firstEdge && firstEdge.cursor;
-                if (firstCursor && !startCursor) {
-                    incoming = mergeDeep(incoming, {
-                        pageInfo: {
-                            startCursor: firstCursor,
-                        },
-                    });
-                }
-                var lastCursor = lastEdge && lastEdge.cursor;
-                if (lastCursor && !endCursor) {
-                    incoming = mergeDeep(incoming, {
-                        pageInfo: {
-                            endCursor: lastCursor,
-                        },
-                    });
-                }
-            }
-            var prefix = existing.edges;
-            var suffix = [];
-            if (args && args.after) {
-                var index = prefix.findIndex(function (edge) { return edge.cursor === args.after; });
-                if (index >= 0) {
-                    prefix = prefix.slice(0, index + 1);
-                }
-            }
-            else if (args && args.before) {
-                var index = prefix.findIndex(function (edge) { return edge.cursor === args.before; });
-                suffix = index < 0 ? prefix : prefix.slice(index);
-                prefix = [];
-            }
-            else if (incoming.edges) {
-                prefix = [];
-            }
-            var edges = tslib.__spreadArray(tslib.__spreadArray(tslib.__spreadArray([], prefix, true), incomingEdges, true), suffix, true);
-            var pageInfo = tslib.__assign(tslib.__assign({}, incoming.pageInfo), existing.pageInfo);
-            if (incoming.pageInfo) {
-                var _b = incoming.pageInfo, hasPreviousPage = _b.hasPreviousPage, hasNextPage = _b.hasNextPage, startCursor = _b.startCursor, endCursor = _b.endCursor, extras = tslib.__rest(_b, ["hasPreviousPage", "hasNextPage", "startCursor", "endCursor"]);
-                Object.assign(pageInfo, extras);
-                if (!prefix.length) {
-                    if (void 0 !== hasPreviousPage)
-                        pageInfo.hasPreviousPage = hasPreviousPage;
-                    if (void 0 !== startCursor)
-                        pageInfo.startCursor = startCursor;
-                }
-                if (!suffix.length) {
-                    if (void 0 !== hasNextPage)
-                        pageInfo.hasNextPage = hasNextPage;
-                    if (void 0 !== endCursor)
-                        pageInfo.endCursor = endCursor;
-                }
-            }
-            return tslib.__assign(tslib.__assign(tslib.__assign({}, getExtras(existing)), getExtras(incoming)), { edges: edges, pageInfo: pageInfo });
-        },
-    };
-}
-var getExtras = function (obj) { return tslib.__rest(obj, notExtras); };
-var notExtras = ["edges", "pageInfo"];
-function makeEmptyData() {
-    return {
-        edges: [],
-        pageInfo: {
-            hasPreviousPage: false,
-            hasNextPage: true,
-            startCursor: "",
-            endCursor: "",
-        },
-    };
-}
-
-function createFulfilledPromise(value) {
-    var promise = Promise.resolve(value);
-    promise.status = "fulfilled";
-    promise.value = value;
-    return promise;
-}
-function createRejectedPromise(reason) {
-    var promise = Promise.reject(reason);
-    promise.catch(function () { });
-    promise.status = "rejected";
-    promise.reason = reason;
-    return promise;
-}
-function isStatefulPromise(promise) {
-    return "status" in promise;
-}
-function wrapPromiseWithState(promise) {
-    if (isStatefulPromise(promise)) {
-        return promise;
-    }
-    var pendingPromise = promise;
-    pendingPromise.status = "pending";
-    pendingPromise.then(function (value) {
-        if (pendingPromise.status === "pending") {
-            var fulfilledPromise = pendingPromise;
-            fulfilledPromise.status = "fulfilled";
-            fulfilledPromise.value = value;
-        }
-    }, function (reason) {
-        if (pendingPromise.status === "pending") {
-            var rejectedPromise = pendingPromise;
-            rejectedPromise.status = "rejected";
-            rejectedPromise.reason = reason;
-        }
-    });
-    return promise;
-}
-
-function preventUnhandledRejection(promise) {
-    promise.catch(function () { });
-    return promise;
-}
-
-var toString = Object.prototype.toString;
-function cloneDeep(value) {
-    return cloneDeepHelper(value);
-}
-function cloneDeepHelper(val, seen) {
-    switch (toString.call(val)) {
-        case "[object Array]": {
-            seen = seen || new Map();
-            if (seen.has(val))
-                return seen.get(val);
-            var copy_1 = val.slice(0);
-            seen.set(val, copy_1);
-            copy_1.forEach(function (child, i) {
-                copy_1[i] = cloneDeepHelper(child, seen);
-            });
-            return copy_1;
-        }
-        case "[object Object]": {
-            seen = seen || new Map();
-            if (seen.has(val))
-                return seen.get(val);
-            var copy_2 = Object.create(Object.getPrototypeOf(val));
-            seen.set(val, copy_2);
-            Object.keys(val).forEach(function (key) {
-                copy_2[key] = cloneDeepHelper(val[key], seen);
-            });
-            return copy_2;
-        }
-        default:
-            return val;
-    }
-}
-
-function deepFreeze(value) {
-    var workSet = new Set([value]);
-    workSet.forEach(function (obj) {
-        if (isNonNullObject(obj) && shallowFreeze(obj) === obj) {
-            Object.getOwnPropertyNames(obj).forEach(function (name) {
-                if (isNonNullObject(obj[name]))
-                    workSet.add(obj[name]);
-            });
-        }
-    });
-    return value;
-}
-function shallowFreeze(obj) {
-    if (globalThis.__DEV__ !== false && !Object.isFrozen(obj)) {
-        try {
-            Object.freeze(obj);
-        }
-        catch (e) {
-            if (e instanceof TypeError)
-                return null;
-            throw e;
-        }
-    }
-    return obj;
-}
-function maybeDeepFreeze(obj) {
-    if (globalThis.__DEV__ !== false) {
-        deepFreeze(obj);
-    }
-    return obj;
-}
-
-function iterateObserversSafely(observers, method, argument) {
-    var observersWithMethod = [];
-    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });
-    observersWithMethod.forEach(function (obs) { return obs[method](argument); });
-}
-
-function asyncMap(observable, mapFn, catchFn) {
-    return new zenObservableTs.Observable(function (observer) {
-        var promiseQueue = {
-            then: function (callback) {
-                return new Promise(function (resolve) { return resolve(callback()); });
-            },
-        };
-        function makeCallback(examiner, key) {
-            return function (arg) {
-                if (examiner) {
-                    var both = function () {
-                        return observer.closed ?
-                             0
-                            : examiner(arg);
-                    };
-                    promiseQueue = promiseQueue.then(both, both).then(function (result) { return observer.next(result); }, function (error) { return observer.error(error); });
-                }
-                else {
-                    observer[key](arg);
-                }
-            };
-        }
-        var handler = {
-            next: makeCallback(mapFn, "next"),
-            error: makeCallback(catchFn, "error"),
-            complete: function () {
-                 promiseQueue.then(function () { return observer.complete(); });
-            },
-        };
-        var sub = observable.subscribe(handler);
-        return function () { return sub.unsubscribe(); };
-    });
-}
-
-function fixObservableSubclass(subclass) {
-    function set(key) {
-        Object.defineProperty(subclass, key, { value: zenObservableTs.Observable });
-    }
-    if (canUseSymbol && Symbol.species) {
-        set(Symbol.species);
-    }
-    set("@@species");
-    return subclass;
-}
-
-function isPromiseLike(value) {
-    return value && typeof value.then === "function";
-}
-var Concast =  (function (_super) {
-    tslib.__extends(Concast, _super);
-    function Concast(sources) {
-        var _this = _super.call(this, function (observer) {
-            _this.addObserver(observer);
-            return function () { return _this.removeObserver(observer); };
-        }) || this;
-        _this.observers = new Set();
-        _this.promise = new Promise(function (resolve, reject) {
-            _this.resolve = resolve;
-            _this.reject = reject;
-        });
-        _this.handlers = {
-            next: function (result) {
-                if (_this.sub !== null) {
-                    _this.latest = ["next", result];
-                    _this.notify("next", result);
-                    iterateObserversSafely(_this.observers, "next", result);
-                }
-            },
-            error: function (error) {
-                var sub = _this.sub;
-                if (sub !== null) {
-                    if (sub)
-                        setTimeout(function () { return sub.unsubscribe(); });
-                    _this.sub = null;
-                    _this.latest = ["error", error];
-                    _this.reject(error);
-                    _this.notify("error", error);
-                    iterateObserversSafely(_this.observers, "error", error);
-                }
-            },
-            complete: function () {
-                var _a = _this, sub = _a.sub, _b = _a.sources, sources = _b === void 0 ? [] : _b;
-                if (sub !== null) {
-                    var value = sources.shift();
-                    if (!value) {
-                        if (sub)
-                            setTimeout(function () { return sub.unsubscribe(); });
-                        _this.sub = null;
-                        if (_this.latest && _this.latest[0] === "next") {
-                            _this.resolve(_this.latest[1]);
-                        }
-                        else {
-                            _this.resolve();
-                        }
-                        _this.notify("complete");
-                        iterateObserversSafely(_this.observers, "complete");
-                    }
-                    else if (isPromiseLike(value)) {
-                        value.then(function (obs) { return (_this.sub = obs.subscribe(_this.handlers)); }, _this.handlers.error);
-                    }
-                    else {
-                        _this.sub = value.subscribe(_this.handlers);
-                    }
-                }
-            },
-        };
-        _this.nextResultListeners = new Set();
-        _this.cancel = function (reason) {
-            _this.reject(reason);
-            _this.sources = [];
-            _this.handlers.error(reason);
-        };
-        _this.promise.catch(function (_) { });
-        if (typeof sources === "function") {
-            sources = [new zenObservableTs.Observable(sources)];
-        }
-        if (isPromiseLike(sources)) {
-            sources.then(function (iterable) { return _this.start(iterable); }, _this.handlers.error);
-        }
-        else {
-            _this.start(sources);
-        }
-        return _this;
-    }
-    Concast.prototype.start = function (sources) {
-        if (this.sub !== void 0)
-            return;
-        this.sources = Array.from(sources);
-        this.handlers.complete();
-    };
-    Concast.prototype.deliverLastMessage = function (observer) {
-        if (this.latest) {
-            var nextOrError = this.latest[0];
-            var method = observer[nextOrError];
-            if (method) {
-                method.call(observer, this.latest[1]);
-            }
-            if (this.sub === null && nextOrError === "next" && observer.complete) {
-                observer.complete();
-            }
-        }
-    };
-    Concast.prototype.addObserver = function (observer) {
-        if (!this.observers.has(observer)) {
-            this.deliverLastMessage(observer);
-            this.observers.add(observer);
-        }
-    };
-    Concast.prototype.removeObserver = function (observer) {
-        if (this.observers.delete(observer) && this.observers.size < 1) {
-            this.handlers.complete();
-        }
-    };
-    Concast.prototype.notify = function (method, arg) {
-        var nextResultListeners = this.nextResultListeners;
-        if (nextResultListeners.size) {
-            this.nextResultListeners = new Set();
-            nextResultListeners.forEach(function (listener) { return listener(method, arg); });
-        }
-    };
-    Concast.prototype.beforeNext = function (callback) {
-        var called = false;
-        this.nextResultListeners.add(function (method, arg) {
-            if (!called) {
-                called = true;
-                callback(method, arg);
-            }
-        });
-    };
-    return Concast;
-}(zenObservableTs.Observable));
-fixObservableSubclass(Concast);
-
-function isExecutionPatchIncrementalResult(value) {
-    return "incremental" in value;
-}
-function isExecutionPatchInitialResult(value) {
-    return "hasNext" in value && "data" in value;
-}
-function isExecutionPatchResult(value) {
-    return (isExecutionPatchIncrementalResult(value) ||
-        isExecutionPatchInitialResult(value));
-}
-function isApolloPayloadResult(value) {
-    return isNonNullObject(value) && "payload" in value;
-}
-function mergeIncrementalData(prevResult, result) {
-    var mergedData = prevResult;
-    var merger = new DeepMerger();
-    if (isExecutionPatchIncrementalResult(result) &&
-        isNonEmptyArray(result.incremental)) {
-        result.incremental.forEach(function (_a) {
-            var data = _a.data, path = _a.path;
-            for (var i = path.length - 1; i >= 0; --i) {
-                var key = path[i];
-                var isNumericKey = !isNaN(+key);
-                var parent_1 = isNumericKey ? [] : {};
-                parent_1[key] = data;
-                data = parent_1;
-            }
-            mergedData = merger.merge(mergedData, data);
-        });
-    }
-    return mergedData;
-}
-
-function graphQLResultHasError(result) {
-    var errors = getGraphQLErrorsFromResult(result);
-    return isNonEmptyArray(errors);
-}
-function getGraphQLErrorsFromResult(result) {
-    var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];
-    if (isExecutionPatchIncrementalResult(result) &&
-        isNonEmptyArray(result.incremental)) {
-        result.incremental.forEach(function (incrementalResult) {
-            if (incrementalResult.errors) {
-                graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);
-            }
-        });
-    }
-    return graphQLErrors;
-}
-
-function compact() {
-    var objects = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        objects[_i] = arguments[_i];
-    }
-    var result = Object.create(null);
-    objects.forEach(function (obj) {
-        if (!obj)
-            return;
-        Object.keys(obj).forEach(function (key) {
-            var value = obj[key];
-            if (value !== void 0) {
-                result[key] = value;
-            }
-        });
-    });
-    return result;
-}
-
-var prefixCounts = new Map();
-function makeUniqueId(prefix) {
-    var count = prefixCounts.get(prefix) || 1;
-    prefixCounts.set(prefix, count + 1);
-    return "".concat(prefix, ":").concat(count, ":").concat(Math.random().toString(36).slice(2));
-}
-
-function stringifyForDisplay(value, space) {
-    if (space === void 0) { space = 0; }
-    var undefId = makeUniqueId("stringifyForDisplay");
-    return JSON.stringify(value, function (key, value) {
-        return value === void 0 ? undefId : value;
-    }, space)
-        .split(JSON.stringify(undefId))
-        .join("<undefined>");
-}
-
-function mergeOptions(defaults, options) {
-    return compact(defaults, options, options.variables && {
-        variables: compact(tslib.__assign(tslib.__assign({}, (defaults && defaults.variables)), options.variables)),
-    });
-}
-
-function omitDeep(value, key) {
-    return __omitDeep(value, key);
-}
-function __omitDeep(value, key, known) {
-    if (known === void 0) { known = new Map(); }
-    if (known.has(value)) {
-        return known.get(value);
-    }
-    var modified = false;
-    if (Array.isArray(value)) {
-        var array_1 = [];
-        known.set(value, array_1);
-        value.forEach(function (value, index) {
-            var result = __omitDeep(value, key, known);
-            modified || (modified = result !== value);
-            array_1[index] = result;
-        });
-        if (modified) {
-            return array_1;
-        }
-    }
-    else if (isPlainObject(value)) {
-        var obj_1 = Object.create(Object.getPrototypeOf(value));
-        known.set(value, obj_1);
-        Object.keys(value).forEach(function (k) {
-            if (k === key) {
-                modified = true;
-                return;
-            }
-            var result = __omitDeep(value[k], key, known);
-            modified || (modified = result !== value[k]);
-            obj_1[k] = result;
-        });
-        if (modified) {
-            return obj_1;
-        }
-    }
-    return value;
-}
-
-function stripTypename(value) {
-    return omitDeep(value, "__typename");
-}
-
-exports.DEV = globals.DEV;
-exports.maybe = globals.maybe;
-exports.Observable = zenObservableTs.Observable;
-exports.AutoCleanedStrongCache = AutoCleanedStrongCache;
-exports.AutoCleanedWeakCache = AutoCleanedWeakCache;
-exports.Concast = Concast;
-exports.DeepMerger = DeepMerger;
-exports.DocumentTransform = DocumentTransform;
-exports.addNonReactiveToNamedFragments = addNonReactiveToNamedFragments;
-exports.addTypenameToDocument = addTypenameToDocument;
-exports.argumentsObjectFromField = argumentsObjectFromField;
-exports.asyncMap = asyncMap;
-exports.buildQueryFromSelectionSet = buildQueryFromSelectionSet;
-exports.cacheSizes = cacheSizes;
-exports.canUseAsyncIteratorSymbol = canUseAsyncIteratorSymbol;
-exports.canUseDOM = canUseDOM;
-exports.canUseLayoutEffect = canUseLayoutEffect;
-exports.canUseSymbol = canUseSymbol;
-exports.canUseWeakMap = canUseWeakMap;
-exports.canUseWeakSet = canUseWeakSet;
-exports.canonicalStringify = canonicalStringify;
-exports.checkDocument = checkDocument;
-exports.cloneDeep = cloneDeep;
-exports.compact = compact;
-exports.concatPagination = concatPagination;
-exports.createFragmentMap = createFragmentMap;
-exports.createFulfilledPromise = createFulfilledPromise;
-exports.createRejectedPromise = createRejectedPromise;
-exports.fixObservableSubclass = fixObservableSubclass;
-exports.getDefaultValues = getDefaultValues;
-exports.getDirectiveNames = getDirectiveNames;
-exports.getFragmentDefinition = getFragmentDefinition;
-exports.getFragmentDefinitions = getFragmentDefinitions;
-exports.getFragmentFromSelection = getFragmentFromSelection;
-exports.getFragmentMaskMode = getFragmentMaskMode;
-exports.getFragmentQueryDocument = getFragmentQueryDocument;
-exports.getGraphQLErrorsFromResult = getGraphQLErrorsFromResult;
-exports.getInclusionDirectives = getInclusionDirectives;
-exports.getMainDefinition = getMainDefinition;
-exports.getOperationDefinition = getOperationDefinition;
-exports.getOperationName = getOperationName;
-exports.getQueryDefinition = getQueryDefinition;
-exports.getStoreKeyName = getStoreKeyName;
-exports.getTypenameFromResult = getTypenameFromResult;
-exports.graphQLResultHasError = graphQLResultHasError;
-exports.hasAllDirectives = hasAllDirectives;
-exports.hasAnyDirectives = hasAnyDirectives;
-exports.hasClientExports = hasClientExports;
-exports.hasDirectives = hasDirectives;
-exports.isApolloPayloadResult = isApolloPayloadResult;
-exports.isArray = isArray;
-exports.isDocumentNode = isDocumentNode;
-exports.isExecutionPatchIncrementalResult = isExecutionPatchIncrementalResult;
-exports.isExecutionPatchInitialResult = isExecutionPatchInitialResult;
-exports.isExecutionPatchResult = isExecutionPatchResult;
-exports.isField = isField;
-exports.isFullyUnmaskedOperation = isFullyUnmaskedOperation;
-exports.isInlineFragment = isInlineFragment;
-exports.isMutationOperation = isMutationOperation;
-exports.isNonEmptyArray = isNonEmptyArray;
-exports.isNonNullObject = isNonNullObject;
-exports.isPlainObject = isPlainObject;
-exports.isQueryOperation = isQueryOperation;
-exports.isReference = isReference;
-exports.isStatefulPromise = isStatefulPromise;
-exports.isSubscriptionOperation = isSubscriptionOperation;
-exports.iterateObserversSafely = iterateObserversSafely;
-exports.makeReference = makeReference;
-exports.makeUniqueId = makeUniqueId;
-exports.maybeDeepFreeze = maybeDeepFreeze;
-exports.mergeDeep = mergeDeep;
-exports.mergeDeepArray = mergeDeepArray;
-exports.mergeIncrementalData = mergeIncrementalData;
-exports.mergeOptions = mergeOptions;
-exports.offsetLimitPagination = offsetLimitPagination;
-exports.omitDeep = omitDeep;
-exports.preventUnhandledRejection = preventUnhandledRejection;
-exports.print = print;
-exports.relayStylePagination = relayStylePagination;
-exports.removeArgumentsFromDocument = removeArgumentsFromDocument;
-exports.removeClientSetsFromDocument = removeClientSetsFromDocument;
-exports.removeConnectionDirectiveFromDocument = removeConnectionDirectiveFromDocument;
-exports.removeDirectivesFromDocument = removeDirectivesFromDocument;
-exports.removeFragmentSpreadFromDocument = removeFragmentSpreadFromDocument;
-exports.resultKeyNameFromField = resultKeyNameFromField;
-exports.shouldInclude = shouldInclude;
-exports.storeKeyNameFromField = storeKeyNameFromField;
-exports.stringifyForDisplay = stringifyForDisplay;
-exports.stripTypename = stripTypename;
-exports.valueToObjectRepresentation = valueToObjectRepresentation;
-exports.wrapPromiseWithState = wrapPromiseWithState;
-//# sourceMappingURL=utilities.cjs.map