{"version":3,"sources":["webpack://web/./node_modules/apollo-link-rest/bundle.umd.js"],"names":["exports","core","utilities","async","qs","extendStatics","__extends","d","b","Object","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__","this","constructor","prototype","create","__assign","assign","t","s","i","n","arguments","length","call","apply","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","value","step","next","e","rejected","result","done","then","__generator","body","f","y","g","_","label","sent","trys","ops","verb","Symbol","iterator","v","op","TypeError","pop","push","__spreadArrays","il","r","k","a","j","jl","addTypeNameToResult","__typename","typePatcher","isArray","fixedTypename_1","noSpace","replace","str","matchStr","offset","fullStr","map","findRestDirectivesThenInsertNullsForOmittedFields","resultKey","current","mainDefinition","fragmentMap","currentSelectionSet","selections","forEach","node","isInlineFragment","selectionSet","kind","fragment","name","isField","Error","resultKeyNameFromField","field","directives","find","directive","insertNullsForAnyOmittedFields","c","PathBuilder","replacerForPath","path","cache","queryOrigStartIndex","indexOf","pathBits","split","argReplacement","chunkActions","hasBegunQuery","reduce","processedCount","bit","nextIndex","_keyPath_1","slice","props","useQSEncoder","PathBuilderLookupValue","stringify","String","key","join","warnTable","console","warn","hasEnteredQuery","accumulator","action","tmp","keyPath","remainingKeyPath","shift","noMangleKeys","convertObjectKeys","object","__converter","keypath","converter","FileList","File","o","index","keys","acc","nestedKeyPath","noOpNameNormalizer","normalizeHeaders","headers","Headers","concatHeadersMergePolicy","headerGroups","_i","append","makeOverrideHeadersMergePolicy","headersToOverride","linkHeaders","requestHeaders","overrideHeadersMergePolicy","SUPPORTED_HTTP_VERBS","addTypeToNode","typename","item","resolver","fieldName","root","args","context","info","isLeaf","exportVariablesByNode","exportVariables","copyExportVariables","aliasedNode","preAliasingNode","isATypeCall","credentials","endpoints","customFetch","operationType","fragmentDefinitions","fieldNameNormalizer","linkLevelNameDenormalizer","serializers","responseTransformer","_a","endpoint","pathBuilder","endpointOption","allParams","pathWithParams","_b","method","type","bodyBuilder","bodyKey","perRequestNameDenormalizer","bodySerializer","overrideHeaders","maybeBody_1","serializedBody","requestParams","requestUrl","response","parsed","transformer","err_1","_c","get","set","export","as","rest","fieldNameDenormalizer","createFragmentMap","DEFAULT_ENDPOINT_KEY","uri","getEndpointOptions","includes","legacyArgs","undefined","replaceLegacyParam","replacer","argsWithExport","DEFAULT_SERIALIZER_KEY","toUpperCase","validateRequestMethodForOperationType","fetch","responses","ok","status","clone","json","text","message","error","statusCode","rethrowServerSideError","DEFAULT_JSON_SERIALIZER","data","has","JSON","CONNECTION_REMOVE_CONFIG","test","remove","RestLink","_super","bodySerializers","defaultSerializer","_this","fallback","currentDefaultURI","_2","patcher","table_1","outerType","patchDeeper","subPatcher","processedDocuments","Map","removeRestSetsFromDocument","query","cached","checkDocument","docClone","removeDirectivesFromDocument","request","operation","forward","variables","getContext","setContext","hasDirectives","nonRest","headersMergePolicy","obs","queryWithTypename","addTypenameToDocument","getMainDefinition","getFragmentDefinitions","requestContext","resolverOptions","Observable","of","flatMap","errors","observer","graphql","restResponses","concat","complete","catch","err","ApolloLink","defineProperty","factory"],"mappings":"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","file":"npm.apollo-link-rest.63a80c649864db2dac4d.react.bundle.js","sourcesContent":["(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@apollo/client/core'), require('@apollo/client/utilities'), require('graphql-anywhere/lib/async'), require('qs')) :\n    typeof define === 'function' && define.amd ? define(['exports', '@apollo/client/core', '@apollo/client/utilities', 'graphql-anywhere/lib/async', 'qs'], factory) :\n    (factory((global['apollo-link-rest'] = {}),global.apolloClient.core,global.apolloClient.utilities,global.graphqlAnywhere.async,global.qs));\n}(this, (function (exports,core,utilities,async,qs) { 'use strict';\n\n    var __extends = (undefined && undefined.__extends) || (function () {\n        var extendStatics = function (d, b) {\n            extendStatics = Object.setPrototypeOf ||\n                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n            return extendStatics(d, b);\n        };\n        return function (d, b) {\n            extendStatics(d, b);\n            function __() { this.constructor = d; }\n            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n        };\n    })();\n    var __assign = (undefined && undefined.__assign) || function () {\n        __assign = Object.assign || function(t) {\n            for (var s, i = 1, n = arguments.length; i < n; i++) {\n                s = arguments[i];\n                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                    t[p] = s[p];\n            }\n            return t;\n        };\n        return __assign.apply(this, arguments);\n    };\n    var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {\n        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n        return new (P || (P = Promise))(function (resolve, reject) {\n            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n            function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n            step((generator = generator.apply(thisArg, _arguments || [])).next());\n        });\n    };\n    var __generator = (undefined && undefined.__generator) || function (thisArg, body) {\n        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n        return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n        function verb(n) { return function (v) { return step([n, v]); }; }\n        function step(op) {\n            if (f) throw new TypeError(\"Generator is already executing.\");\n            while (_) try {\n                if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n                if (y = 0, t) op = [op[0] & 2, t.value];\n                switch (op[0]) {\n                    case 0: case 1: t = op; break;\n                    case 4: _.label++; return { value: op[1], done: false };\n                    case 5: _.label++; y = op[1]; op = [0]; continue;\n                    case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                    default:\n                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                        if (t[2]) _.ops.pop();\n                        _.trys.pop(); continue;\n                }\n                op = body.call(thisArg, _);\n            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n        }\n    };\n    var __spreadArrays = (undefined && undefined.__spreadArrays) || function () {\n        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\n        for (var r = Array(s), k = 0, i = 0; i < il; i++)\n            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\n                r[k] = a[j];\n        return r;\n    };\n    var popOneSetOfArrayBracketsFromTypeName = function (typename) {\n        var noSpace = typename.replace(/\\s/g, '');\n        var sansOneBracketPair = noSpace.replace(/\\[(.*)\\]/, function (str, matchStr, offset, fullStr) {\n            return (((matchStr != null && matchStr.length) > 0 ? matchStr : null) || noSpace);\n        });\n        return sansOneBracketPair;\n    };\n    var addTypeNameToResult = function (result, __typename, typePatcher) {\n        if (Array.isArray(result)) {\n            var fixedTypename_1 = popOneSetOfArrayBracketsFromTypeName(__typename);\n            // Recursion needed for multi-dimensional arrays\n            return result.map(function (e) { return addTypeNameToResult(e, fixedTypename_1, typePatcher); });\n        }\n        if (null == result ||\n            typeof result === 'number' ||\n            typeof result === 'boolean' ||\n            typeof result === 'string') {\n            return result;\n        }\n        return typePatcher(result, __typename, typePatcher);\n    };\n    var quickFindRestDirective = function (field) {\n        if (field.directives && field.directives.length) {\n            return field.directives.find(function (directive) { return 'rest' === directive.name.value; });\n        }\n        return null;\n    };\n    /**\n     * The way graphql works today, it doesn't hand us the AST tree for our query, it hands us the ROOT\n     * This method searches for REST-directive-attached nodes that are named to match this query.\n     *\n     * A little bit of wasted compute, but alternative would be a patch in graphql-anywhere.\n     *\n     * @param resultKey SearchKey for REST directive-attached item matching this sub-query\n     * @param current current node in the REST-JSON-response\n     * @param mainDefinition Parsed Query Definition\n     * @param fragmentMap Map of Named Fragments\n     * @param currentSelectionSet Current selection set we're filtering by\n     */\n    function findRestDirectivesThenInsertNullsForOmittedFields(resultKey, current, // currentSelectionSet starts at root, so wait until we're inside a Field tagged with an @rest directive to activate!\n    mainDefinition, fragmentMap, currentSelectionSet) {\n        if (currentSelectionSet == null ||\n            null == current ||\n            typeof current === 'number' ||\n            typeof current === 'boolean' ||\n            typeof current === 'string') {\n            return current;\n        }\n        currentSelectionSet.selections.forEach(function (node) {\n            if (utilities.isInlineFragment(node)) {\n                findRestDirectivesThenInsertNullsForOmittedFields(resultKey, current, mainDefinition, fragmentMap, node.selectionSet);\n            }\n            else if (node.kind === 'FragmentSpread') {\n                var fragment = fragmentMap[node.name.value];\n                findRestDirectivesThenInsertNullsForOmittedFields(resultKey, current, mainDefinition, fragmentMap, fragment.selectionSet);\n            }\n            else if (utilities.isField(node)) {\n                var name_1 = utilities.resultKeyNameFromField(node);\n                if (name_1 === resultKey && quickFindRestDirective(node) != null) {\n                    // Jackpot! We found our selectionSet!\n                    insertNullsForAnyOmittedFields(current, mainDefinition, fragmentMap, node.selectionSet);\n                }\n                else {\n                    findRestDirectivesThenInsertNullsForOmittedFields(resultKey, current, mainDefinition, fragmentMap, node.selectionSet);\n                }\n            }\n            else {\n                // This will give a TypeScript build-time error if you did something wrong or the AST changes!\n                return (function (node) {\n                    throw new Error('Unhandled Node Type in SelectionSetNode.selections');\n                })(node);\n            }\n        });\n        // Return current to have our result pass to next link in async promise chain!\n        return current;\n    }\n    /**\n     * Recursively walks a handed object in parallel with the Query SelectionSet,\n     *  and inserts `null` for any field that is missing from the response.\n     *\n     * This is needed because ApolloClient will throw an error automatically if it's\n     *  missing -- effectively making all of rest-link's selections implicitly non-optional.\n     *\n     * If you want to implement required fields, you need to use typePatcher to *delete*\n     *  fields when they're null and you want the query to fail instead.\n     *\n     * @param current Current object we're patching\n     * @param mainDefinition Parsed Query Definition\n     * @param fragmentMap Map of Named Fragments\n     * @param currentSelectionSet Current selection set we're filtering by\n     */\n    function insertNullsForAnyOmittedFields(current, // currentSelectionSet starts at root, so wait until we're inside a Field tagged with an @rest directive to activate!\n    mainDefinition, fragmentMap, currentSelectionSet) {\n        if (null == current ||\n            typeof current === 'number' ||\n            typeof current === 'boolean' ||\n            typeof current === 'string') {\n            return;\n        }\n        if (Array.isArray(current)) {\n            // If our current value is an array, process our selection set for each entry.\n            current.forEach(function (c) {\n                return insertNullsForAnyOmittedFields(c, mainDefinition, fragmentMap, currentSelectionSet);\n            });\n            return;\n        }\n        currentSelectionSet.selections.forEach(function (node) {\n            if (utilities.isInlineFragment(node)) {\n                insertNullsForAnyOmittedFields(current, mainDefinition, fragmentMap, node.selectionSet);\n            }\n            else if (node.kind === 'FragmentSpread') {\n                var fragment = fragmentMap[node.name.value];\n                insertNullsForAnyOmittedFields(current, mainDefinition, fragmentMap, fragment.selectionSet);\n            }\n            else if (utilities.isField(node)) {\n                var value = current[node.name.value];\n                if (node.name.value === '__typename') ;\n                else if (typeof value === 'undefined') {\n                    // Patch in a null where the field would have been marked as missing\n                    current[node.name.value] = null;\n                }\n                else if (value != null &&\n                    typeof value === 'object' &&\n                    node.selectionSet != null) {\n                    insertNullsForAnyOmittedFields(value, mainDefinition, fragmentMap, node.selectionSet);\n                }\n            }\n            else {\n                // This will give a TypeScript build-time error if you did something wrong or the AST changes!\n                return (function (node) {\n                    throw new Error('Unhandled Node Type in SelectionSetNode.selections');\n                })(node);\n            }\n        });\n    }\n    var getEndpointOptions = function (endpoints, endpoint) {\n        var result = endpoints[endpoint || DEFAULT_ENDPOINT_KEY] ||\n            endpoints[DEFAULT_ENDPOINT_KEY];\n        if (typeof result === 'string') {\n            return { uri: result };\n        }\n        return __assign({ responseTransformer: null }, result);\n    };\n    /** Replaces params in the path, keyed by colons */\n    var replaceLegacyParam = function (endpoint, name, value) {\n        if (value === undefined || name === undefined) {\n            return endpoint;\n        }\n        return endpoint.replace(\":\" + name, value);\n    };\n    /** Internal Tool that Parses Paths for RestLink -- This API should be considered experimental */\n    var PathBuilder = /** @class */ (function () {\n        function PathBuilder() {\n        }\n        PathBuilder.replacerForPath = function (path) {\n            if (path in PathBuilder.cache) {\n                return PathBuilder.cache[path];\n            }\n            var queryOrigStartIndex = path.indexOf('?');\n            var pathBits = path.split(PathBuilder.argReplacement);\n            var chunkActions = [];\n            var hasBegunQuery = false;\n            pathBits.reduce(function (processedCount, bit) {\n                if (bit === '' || bit === '{}') {\n                    // Empty chunk, do nothing\n                    return processedCount + bit.length;\n                }\n                var nextIndex = processedCount + bit.length;\n                if (bit[0] === '{' && bit[bit.length - 1] === '}') {\n                    // Replace some args!\n                    var _keyPath_1 = bit.slice(1, bit.length - 1).split('.');\n                    chunkActions.push(function (props, useQSEncoder) {\n                        try {\n                            var value = PathBuilderLookupValue(props, _keyPath_1);\n                            if (!useQSEncoder ||\n                                (typeof value !== 'object' || value == null)) {\n                                return String(value);\n                            }\n                            else {\n                                return qs.stringify(value);\n                            }\n                        }\n                        catch (e) {\n                            var key = [path, _keyPath_1.join('.')].join('|');\n                            if (!(key in PathBuilder.warnTable)) {\n                                console.warn('Warning: RestLink caught an error while unpacking', key, \"This tends to happen if you forgot to pass a parameter needed for creating an @rest(path, or if RestLink was configured to deeply unpack a path parameter that wasn't provided. This message will only log once per detected instance. Trouble-shooting hint: check @rest(path: and the variables provided to this query.\");\n                                PathBuilder.warnTable[key] = true;\n                            }\n                            return '';\n                        }\n                    });\n                }\n                else {\n                    chunkActions.push(bit);\n                    if (!hasBegunQuery && nextIndex >= queryOrigStartIndex) {\n                        hasBegunQuery = true;\n                        chunkActions.push(true);\n                    }\n                }\n                return nextIndex;\n            }, 0);\n            var result = function (props) {\n                var hasEnteredQuery = false;\n                var tmp = chunkActions.reduce(function (accumulator, action) {\n                    if (typeof action === 'string') {\n                        return accumulator + action;\n                    }\n                    else if (typeof action === 'boolean') {\n                        hasEnteredQuery = true;\n                        return accumulator;\n                    }\n                    else {\n                        return accumulator + action(props, hasEnteredQuery);\n                    }\n                }, '');\n                return tmp;\n            };\n            return (PathBuilder.cache[path] = result);\n        };\n        /** For accelerating the replacement of paths that are used a lot */\n        PathBuilder.cache = {};\n        /** Table to limit the amount of nagging (due to probable API Misuse) we do to once per path per launch */\n        PathBuilder.warnTable = {};\n        /** Regexp that finds things that are eligible for variable replacement */\n        PathBuilder.argReplacement = /({[._a-zA-Z0-9]*})/;\n        return PathBuilder;\n    }());\n    /** Private Helper Function */\n    function PathBuilderLookupValue(tmp, keyPath) {\n        if (keyPath.length === 0) {\n            return tmp;\n        }\n        var remainingKeyPath = __spreadArrays(keyPath); // Copy before mutating\n        var key = remainingKeyPath.shift();\n        return PathBuilderLookupValue(tmp[key], remainingKeyPath);\n    }\n    /**\n     * Some keys should be passed through transparently without normalizing/de-normalizing\n     */\n    var noMangleKeys = ['__typename'];\n    /** Recursively descends the provided object tree and converts all the keys */\n    var convertObjectKeys = function (object, __converter, keypath) {\n        if (keypath === void 0) { keypath = []; }\n        var converter = null;\n        if (__converter.length != 2) {\n            converter = function (name, keypath) {\n                return __converter(name);\n            };\n        }\n        else {\n            converter = __converter;\n        }\n        if (object == null || typeof object !== 'object') {\n            // Object is a scalar or null / undefined => no keys to convert!\n            return object;\n        }\n        // FileList/File are only available in some browser contexts\n        // Notably: *not available* in react-native.\n        if ((global.FileList && object instanceof FileList) ||\n            (global.File && object instanceof File)) {\n            // Object is a FileList or File object => no keys to convert!\n            return object;\n        }\n        if (Array.isArray(object)) {\n            return object.map(function (o, index) {\n                return convertObjectKeys(o, converter, __spreadArrays(keypath, [String(index)]));\n            });\n        }\n        return Object.keys(object).reduce(function (acc, key) {\n            var value = object[key];\n            if (noMangleKeys.indexOf(key) !== -1) {\n                acc[key] = value;\n                return acc;\n            }\n            var nestedKeyPath = __spreadArrays(keypath, [key]);\n            acc[converter(key, nestedKeyPath)] = convertObjectKeys(value, converter, nestedKeyPath);\n            return acc;\n        }, {});\n    };\n    var noOpNameNormalizer = function (name) {\n        return name;\n    };\n    /**\n     * Helper that makes sure our headers are of the right type to pass to Fetch\n     */\n    var normalizeHeaders = function (headers) {\n        // Make sure that our headers object is of the right type\n        if (headers instanceof Headers) {\n            return headers;\n        }\n        else {\n            return new Headers(headers || {});\n        }\n    };\n    /**\n     * Returns a new Headers Group that contains all the headers.\n     * - If there are duplicates, they will be in the returned header set multiple times!\n     */\n    var concatHeadersMergePolicy = function () {\n        var headerGroups = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            headerGroups[_i] = arguments[_i];\n        }\n        return headerGroups.reduce(function (accumulator, current) {\n            if (!current) {\n                return accumulator;\n            }\n            if (!current.forEach) {\n                current = normalizeHeaders(current);\n            }\n            current.forEach(function (value, key) {\n                accumulator.append(key, value);\n            });\n            return accumulator;\n        }, new Headers());\n    };\n    /**\n     * This merge policy deletes any matching headers from the link's default headers.\n     * - Pass headersToOverride array & a headers arg to context and this policy will automatically be selected.\n     */\n    var overrideHeadersMergePolicy = function (linkHeaders, headersToOverride, requestHeaders) {\n        var result = new Headers();\n        linkHeaders.forEach(function (value, key) {\n            if (headersToOverride.indexOf(key) !== -1) {\n                return;\n            }\n            result.append(key, value);\n        });\n        return concatHeadersMergePolicy(result, requestHeaders || new Headers());\n    };\n    var makeOverrideHeadersMergePolicy = function (headersToOverride) {\n        return function (linkHeaders, requestHeaders) {\n            return overrideHeadersMergePolicy(linkHeaders, headersToOverride, requestHeaders);\n        };\n    };\n    var SUPPORTED_HTTP_VERBS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];\n    var validateRequestMethodForOperationType = function (method, operationType) {\n        switch (operationType) {\n            case 'query':\n                if (SUPPORTED_HTTP_VERBS.indexOf(method.toUpperCase()) !== -1) {\n                    return;\n                }\n                throw new Error(\"A \\\"query\\\" operation can only support \\\"GET\\\" requests but got \\\"\" + method + \"\\\".\");\n            case 'mutation':\n                if (SUPPORTED_HTTP_VERBS.indexOf(method.toUpperCase()) !== -1) {\n                    return;\n                }\n                throw new Error('\"mutation\" operations do not support that HTTP-verb');\n            case 'subscription':\n                throw new Error('A \"subscription\" operation is not supported yet.');\n            default:\n                var _exhaustiveCheck = operationType;\n                return _exhaustiveCheck;\n        }\n    };\n    /**\n     * Utility to build & throw a JS Error from a \"failed\" REST-response\n     * @param response: HTTP Response object for this request\n     * @param result: Promise that will render the body of the response\n     * @param message: Human-facing error message\n     */\n    var rethrowServerSideError = function (response, result, message) {\n        var error = new Error(message);\n        error.response = response;\n        error.statusCode = response.status;\n        error.result = result;\n        throw error;\n    };\n    var addTypeToNode = function (node, typename) {\n        if (node === null || node === undefined || typeof node !== 'object') {\n            return node;\n        }\n        if (!Array.isArray(node)) {\n            node['__typename'] = typename;\n            return node;\n        }\n        return node.map(function (item) {\n            return addTypeToNode(item, typename);\n        });\n    };\n    var resolver = function (fieldName, root, args, context, info) { return __awaiter(void 0, void 0, void 0, function () {\n        var directives, isLeaf, resultKey, exportVariablesByNode, exportVariables, copyExportVariables, aliasedNode, preAliasingNode, isATypeCall, isNotARestCall, credentials, endpoints, headers, customFetch, operationType, typePatcher, mainDefinition, fragmentDefinitions, fieldNameNormalizer, linkLevelNameDenormalizer, serializers, responseTransformer, fragmentMap, _a, path, endpoint, pathBuilder, endpointOption, neitherPathsProvided, allParams, pathWithParams, _b, method, type, bodyBuilder, bodyKey, perRequestNameDenormalizer, bodySerializer, body, overrideHeaders, maybeBody_1, serializedBody, requestParams, requestUrl, response, result, parsed, error_1, transformer, err_1;\n        return __generator(this, function (_c) {\n            switch (_c.label) {\n                case 0:\n                    directives = info.directives, isLeaf = info.isLeaf, resultKey = info.resultKey;\n                    exportVariablesByNode = context.exportVariablesByNode;\n                    exportVariables = exportVariablesByNode.get(root) || {};\n                    copyExportVariables = function (result) {\n                        if (result instanceof Array) {\n                            result.forEach(copyExportVariables);\n                        }\n                        else {\n                            // export variables are stored keyed on the node they are for\n                            exportVariablesByNode.set(result, __assign({}, exportVariables));\n                        }\n                        return result;\n                    };\n                    aliasedNode = (root || {})[resultKey];\n                    preAliasingNode = (root || {})[fieldName];\n                    if (root && directives && directives.export) {\n                        // @export(as:) is only supported with apollo-link-rest at this time\n                        // so use the preAliasingNode as we're responsible for implementing aliasing!\n                        exportVariables[directives.export.as] = preAliasingNode;\n                    }\n                    isATypeCall = directives && directives.type;\n                    if (!isLeaf && isATypeCall) {\n                        // @type(name: ) is only supported inside apollo-link-rest at this time\n                        // so use the preAliasingNode as we're responsible for implementing aliasing!\n                        // Also: exit early, since @type(name: ) && @rest() can't both exist on the same node.\n                        if (directives.rest) {\n                            throw new Error('Invalid use of @type(name: ...) directive on a call that also has @rest(...)');\n                        }\n                        copyExportVariables(preAliasingNode);\n                        return [2 /*return*/, addTypeToNode(preAliasingNode, directives.type.name)];\n                    }\n                    isNotARestCall = !directives || !directives.rest;\n                    if (isNotARestCall) {\n                        // This is not tagged with @rest()\n                        // This might not belong to us so return the aliasNode version preferentially\n                        return [2 /*return*/, copyExportVariables(aliasedNode || preAliasingNode)];\n                    }\n                    credentials = context.credentials, endpoints = context.endpoints, headers = context.headers, customFetch = context.customFetch, operationType = context.operationType, typePatcher = context.typePatcher, mainDefinition = context.mainDefinition, fragmentDefinitions = context.fragmentDefinitions, fieldNameNormalizer = context.fieldNameNormalizer, linkLevelNameDenormalizer = context.fieldNameDenormalizer, serializers = context.serializers, responseTransformer = context.responseTransformer;\n                    fragmentMap = utilities.createFragmentMap(fragmentDefinitions);\n                    _a = directives.rest, path = _a.path, endpoint = _a.endpoint, pathBuilder = _a.pathBuilder;\n                    endpointOption = getEndpointOptions(endpoints, endpoint);\n                    neitherPathsProvided = path == null && pathBuilder == null;\n                    if (neitherPathsProvided) {\n                        throw new Error(\"One of (\\\"path\\\" | \\\"pathBuilder\\\") must be set in the @rest() directive. This request had neither, please add one\");\n                    }\n                    if (!pathBuilder) {\n                        if (!path.includes(':')) {\n                            // Colons are the legacy route, and aren't uri encoded anyhow.\n                            pathBuilder = PathBuilder.replacerForPath(path);\n                        }\n                        else {\n                            console.warn(\"Deprecated: '@rest(path:' contains a ':' colon, this format will be removed in future versions\");\n                            pathBuilder = function (_a) {\n                                var args = _a.args, exportVariables = _a.exportVariables;\n                                var legacyArgs = __assign(__assign({}, args), exportVariables);\n                                var pathWithParams = Object.keys(legacyArgs).reduce(function (acc, e) { return replaceLegacyParam(acc, e, legacyArgs[e]); }, path);\n                                if (pathWithParams.includes(':')) {\n                                    throw new Error('Missing parameters to run query, specify it in the query params or use ' +\n                                        'an export directive. (If you need to use \":\" inside a variable string' +\n                                        ' make sure to encode the variables properly using `encodeURIComponent' +\n                                        '`. Alternatively see documentation about using pathBuilder.)');\n                                }\n                                return pathWithParams;\n                            };\n                        }\n                    }\n                    allParams = {\n                        args: args,\n                        exportVariables: exportVariables,\n                        context: context,\n                        '@rest': directives.rest,\n                        replacer: pathBuilder,\n                    };\n                    pathWithParams = pathBuilder(allParams);\n                    _b = directives.rest, method = _b.method, type = _b.type, bodyBuilder = _b.bodyBuilder, bodyKey = _b.bodyKey, perRequestNameDenormalizer = _b.fieldNameDenormalizer, bodySerializer = _b.bodySerializer;\n                    if (!method) {\n                        method = 'GET';\n                    }\n                    if (!bodyKey) {\n                        bodyKey = 'input';\n                    }\n                    body = undefined;\n                    overrideHeaders = undefined;\n                    if (-1 === ['GET', 'DELETE'].indexOf(method)) {\n                        // Prepare our body!\n                        if (!bodyBuilder) {\n                            maybeBody_1 = allParams.exportVariables[bodyKey] ||\n                                (allParams.args && allParams.args[bodyKey]);\n                            if (!maybeBody_1) {\n                                throw new Error(\"[GraphQL \" + method + \" \" + operationType + \" using a REST call without a body]. No `\" + bodyKey + \"` was detected. Pass bodyKey, or bodyBuilder to the @rest() directive to resolve this.\");\n                            }\n                            bodyBuilder = function (argsWithExport) {\n                                return maybeBody_1;\n                            };\n                        }\n                        body = convertObjectKeys(bodyBuilder(allParams), perRequestNameDenormalizer ||\n                            linkLevelNameDenormalizer ||\n                            noOpNameNormalizer);\n                        serializedBody = void 0;\n                        if (typeof bodySerializer === 'string') {\n                            if (!serializers.hasOwnProperty(bodySerializer)) {\n                                throw new Error('\"bodySerializer\" must correspond to configured serializer. ' +\n                                    (\"Please make sure to specify a serializer called \" + bodySerializer + \" in the \\\"bodySerializers\\\" property of the RestLink.\"));\n                            }\n                            serializedBody = serializers[bodySerializer](body, headers);\n                        }\n                        else {\n                            serializedBody = bodySerializer\n                                ? bodySerializer(body, headers)\n                                : serializers[DEFAULT_SERIALIZER_KEY](body, headers);\n                        }\n                        body = serializedBody.body;\n                        overrideHeaders = new Headers(serializedBody.headers);\n                    }\n                    validateRequestMethodForOperationType(method, operationType || 'query');\n                    requestParams = __assign({ method: method, headers: overrideHeaders || headers, body: body }, (credentials ? { credentials: credentials } : {}));\n                    requestUrl = \"\" + endpointOption.uri + pathWithParams;\n                    return [4 /*yield*/, (customFetch || fetch)(requestUrl, requestParams)];\n                case 1:\n                    response = _c.sent();\n                    context.responses.push(response);\n                    if (!response.ok) return [3 /*break*/, 2];\n                    if (response.status === 204 ||\n                        response.headers.get('Content-Length') === '0') {\n                        // HTTP-204 means \"no-content\", similarly Content-Length implies the same\n                        // This commonly occurs when you POST/PUT to the server, and it acknowledges\n                        // success, but doesn't return your Resource.\n                        result = {};\n                    }\n                    else {\n                        result = response;\n                    }\n                    return [3 /*break*/, 9];\n                case 2:\n                    if (!(response.status === 404)) return [3 /*break*/, 3];\n                    // In a GraphQL context a missing resource should be indicated by\n                    // a null value rather than throwing a network error\n                    result = null;\n                    return [3 /*break*/, 9];\n                case 3:\n                    parsed = void 0;\n                    _c.label = 4;\n                case 4:\n                    _c.trys.push([4, 6, , 8]);\n                    return [4 /*yield*/, response.clone().json()];\n                case 5:\n                    parsed = _c.sent();\n                    return [3 /*break*/, 8];\n                case 6:\n                    error_1 = _c.sent();\n                    return [4 /*yield*/, response.clone().text()];\n                case 7:\n                    // its not json\n                    parsed = _c.sent();\n                    return [3 /*break*/, 8];\n                case 8:\n                    rethrowServerSideError(response, parsed, \"Response not successful: Received status code \" + response.status);\n                    _c.label = 9;\n                case 9:\n                    transformer = endpointOption.responseTransformer || responseTransformer;\n                    if (!transformer) return [3 /*break*/, 14];\n                    _c.label = 10;\n                case 10:\n                    _c.trys.push([10, 12, , 13]);\n                    return [4 /*yield*/, transformer(result, type)];\n                case 11:\n                    result = _c.sent();\n                    return [3 /*break*/, 13];\n                case 12:\n                    err_1 = _c.sent();\n                    console.warn('An error occurred in a responseTransformer:');\n                    throw err_1;\n                case 13: return [3 /*break*/, 16];\n                case 14:\n                    if (!(result && result.json)) return [3 /*break*/, 16];\n                    return [4 /*yield*/, result.json()];\n                case 15:\n                    result = _c.sent();\n                    _c.label = 16;\n                case 16:\n                    if (fieldNameNormalizer !== null) {\n                        result = convertObjectKeys(result, fieldNameNormalizer);\n                    }\n                    result = findRestDirectivesThenInsertNullsForOmittedFields(resultKey, result, mainDefinition, fragmentMap, mainDefinition.selectionSet);\n                    result = addTypeNameToResult(result, type, typePatcher);\n                    return [2 /*return*/, copyExportVariables(result)];\n            }\n        });\n    }); };\n    /**\n     * Default key to use when the @rest directive omits the \"endpoint\" parameter.\n     */\n    var DEFAULT_ENDPOINT_KEY = '';\n    /**\n     * Default key to use when the @rest directive omits the \"bodySerializers\" parameter.\n     */\n    var DEFAULT_SERIALIZER_KEY = '';\n    var DEFAULT_JSON_SERIALIZER = function (data, headers) {\n        if (!headers.has('content-type')) {\n            headers.append('Content-Type', 'application/json');\n        }\n        return {\n            body: JSON.stringify(data),\n            headers: headers,\n        };\n    };\n    var CONNECTION_REMOVE_CONFIG = {\n        test: function (directive) { return directive.name.value === 'rest'; },\n        remove: true,\n    };\n    /**\n     * RestLink is an apollo-link for communicating with REST services using GraphQL on the client-side\n     */\n    var RestLink = /** @class */ (function (_super) {\n        __extends(RestLink, _super);\n        function RestLink(_a) {\n            var _b;\n            var uri = _a.uri, endpoints = _a.endpoints, headers = _a.headers, fieldNameNormalizer = _a.fieldNameNormalizer, fieldNameDenormalizer = _a.fieldNameDenormalizer, typePatcher = _a.typePatcher, customFetch = _a.customFetch, credentials = _a.credentials, bodySerializers = _a.bodySerializers, defaultSerializer = _a.defaultSerializer, responseTransformer = _a.responseTransformer;\n            var _this = _super.call(this) || this;\n            var fallback = {};\n            fallback[DEFAULT_ENDPOINT_KEY] = uri || '';\n            _this.endpoints = Object.assign({}, endpoints || fallback);\n            if (uri == null && endpoints == null) {\n                throw new Error('A RestLink must be initialized with either 1 uri, or a map of keyed-endpoints');\n            }\n            if (uri != null) {\n                var currentDefaultURI = (endpoints || {})[DEFAULT_ENDPOINT_KEY];\n                if (currentDefaultURI != null && currentDefaultURI != uri) {\n                    throw new Error(\"RestLink was configured with a default uri that doesn't match what's passed in to the endpoints map.\");\n                }\n                _this.endpoints[DEFAULT_ENDPOINT_KEY] = uri;\n            }\n            if (_this.endpoints[DEFAULT_ENDPOINT_KEY] == null) {\n                console.warn('RestLink configured without a default URI. All @rest(…) directives must provide an endpoint key!');\n            }\n            if (typePatcher == null) {\n                _this.typePatcher = function (result, __typename, _2) {\n                    return __assign({ __typename: __typename }, result);\n                };\n            }\n            else if (!Array.isArray(typePatcher) &&\n                typeof typePatcher === 'object' &&\n                Object.keys(typePatcher)\n                    .map(function (key) { return typePatcher[key]; })\n                    .reduce(\n                // Make sure all of the values are patcher-functions\n                function (current, patcher) { return current && typeof patcher === 'function'; }, true)) {\n                var table_1 = typePatcher;\n                _this.typePatcher = function (data, outerType, patchDeeper) {\n                    var __typename = data.__typename || outerType;\n                    if (Array.isArray(data)) {\n                        return data.map(function (d) { return patchDeeper(d, __typename, patchDeeper); });\n                    }\n                    var subPatcher = table_1[__typename] || (function (result) { return result; });\n                    return __assign({ __typename: __typename }, subPatcher(data, __typename, patchDeeper));\n                };\n            }\n            else {\n                throw new Error('RestLink was configured with a typePatcher of invalid type!');\n            }\n            if (bodySerializers &&\n                bodySerializers.hasOwnProperty(DEFAULT_SERIALIZER_KEY)) {\n                console.warn('RestLink was configured to override the default serializer! This may result in unexpected behavior');\n            }\n            _this.responseTransformer = responseTransformer || null;\n            _this.fieldNameNormalizer = fieldNameNormalizer || null;\n            _this.fieldNameDenormalizer = fieldNameDenormalizer || null;\n            _this.headers = normalizeHeaders(headers);\n            _this.credentials = credentials || null;\n            _this.customFetch = customFetch;\n            _this.serializers = __assign((_b = {}, _b[DEFAULT_SERIALIZER_KEY] = defaultSerializer || DEFAULT_JSON_SERIALIZER, _b), (bodySerializers || {}));\n            _this.processedDocuments = new Map();\n            return _this;\n        }\n        RestLink.prototype.removeRestSetsFromDocument = function (query) {\n            var cached = this.processedDocuments.get(query);\n            if (cached)\n                return cached;\n            utilities.checkDocument(query);\n            var docClone = utilities.removeDirectivesFromDocument([CONNECTION_REMOVE_CONFIG], query);\n            this.processedDocuments.set(query, docClone);\n            return docClone;\n        };\n        RestLink.prototype.request = function (operation, forward) {\n            var query = operation.query, variables = operation.variables, getContext = operation.getContext, setContext = operation.setContext;\n            var context = getContext();\n            var isRestQuery = utilities.hasDirectives(['rest'], query);\n            if (!isRestQuery) {\n                return forward(operation);\n            }\n            var nonRest = this.removeRestSetsFromDocument(query);\n            // 1. Use the user's merge policy if any\n            var headersMergePolicy = context.headersMergePolicy;\n            if (headersMergePolicy == null &&\n                Array.isArray(context.headersToOverride)) {\n                // 2.a. Override just the passed in headers, if user provided that optional array\n                headersMergePolicy = makeOverrideHeadersMergePolicy(context.headersToOverride);\n            }\n            else if (headersMergePolicy == null) {\n                // 2.b Glue the link (default) headers to the request-context headers\n                headersMergePolicy = concatHeadersMergePolicy;\n            }\n            var headers = headersMergePolicy(this.headers, context.headers);\n            if (!headers.has('Accept')) {\n                // Since we assume a json body on successful responses set the Accept\n                // header accordingly if it is not provided by the user\n                headers.append('Accept', 'application/json');\n            }\n            var credentials = context.credentials || this.credentials;\n            var queryWithTypename = utilities.addTypenameToDocument(query);\n            var mainDefinition = utilities.getMainDefinition(query);\n            var fragmentDefinitions = utilities.getFragmentDefinitions(query);\n            var operationType = (mainDefinition || {}).operation || 'query';\n            var requestContext = {\n                headers: headers,\n                endpoints: this.endpoints,\n                // Provide an empty map for this request's exports to be stuffed into\n                exportVariablesByNode: new Map(),\n                credentials: credentials,\n                customFetch: this.customFetch,\n                operationType: operationType,\n                fieldNameNormalizer: this.fieldNameNormalizer,\n                fieldNameDenormalizer: this.fieldNameDenormalizer,\n                mainDefinition: mainDefinition,\n                fragmentDefinitions: fragmentDefinitions,\n                typePatcher: this.typePatcher,\n                serializers: this.serializers,\n                responses: [],\n                responseTransformer: this.responseTransformer,\n            };\n            var resolverOptions = {};\n            var obs;\n            if (nonRest && forward) {\n                operation.query = nonRest;\n                obs = forward(operation);\n            }\n            else\n                obs = core.Observable.of({ data: {} });\n            return obs.flatMap(function (_a) {\n                var data = _a.data, errors = _a.errors;\n                return new core.Observable(function (observer) {\n                    async.graphql(resolver, queryWithTypename, data, requestContext, variables, resolverOptions)\n                        .then(function (data) {\n                        setContext({\n                            restResponses: (context.restResponses || []).concat(requestContext.responses),\n                        });\n                        observer.next({ data: data, errors: errors });\n                        observer.complete();\n                    })\n                        .catch(function (err) {\n                        if (err.name === 'AbortError')\n                            return;\n                        if (err.result && err.result.errors) {\n                            observer.next(err.result);\n                        }\n                        observer.error(err);\n                    });\n                });\n            });\n        };\n        return RestLink;\n    }(core.ApolloLink));\n\n    exports.RestLink = RestLink;\n    exports.PathBuilder = PathBuilder;\n\n    Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=bundle.umd.js.map\n"],"sourceRoot":""}