{"version":3,"sources":["webpack://web/./node_modules/apollo-utilities/node_modules/ts-invariant/lib/invariant.esm.js","webpack://web/./node_modules/apollo-utilities/node_modules/@wry/equality/lib/equality.esm.js","webpack://web/./node_modules/apollo-utilities/lib/bundle.esm.js"],"names":["genericMessage","_a","Object","setPrototypeOf","obj","proto","__proto__","InvariantError","_super","message","_this","call","this","framesToPop","name","prototype","__extends","Error","invariant","condition","wrapConsoleMethod","method","console","apply","arguments","warn","error","processStub","env","process","Function","atLeastWeTried","toString","hasOwnProperty","previousComparisons","Map","equal","a","b","check","clear","aTag","length","previouslyCompared","aKeys","keys","bKeys","keyCount","k","key","size","aIterator","entries","isMap","info","next","done","value","aKey","aValue","has","get","bSet","set","Set","add","isScalarValue","indexOf","kind","isNumberValue","valueToObjectRepresentation","argObj","variables","isIntValue","isFloatValue","Number","isBooleanValue","isStringValue","isObjectValue","nestedArgObj_1","fields","map","isVariable","variableValue","isListValue","values","listValue","nestedArgArrayObj","isEnumValue","isNullValue","storeKeyNameFromField","field","directivesObj","directives","forEach","directive","getStoreKeyName","KNOWN_DIRECTIVES","fieldName","args","filterKeys","sort","queryArgs_1","filteredArgs_1","JSON","stringify","completeFieldName","stringifiedArgs","argumentsObjectFromField","argObj_1","resultKeyNameFromField","alias","isField","selection","isInlineFragment","isIdValue","idObject","type","generated","toIdValue","idConfig","__assign","id","typename","undefined","isJsonValue","jsonObject","defaultValueFromVariable","node","valueFromNode","onVariable","parseInt","parseFloat","v","_i","getDirectiveInfoFromField","directiveObj_1","shouldInclude","getInclusionDirectives","every","ifArgument","evaledValue","getDirectiveNames","doc","names","visit","Directive","push","hasDirectives","some","hasClientExports","document","isInclusionDirective","filter","directiveArguments","ifValue","getFragmentQueryDocument","fragmentName","actualFragmentName","fragments","definitions","definition","__spreadArrays","operation","selectionSet","selections","target","sources","source","getMutationDefinition","checkDocument","mutationDef","d","getOperationDefinition","getOperationDefinitionOrDie","def","getOperationName","x","getFragmentDefinitions","getQueryDefinition","queryDef","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","createFragmentMap","symTable","fragment","getDefaultValues","variableDefinitions","defaultValues","defaultValue","variable","defaultValueObj","variablesInOperation","filterInPlace","array","test","context","elem","i","TYPENAME_FIELD","isEmpty","op","nullIfDocIsEmpty","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","create","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","enter","_key","parent","Field","remove","arg","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","removeArgumentsFromDocument","fs","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","lastIndexOf","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","hasDirectivesInSelectionSet","nestedCheck","hasDirectivesInSelection","getDirectivesFromDocument","parentPath","_parent","path","currentPath","join","startsWith","selectionsWithDirectives","config","argMatcher","argument","aConfig","getArgumentMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","FragmentDefinition","allFragments","buildQueryFromSelectionSet","removeClientSetsFromDocument","canUseWeakMap","WeakMap","navigator","product","cloneDeep","cloneDeepHelper","val","seen","copy_1","slice","child","copy_2","getPrototypeOf","getEnv","isEnv","isProduction","isDevelopment","isTest","tryFunctionOrLogError","f","e","graphQLResultHasError","result","errors","deepFreeze","o","freeze","getOwnPropertyNames","prop","isFrozen","maybeDeepFreeze","Symbol","mergeDeep","mergeDeepArray","count","pastCopies","shallowCopyForMerge","mergeHelper","isObject","isExtensible","sourceKey","sourceValue","targetValue","Array","isArray","haveWarned","warnOnceInDevelopment","msg","stripSymbols","data","parse"],"mappings":"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","file":"npm.apollo-utilities.cf88e1c32848e7ac87df.react.bundle.js","sourcesContent":["import { __extends } from 'tslib';\n\nvar genericMessage = \"Invariant Violation\";\r\nvar _a = Object.setPrototypeOf, setPrototypeOf = _a === void 0 ? function (obj, proto) {\r\n    obj.__proto__ = proto;\r\n    return obj;\r\n} : _a;\r\nvar InvariantError = /** @class */ (function (_super) {\r\n    __extends(InvariantError, _super);\r\n    function InvariantError(message) {\r\n        if (message === void 0) { message = genericMessage; }\r\n        var _this = _super.call(this, typeof message === \"number\"\r\n            ? genericMessage + \": \" + message + \" (see https://github.com/apollographql/invariant-packages)\"\r\n            : message) || this;\r\n        _this.framesToPop = 1;\r\n        _this.name = genericMessage;\r\n        setPrototypeOf(_this, InvariantError.prototype);\r\n        return _this;\r\n    }\r\n    return InvariantError;\r\n}(Error));\r\nfunction invariant(condition, message) {\r\n    if (!condition) {\r\n        throw new InvariantError(message);\r\n    }\r\n}\r\nfunction wrapConsoleMethod(method) {\r\n    return function () {\r\n        return console[method].apply(console, arguments);\r\n    };\r\n}\r\n(function (invariant) {\r\n    invariant.warn = wrapConsoleMethod(\"warn\");\r\n    invariant.error = wrapConsoleMethod(\"error\");\r\n})(invariant || (invariant = {}));\r\n// Code that uses ts-invariant with rollup-plugin-invariant may want to\r\n// import this process stub to avoid errors evaluating process.env.NODE_ENV.\r\n// However, because most ESM-to-CJS compilers will rewrite the process import\r\n// as tsInvariant.process, which prevents proper replacement by minifiers, we\r\n// also attempt to define the stub globally when it is not already defined.\r\nvar processStub = { env: {} };\r\nif (typeof process === \"object\") {\r\n    processStub = process;\r\n}\r\nelse\r\n    try {\r\n        // Using Function to evaluate this assignment in global scope also escapes\r\n        // the strict mode of the current module, thereby allowing the assignment.\r\n        // Inspired by https://github.com/facebook/regenerator/pull/369.\r\n        Function(\"stub\", \"process = stub\")(processStub);\r\n    }\r\n    catch (atLeastWeTried) {\r\n        // The assignment can fail if a Content Security Policy heavy-handedly\r\n        // forbids Function usage. In those environments, developers should take\r\n        // extra care to replace process.env.NODE_ENV in their production builds,\r\n        // or define an appropriate global.process polyfill.\r\n    }\r\nvar invariant$1 = invariant;\n\nexport default invariant$1;\nexport { InvariantError, invariant, processStub as process };\n//# sourceMappingURL=invariant.esm.js.map\n","var _a = Object.prototype, toString = _a.toString, hasOwnProperty = _a.hasOwnProperty;\r\nvar previousComparisons = new Map();\r\n/**\r\n * Performs a deep equality check on two JavaScript values, tolerating cycles.\r\n */\r\nfunction equal(a, b) {\r\n    try {\r\n        return check(a, b);\r\n    }\r\n    finally {\r\n        previousComparisons.clear();\r\n    }\r\n}\r\nfunction check(a, b) {\r\n    // If the two values are strictly equal, our job is easy.\r\n    if (a === b) {\r\n        return true;\r\n    }\r\n    // Object.prototype.toString returns a representation of the runtime type of\r\n    // the given value that is considerably more precise than typeof.\r\n    var aTag = toString.call(a);\r\n    var bTag = toString.call(b);\r\n    // If the runtime types of a and b are different, they could maybe be equal\r\n    // under some interpretation of equality, but for simplicity and performance\r\n    // we just return false instead.\r\n    if (aTag !== bTag) {\r\n        return false;\r\n    }\r\n    switch (aTag) {\r\n        case '[object Array]':\r\n            // Arrays are a lot like other objects, but we can cheaply compare their\r\n            // lengths as a short-cut before comparing their elements.\r\n            if (a.length !== b.length)\r\n                return false;\r\n        // Fall through to object case...\r\n        case '[object Object]': {\r\n            if (previouslyCompared(a, b))\r\n                return true;\r\n            var aKeys = Object.keys(a);\r\n            var bKeys = Object.keys(b);\r\n            // If `a` and `b` have a different number of enumerable keys, they\r\n            // must be different.\r\n            var keyCount = aKeys.length;\r\n            if (keyCount !== bKeys.length)\r\n                return false;\r\n            // Now make sure they have the same keys.\r\n            for (var k = 0; k < keyCount; ++k) {\r\n                if (!hasOwnProperty.call(b, aKeys[k])) {\r\n                    return false;\r\n                }\r\n            }\r\n            // Finally, check deep equality of all child properties.\r\n            for (var k = 0; k < keyCount; ++k) {\r\n                var key = aKeys[k];\r\n                if (!check(a[key], b[key])) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n        case '[object Error]':\r\n            return a.name === b.name && a.message === b.message;\r\n        case '[object Number]':\r\n            // Handle NaN, which is !== itself.\r\n            if (a !== a)\r\n                return b !== b;\r\n        // Fall through to shared +a === +b case...\r\n        case '[object Boolean]':\r\n        case '[object Date]':\r\n            return +a === +b;\r\n        case '[object RegExp]':\r\n        case '[object String]':\r\n            return a == \"\" + b;\r\n        case '[object Map]':\r\n        case '[object Set]': {\r\n            if (a.size !== b.size)\r\n                return false;\r\n            if (previouslyCompared(a, b))\r\n                return true;\r\n            var aIterator = a.entries();\r\n            var isMap = aTag === '[object Map]';\r\n            while (true) {\r\n                var info = aIterator.next();\r\n                if (info.done)\r\n                    break;\r\n                // If a instanceof Set, aValue === aKey.\r\n                var _a = info.value, aKey = _a[0], aValue = _a[1];\r\n                // So this works the same way for both Set and Map.\r\n                if (!b.has(aKey)) {\r\n                    return false;\r\n                }\r\n                // However, we care about deep equality of values only when dealing\r\n                // with Map structures.\r\n                if (isMap && !check(aValue, b.get(aKey))) {\r\n                    return false;\r\n                }\r\n            }\r\n            return true;\r\n        }\r\n    }\r\n    // Otherwise the values are not equal.\r\n    return false;\r\n}\r\nfunction previouslyCompared(a, b) {\r\n    // Though cyclic references can make an object graph appear infinite from the\r\n    // perspective of a depth-first traversal, the graph still contains a finite\r\n    // number of distinct object references. We use the previousComparisons cache\r\n    // to avoid comparing the same pair of object references more than once, which\r\n    // guarantees termination (even if we end up comparing every object in one\r\n    // graph to every object in the other graph, which is extremely unlikely),\r\n    // while still allowing weird isomorphic structures (like rings with different\r\n    // lengths) a chance to pass the equality test.\r\n    var bSet = previousComparisons.get(a);\r\n    if (bSet) {\r\n        // Return true here because we can be sure false will be returned somewhere\r\n        // else if the objects are not equivalent.\r\n        if (bSet.has(b))\r\n            return true;\r\n    }\r\n    else {\r\n        previousComparisons.set(a, bSet = new Set);\r\n    }\r\n    bSet.add(b);\r\n    return false;\r\n}\n\nexport default equal;\nexport { equal };\n//# sourceMappingURL=equality.esm.js.map\n","import { visit } from 'graphql/language/visitor';\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { __assign, __spreadArrays } from 'tslib';\nimport stringify from 'fast-json-stable-stringify';\nexport { equal as isEqual } from '@wry/equality';\n\nfunction isScalarValue(value) {\n    return ['StringValue', 'BooleanValue', 'EnumValue'].indexOf(value.kind) > -1;\n}\nfunction isNumberValue(value) {\n    return ['IntValue', 'FloatValue'].indexOf(value.kind) > -1;\n}\nfunction isStringValue(value) {\n    return value.kind === 'StringValue';\n}\nfunction isBooleanValue(value) {\n    return value.kind === 'BooleanValue';\n}\nfunction isIntValue(value) {\n    return value.kind === 'IntValue';\n}\nfunction isFloatValue(value) {\n    return value.kind === 'FloatValue';\n}\nfunction isVariable(value) {\n    return value.kind === 'Variable';\n}\nfunction isObjectValue(value) {\n    return value.kind === 'ObjectValue';\n}\nfunction isListValue(value) {\n    return value.kind === 'ListValue';\n}\nfunction isEnumValue(value) {\n    return value.kind === 'EnumValue';\n}\nfunction isNullValue(value) {\n    return value.kind === 'NullValue';\n}\nfunction valueToObjectRepresentation(argObj, name, value, variables) {\n    if (isIntValue(value) || isFloatValue(value)) {\n        argObj[name.value] = Number(value.value);\n    }\n    else if (isBooleanValue(value) || isStringValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isObjectValue(value)) {\n        var nestedArgObj_1 = {};\n        value.fields.map(function (obj) {\n            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n        });\n        argObj[name.value] = nestedArgObj_1;\n    }\n    else if (isVariable(value)) {\n        var variableValue = (variables || {})[value.name.value];\n        argObj[name.value] = variableValue;\n    }\n    else if (isListValue(value)) {\n        argObj[name.value] = value.values.map(function (listValue) {\n            var nestedArgArrayObj = {};\n            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n            return nestedArgArrayObj[name.value];\n        });\n    }\n    else if (isEnumValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isNullValue(value)) {\n        argObj[name.value] = null;\n    }\n    else {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(17) : new InvariantError(\"The inline argument \\\"\" + name.value + \"\\\" of kind \\\"\" + value.kind + \"\\\"\" +\n            'is not supported. Use variables instead of inline arguments to ' +\n            'overcome this limitation.');\n    }\n}\nfunction storeKeyNameFromField(field, variables) {\n    var directivesObj = null;\n    if (field.directives) {\n        directivesObj = {};\n        field.directives.forEach(function (directive) {\n            directivesObj[directive.name.value] = {};\n            if (directive.arguments) {\n                directive.arguments.forEach(function (_a) {\n                    var name = _a.name, value = _a.value;\n                    return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n                });\n            }\n        });\n    }\n    var argObj = null;\n    if (field.arguments && field.arguments.length) {\n        argObj = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj, name, value, variables);\n        });\n    }\n    return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\nvar KNOWN_DIRECTIVES = [\n    'connection',\n    'include',\n    'skip',\n    'client',\n    'rest',\n    'export',\n];\nfunction getStoreKeyName(fieldName, args, directives) {\n    if (directives &&\n        directives['connection'] &&\n        directives['connection']['key']) {\n        if (directives['connection']['filter'] &&\n            directives['connection']['filter'].length > 0) {\n            var filterKeys = directives['connection']['filter']\n                ? directives['connection']['filter']\n                : [];\n            filterKeys.sort();\n            var queryArgs_1 = args;\n            var filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = queryArgs_1[key];\n            });\n            return directives['connection']['key'] + \"(\" + JSON.stringify(filteredArgs_1) + \")\";\n        }\n        else {\n            return directives['connection']['key'];\n        }\n    }\n    var completeFieldName = fieldName;\n    if (args) {\n        var stringifiedArgs = stringify(args);\n        completeFieldName += \"(\" + stringifiedArgs + \")\";\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\" + key + \"(\" + JSON.stringify(directives[key]) + \")\";\n            }\n            else {\n                completeFieldName += \"@\" + key;\n            }\n        });\n    }\n    return completeFieldName;\n}\nfunction argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        var argObj_1 = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj_1, name, value, variables);\n        });\n        return argObj_1;\n    }\n    return null;\n}\nfunction resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nfunction isField(selection) {\n    return selection.kind === 'Field';\n}\nfunction isInlineFragment(selection) {\n    return selection.kind === 'InlineFragment';\n}\nfunction isIdValue(idObject) {\n    return idObject &&\n        idObject.type === 'id' &&\n        typeof idObject.generated === 'boolean';\n}\nfunction toIdValue(idConfig, generated) {\n    if (generated === void 0) { generated = false; }\n    return __assign({ type: 'id', generated: generated }, (typeof idConfig === 'string'\n        ? { id: idConfig, typename: undefined }\n        : idConfig));\n}\nfunction isJsonValue(jsonObject) {\n    return (jsonObject != null &&\n        typeof jsonObject === 'object' &&\n        jsonObject.type === 'json');\n}\nfunction defaultValueFromVariable(node) {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(18) : new InvariantError(\"Variable nodes are not supported by valueFromNode\");\n}\nfunction valueFromNode(node, onVariable) {\n    if (onVariable === void 0) { onVariable = defaultValueFromVariable; }\n    switch (node.kind) {\n        case 'Variable':\n            return onVariable(node);\n        case 'NullValue':\n            return null;\n        case 'IntValue':\n            return parseInt(node.value, 10);\n        case 'FloatValue':\n            return parseFloat(node.value);\n        case 'ListValue':\n            return node.values.map(function (v) { return valueFromNode(v, onVariable); });\n        case 'ObjectValue': {\n            var value = {};\n            for (var _i = 0, _a = node.fields; _i < _a.length; _i++) {\n                var field = _a[_i];\n                value[field.name.value] = valueFromNode(field.value, onVariable);\n            }\n            return value;\n        }\n        default:\n            return node.value;\n    }\n}\n\nfunction getDirectiveInfoFromField(field, variables) {\n    if (field.directives && field.directives.length) {\n        var directiveObj_1 = {};\n        field.directives.forEach(function (directive) {\n            directiveObj_1[directive.name.value] = argumentsObjectFromField(directive, variables);\n        });\n        return directiveObj_1;\n    }\n    return null;\n}\nfunction shouldInclude(selection, variables) {\n    if (variables === void 0) { variables = {}; }\n    return getInclusionDirectives(selection.directives).every(function (_a) {\n        var directive = _a.directive, ifArgument = _a.ifArgument;\n        var evaledValue = false;\n        if (ifArgument.value.kind === 'Variable') {\n            evaledValue = variables[ifArgument.value.name.value];\n            process.env.NODE_ENV === \"production\" ? invariant(evaledValue !== void 0, 13) : invariant(evaledValue !== void 0, \"Invalid variable referenced in @\" + directive.name.value + \" directive.\");\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n    });\n}\nfunction getDirectiveNames(doc) {\n    var names = [];\n    visit(doc, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nfunction hasDirectives(names, doc) {\n    return getDirectiveNames(doc).some(function (name) { return names.indexOf(name) > -1; });\n}\nfunction hasClientExports(document) {\n    return (document &&\n        hasDirectives(['client'], document) &&\n        hasDirectives(['export'], document));\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === 'skip' || value === 'include';\n}\nfunction getInclusionDirectives(directives) {\n    return directives ? directives.filter(isInclusionDirective).map(function (directive) {\n        var directiveArguments = directive.arguments;\n        var directiveName = directive.name.value;\n        process.env.NODE_ENV === \"production\" ? invariant(directiveArguments && directiveArguments.length === 1, 14) : invariant(directiveArguments && directiveArguments.length === 1, \"Incorrect number of arguments for the @\" + directiveName + \" directive.\");\n        var ifArgument = directiveArguments[0];\n        process.env.NODE_ENV === \"production\" ? invariant(ifArgument.name && ifArgument.name.value === 'if', 15) : invariant(ifArgument.name && ifArgument.name.value === 'if', \"Invalid argument for the @\" + directiveName + \" directive.\");\n        var ifValue = ifArgument.value;\n        process.env.NODE_ENV === \"production\" ? invariant(ifValue &&\n            (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 16) : invariant(ifValue &&\n            (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), \"Argument for the @\" + directiveName + \" directive must be a variable or a boolean value.\");\n        return { directive: directive, ifArgument: ifArgument };\n    }) : [];\n}\n\nfunction getFragmentQueryDocument(document, fragmentName) {\n    var actualFragmentName = fragmentName;\n    var fragments = [];\n    document.definitions.forEach(function (definition) {\n        if (definition.kind === 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(11) : new InvariantError(\"Found a \" + definition.operation + \" operation\" + (definition.name ? \" named '\" + definition.name.value + \"'\" : '') + \". \" +\n                'No operations are allowed when using a fragment as a query. Only fragments are allowed.');\n        }\n        if (definition.kind === 'FragmentDefinition') {\n            fragments.push(definition);\n        }\n    });\n    if (typeof actualFragmentName === 'undefined') {\n        process.env.NODE_ENV === \"production\" ? invariant(fragments.length === 1, 12) : invariant(fragments.length === 1, \"Found \" + fragments.length + \" fragments. `fragmentName` must be provided when there is not exactly 1 fragment.\");\n        actualFragmentName = fragments[0].name.value;\n    }\n    var query = __assign(__assign({}, document), { definitions: __spreadArrays([\n            {\n                kind: 'OperationDefinition',\n                operation: 'query',\n                selectionSet: {\n                    kind: 'SelectionSet',\n                    selections: [\n                        {\n                            kind: 'FragmentSpread',\n                            name: {\n                                kind: 'Name',\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions) });\n    return query;\n}\n\nfunction assign(target) {\n    var sources = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        sources[_i - 1] = arguments[_i];\n    }\n    sources.forEach(function (source) {\n        if (typeof source === 'undefined' || source === null) {\n            return;\n        }\n        Object.keys(source).forEach(function (key) {\n            target[key] = source[key];\n        });\n    });\n    return target;\n}\n\nfunction getMutationDefinition(doc) {\n    checkDocument(doc);\n    var mutationDef = doc.definitions.filter(function (definition) {\n        return definition.kind === 'OperationDefinition' &&\n            definition.operation === 'mutation';\n    })[0];\n    process.env.NODE_ENV === \"production\" ? invariant(mutationDef, 1) : invariant(mutationDef, 'Must contain a mutation definition.');\n    return mutationDef;\n}\nfunction checkDocument(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc && doc.kind === 'Document', 2) : invariant(doc && doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== 'FragmentDefinition'; })\n        .map(function (definition) {\n        if (definition.kind !== 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(3) : new InvariantError(\"Schema type definitions not allowed in queries. Found: \\\"\" + definition.kind + \"\\\"\");\n        }\n        return definition;\n    });\n    process.env.NODE_ENV === \"production\" ? invariant(operations.length <= 1, 4) : invariant(operations.length <= 1, \"Ambiguous GraphQL document: contains \" + operations.length + \" operations\");\n    return doc;\n}\nfunction getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) { return definition.kind === 'OperationDefinition'; })[0];\n}\nfunction getOperationDefinitionOrDie(document) {\n    var def = getOperationDefinition(document);\n    process.env.NODE_ENV === \"production\" ? invariant(def, 5) : invariant(def, \"GraphQL document is missing an operation\");\n    return def;\n}\nfunction getOperationName(doc) {\n    return (doc.definitions\n        .filter(function (definition) {\n        return definition.kind === 'OperationDefinition' && definition.name;\n    })\n        .map(function (x) { return x.name.value; })[0] || null);\n}\nfunction getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) { return definition.kind === 'FragmentDefinition'; });\n}\nfunction getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    process.env.NODE_ENV === \"production\" ? invariant(queryDef && queryDef.operation === 'query', 6) : invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.');\n    return queryDef;\n}\nfunction getFragmentDefinition(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc.kind === 'Document', 7) : invariant(doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    process.env.NODE_ENV === \"production\" ? invariant(doc.definitions.length <= 1, 8) : invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.');\n    var fragmentDef = doc.definitions[0];\n    process.env.NODE_ENV === \"production\" ? invariant(fragmentDef.kind === 'FragmentDefinition', 9) : invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.');\n    return fragmentDef;\n}\nfunction getMainDefinition(queryDoc) {\n    checkDocument(queryDoc);\n    var fragmentDefinition;\n    for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n        var definition = _a[_i];\n        if (definition.kind === 'OperationDefinition') {\n            var operation = definition.operation;\n            if (operation === 'query' ||\n                operation === 'mutation' ||\n                operation === 'subscription') {\n                return definition;\n            }\n        }\n        if (definition.kind === 'FragmentDefinition' && !fragmentDefinition) {\n            fragmentDefinition = definition;\n        }\n    }\n    if (fragmentDefinition) {\n        return fragmentDefinition;\n    }\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.');\n}\nfunction createFragmentMap(fragments) {\n    if (fragments === void 0) { fragments = []; }\n    var symTable = {};\n    fragments.forEach(function (fragment) {\n        symTable[fragment.name.value] = fragment;\n    });\n    return symTable;\n}\nfunction getDefaultValues(definition) {\n    if (definition &&\n        definition.variableDefinitions &&\n        definition.variableDefinitions.length) {\n        var defaultValues = definition.variableDefinitions\n            .filter(function (_a) {\n            var defaultValue = _a.defaultValue;\n            return defaultValue;\n        })\n            .map(function (_a) {\n            var variable = _a.variable, defaultValue = _a.defaultValue;\n            var defaultValueObj = {};\n            valueToObjectRepresentation(defaultValueObj, variable.name, defaultValue);\n            return defaultValueObj;\n        });\n        return assign.apply(void 0, __spreadArrays([{}], defaultValues));\n    }\n    return {};\n}\nfunction variablesInOperation(operation) {\n    var names = new Set();\n    if (operation.variableDefinitions) {\n        for (var _i = 0, _a = operation.variableDefinitions; _i < _a.length; _i++) {\n            var definition = _a[_i];\n            names.add(definition.variable.name.value);\n        }\n    }\n    return names;\n}\n\nfunction filterInPlace(array, test, context) {\n    var target = 0;\n    array.forEach(function (elem, i) {\n        if (test.call(this, elem, i, array)) {\n            array[target++] = elem;\n        }\n    }, context);\n    array.length = target;\n    return array;\n}\n\nvar TYPENAME_FIELD = {\n    kind: 'Field',\n    name: {\n        kind: 'Name',\n        value: '__typename',\n    },\n};\nfunction isEmpty(op, fragments) {\n    return op.selectionSet.selections.every(function (selection) {\n        return selection.kind === 'FragmentSpread' &&\n            isEmpty(fragments[selection.name.value], fragments);\n    });\n}\nfunction nullIfDocIsEmpty(doc) {\n    return isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))\n        ? null\n        : doc;\n}\nfunction getDirectiveMatcher(directives) {\n    return function directiveMatcher(directive) {\n        return directives.some(function (dir) {\n            return (dir.name && dir.name === directive.name.value) ||\n                (dir.test && dir.test(directive));\n        });\n    };\n}\nfunction removeDirectivesFromDocument(directives, doc) {\n    var variablesInUse = Object.create(null);\n    var variablesToRemove = [];\n    var fragmentSpreadsInUse = Object.create(null);\n    var fragmentSpreadsToRemove = [];\n    var modifiedDoc = nullIfDocIsEmpty(visit(doc, {\n        Variable: {\n            enter: function (node, _key, parent) {\n                if (parent.kind !== 'VariableDefinition') {\n                    variablesInUse[node.name.value] = true;\n                }\n            },\n        },\n        Field: {\n            enter: function (node) {\n                if (directives && node.directives) {\n                    var shouldRemoveField = directives.some(function (directive) { return directive.remove; });\n                    if (shouldRemoveField &&\n                        node.directives &&\n                        node.directives.some(getDirectiveMatcher(directives))) {\n                        if (node.arguments) {\n                            node.arguments.forEach(function (arg) {\n                                if (arg.value.kind === 'Variable') {\n                                    variablesToRemove.push({\n                                        name: arg.value.name.value,\n                                    });\n                                }\n                            });\n                        }\n                        if (node.selectionSet) {\n                            getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(function (frag) {\n                                fragmentSpreadsToRemove.push({\n                                    name: frag.name.value,\n                                });\n                            });\n                        }\n                        return null;\n                    }\n                }\n            },\n        },\n        FragmentSpread: {\n            enter: function (node) {\n                fragmentSpreadsInUse[node.name.value] = true;\n            },\n        },\n        Directive: {\n            enter: function (node) {\n                if (getDirectiveMatcher(directives)(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n    if (modifiedDoc &&\n        filterInPlace(variablesToRemove, function (v) { return !variablesInUse[v.name]; }).length) {\n        modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n    }\n    if (modifiedDoc &&\n        filterInPlace(fragmentSpreadsToRemove, function (fs) { return !fragmentSpreadsInUse[fs.name]; })\n            .length) {\n        modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);\n    }\n    return modifiedDoc;\n}\nfunction addTypenameToDocument(doc) {\n    return visit(checkDocument(doc), {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                if (parent &&\n                    parent.kind === 'OperationDefinition') {\n                    return;\n                }\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                var skip = selections.some(function (selection) {\n                    return (isField(selection) &&\n                        (selection.name.value === '__typename' ||\n                            selection.name.value.lastIndexOf('__', 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                var field = parent;\n                if (isField(field) &&\n                    field.directives &&\n                    field.directives.some(function (d) { return d.name.value === 'export'; })) {\n                    return;\n                }\n                return __assign(__assign({}, node), { selections: __spreadArrays(selections, [TYPENAME_FIELD]) });\n            },\n        },\n    });\n}\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === 'connection';\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === 'key'; })) {\n                process.env.NODE_ENV === \"production\" || invariant.warn('Removing an @connection directive even though it does not have a key. ' +\n                    'You may want to use the key parameter to specify a store key.');\n            }\n        }\n        return willRemove;\n    },\n};\nfunction removeConnectionDirectiveFromDocument(doc) {\n    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\nfunction hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    return (selectionSet &&\n        selectionSet.selections &&\n        selectionSet.selections.some(function (selection) {\n            return hasDirectivesInSelection(directives, selection, nestedCheck);\n        }));\n}\nfunction hasDirectivesInSelection(directives, selection, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    if (!isField(selection)) {\n        return true;\n    }\n    if (!selection.directives) {\n        return false;\n    }\n    return (selection.directives.some(getDirectiveMatcher(directives)) ||\n        (nestedCheck &&\n            hasDirectivesInSelectionSet(directives, selection.selectionSet, nestedCheck)));\n}\nfunction getDirectivesFromDocument(directives, doc) {\n    checkDocument(doc);\n    var parentPath;\n    return nullIfDocIsEmpty(visit(doc, {\n        SelectionSet: {\n            enter: function (node, _key, _parent, path) {\n                var currentPath = path.join('-');\n                if (!parentPath ||\n                    currentPath === parentPath ||\n                    !currentPath.startsWith(parentPath)) {\n                    if (node.selections) {\n                        var selectionsWithDirectives = node.selections.filter(function (selection) { return hasDirectivesInSelection(directives, selection); });\n                        if (hasDirectivesInSelectionSet(directives, node, false)) {\n                            parentPath = currentPath;\n                        }\n                        return __assign(__assign({}, node), { selections: selectionsWithDirectives });\n                    }\n                    else {\n                        return null;\n                    }\n                }\n            },\n        },\n    }));\n}\nfunction getArgumentMatcher(config) {\n    return function argumentMatcher(argument) {\n        return config.some(function (aConfig) {\n            return argument.value &&\n                argument.value.kind === 'Variable' &&\n                argument.value.name &&\n                (aConfig.name === argument.value.name.value ||\n                    (aConfig.test && aConfig.test(argument)));\n        });\n    };\n}\nfunction removeArgumentsFromDocument(config, doc) {\n    var argMatcher = getArgumentMatcher(config);\n    return nullIfDocIsEmpty(visit(doc, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n                        return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });\n                    }) });\n            },\n        },\n        Field: {\n            enter: function (node) {\n                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });\n                if (shouldRemoveField) {\n                    var argMatchCount_1 = 0;\n                    node.arguments.forEach(function (arg) {\n                        if (argMatcher(arg)) {\n                            argMatchCount_1 += 1;\n                        }\n                    });\n                    if (argMatchCount_1 === 1) {\n                        return null;\n                    }\n                }\n            },\n        },\n        Argument: {\n            enter: function (node) {\n                if (argMatcher(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n}\nfunction removeFragmentSpreadFromDocument(config, doc) {\n    function enter(node) {\n        if (config.some(function (def) { return def.name === node.name.value; })) {\n            return null;\n        }\n    }\n    return nullIfDocIsEmpty(visit(doc, {\n        FragmentSpread: { enter: enter },\n        FragmentDefinition: { enter: enter },\n    }));\n}\nfunction getAllFragmentSpreadsFromSelectionSet(selectionSet) {\n    var allFragments = [];\n    selectionSet.selections.forEach(function (selection) {\n        if ((isField(selection) || isInlineFragment(selection)) &&\n            selection.selectionSet) {\n            getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(function (frag) { return allFragments.push(frag); });\n        }\n        else if (selection.kind === 'FragmentSpread') {\n            allFragments.push(selection);\n        }\n    });\n    return allFragments;\n}\nfunction buildQueryFromSelectionSet(document) {\n    var definition = getMainDefinition(document);\n    var definitionOperation = definition.operation;\n    if (definitionOperation === 'query') {\n        return document;\n    }\n    var modifiedDoc = visit(document, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { operation: 'query' });\n            },\n        },\n    });\n    return modifiedDoc;\n}\nfunction removeClientSetsFromDocument(document) {\n    checkDocument(document);\n    var modifiedDoc = removeDirectivesFromDocument([\n        {\n            test: function (directive) { return directive.name.value === 'client'; },\n            remove: true,\n        },\n    ], document);\n    if (modifiedDoc) {\n        modifiedDoc = visit(modifiedDoc, {\n            FragmentDefinition: {\n                enter: function (node) {\n                    if (node.selectionSet) {\n                        var isTypenameOnly = node.selectionSet.selections.every(function (selection) {\n                            return isField(selection) && selection.name.value === '__typename';\n                        });\n                        if (isTypenameOnly) {\n                            return null;\n                        }\n                    }\n                },\n            },\n        });\n    }\n    return modifiedDoc;\n}\n\nvar canUseWeakMap = typeof WeakMap === 'function' && !(typeof navigator === 'object' &&\n    navigator.product === 'ReactNative');\n\nvar toString = Object.prototype.toString;\nfunction cloneDeep(value) {\n    return cloneDeepHelper(value, new Map());\n}\nfunction cloneDeepHelper(val, seen) {\n    switch (toString.call(val)) {\n        case \"[object Array]\": {\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_1 = val.slice(0);\n            seen.set(val, copy_1);\n            copy_1.forEach(function (child, i) {\n                copy_1[i] = cloneDeepHelper(child, seen);\n            });\n            return copy_1;\n        }\n        case \"[object Object]\": {\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_2 = Object.create(Object.getPrototypeOf(val));\n            seen.set(val, copy_2);\n            Object.keys(val).forEach(function (key) {\n                copy_2[key] = cloneDeepHelper(val[key], seen);\n            });\n            return copy_2;\n        }\n        default:\n            return val;\n    }\n}\n\nfunction getEnv() {\n    if (typeof process !== 'undefined' && process.env.NODE_ENV) {\n        return process.env.NODE_ENV;\n    }\n    return 'development';\n}\nfunction isEnv(env) {\n    return getEnv() === env;\n}\nfunction isProduction() {\n    return isEnv('production') === true;\n}\nfunction isDevelopment() {\n    return isEnv('development') === true;\n}\nfunction isTest() {\n    return isEnv('test') === true;\n}\n\nfunction tryFunctionOrLogError(f) {\n    try {\n        return f();\n    }\n    catch (e) {\n        if (console.error) {\n            console.error(e);\n        }\n    }\n}\nfunction graphQLResultHasError(result) {\n    return result.errors && result.errors.length;\n}\n\nfunction deepFreeze(o) {\n    Object.freeze(o);\n    Object.getOwnPropertyNames(o).forEach(function (prop) {\n        if (o[prop] !== null &&\n            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&\n            !Object.isFrozen(o[prop])) {\n            deepFreeze(o[prop]);\n        }\n    });\n    return o;\n}\nfunction maybeDeepFreeze(obj) {\n    if (isDevelopment() || isTest()) {\n        var symbolIsPolyfilled = typeof Symbol === 'function' && typeof Symbol('') === 'string';\n        if (!symbolIsPolyfilled) {\n            return deepFreeze(obj);\n        }\n    }\n    return obj;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\nfunction mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var pastCopies = [];\n        target = shallowCopyForMerge(target, pastCopies);\n        for (var i = 1; i < count; ++i) {\n            target = mergeHelper(target, sources[i], pastCopies);\n        }\n    }\n    return target;\n}\nfunction isObject(obj) {\n    return obj !== null && typeof obj === 'object';\n}\nfunction mergeHelper(target, source, pastCopies) {\n    if (isObject(source) && isObject(target)) {\n        if (Object.isExtensible && !Object.isExtensible(target)) {\n            target = shallowCopyForMerge(target, pastCopies);\n        }\n        Object.keys(source).forEach(function (sourceKey) {\n            var sourceValue = source[sourceKey];\n            if (hasOwnProperty.call(target, sourceKey)) {\n                var targetValue = target[sourceKey];\n                if (sourceValue !== targetValue) {\n                    target[sourceKey] = mergeHelper(shallowCopyForMerge(targetValue, pastCopies), sourceValue, pastCopies);\n                }\n            }\n            else {\n                target[sourceKey] = sourceValue;\n            }\n        });\n        return target;\n    }\n    return source;\n}\nfunction shallowCopyForMerge(value, pastCopies) {\n    if (value !== null &&\n        typeof value === 'object' &&\n        pastCopies.indexOf(value) < 0) {\n        if (Array.isArray(value)) {\n            value = value.slice(0);\n        }\n        else {\n            value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n        }\n        pastCopies.push(value);\n    }\n    return value;\n}\n\nvar haveWarned = Object.create({});\nfunction warnOnceInDevelopment(msg, type) {\n    if (type === void 0) { type = 'warn'; }\n    if (!isProduction() && !haveWarned[msg]) {\n        if (!isTest()) {\n            haveWarned[msg] = true;\n        }\n        if (type === 'error') {\n            console.error(msg);\n        }\n        else {\n            console.warn(msg);\n        }\n    }\n}\n\nfunction stripSymbols(data) {\n    return JSON.parse(JSON.stringify(data));\n}\n\nexport { addTypenameToDocument, argumentsObjectFromField, assign, buildQueryFromSelectionSet, canUseWeakMap, checkDocument, cloneDeep, createFragmentMap, getDefaultValues, getDirectiveInfoFromField, getDirectiveNames, getDirectivesFromDocument, getEnv, getFragmentDefinition, getFragmentDefinitions, getFragmentQueryDocument, getInclusionDirectives, getMainDefinition, getMutationDefinition, getOperationDefinition, getOperationDefinitionOrDie, getOperationName, getQueryDefinition, getStoreKeyName, graphQLResultHasError, hasClientExports, hasDirectives, isDevelopment, isEnv, isField, isIdValue, isInlineFragment, isJsonValue, isNumberValue, isProduction, isScalarValue, isTest, maybeDeepFreeze, mergeDeep, mergeDeepArray, removeArgumentsFromDocument, removeClientSetsFromDocument, removeConnectionDirectiveFromDocument, removeDirectivesFromDocument, removeFragmentSpreadFromDocument, resultKeyNameFromField, shouldInclude, storeKeyNameFromField, stripSymbols, toIdValue, tryFunctionOrLogError, valueFromNode, valueToObjectRepresentation, variablesInOperation, warnOnceInDevelopment };\n//# sourceMappingURL=bundle.esm.js.map\n"],"sourceRoot":""}