{"version":3,"sources":["webpack:///./node_modules/apollo-upload-client/public/createUploadLink.js","webpack:///./node_modules/apollo-upload-client/public/isExtractableFile.js","webpack:///./node_modules/apollo-utilities/node_modules/@wry/equality/lib/equality.esm.js","webpack:///./node_modules/apollo-link/node_modules/ts-invariant/lib/invariant.esm.js","webpack:///./node_modules/apollo-client/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/apollo-client/node_modules/ts-invariant/lib/invariant.esm.js","webpack:///./node_modules/apollo-utilities/lib/bundle.esm.js","webpack:///./node_modules/apollo-link/node_modules/zen-observable-ts/lib/bundle.esm.js","webpack:///./node_modules/apollo-link/lib/bundle.esm.js","webpack:///./node_modules/apollo-client/bundle.esm.js","webpack:///./node_modules/apollo-upload-client/public/formDataAppendFile.js","webpack:///./node_modules/apollo-link/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/apollo-client/node_modules/symbol-observable/es/index.js","webpack:///./node_modules/apollo-utilities/node_modules/ts-invariant/lib/invariant.esm.js","webpack:///./node_modules/apollo-utilities/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/apollo-client/node_modules/symbol-observable/es/ponyfill.js"],"names":["ApolloLink","Observable","createSignalIfSupported","fallbackHttpConfig","parseAndCheckHttpResponse","rewriteURIForGET","selectHttpOptionsAndBody","selectURI","serializeFetchParameter","extractFiles","formDataAppendFile","isExtractableFile","module","exports","uri","fetchUri","useGETForQueries","customIsExtractableFile","FormData","CustomFormData","customFormDataAppendFile","fetch","customFetch","fetchOptions","credentials","headers","includeExtensions","linkConfig","http","options","operation","context","getContext","clientAwareness","name","version","contextConfig","body","clone","files","size","RuntimeFormData","form","append","map","i","forEach","paths","JSON","stringify","file","query","definitions","some","definition","kind","method","newURI","parseError","observer","error","controller","signal","aborted","abort","addEventListener","once","runtimeFetch","cleaningUp","then","response","setContext","result","next","complete","catch","errors","data","_a","Object","prototype","toString","hasOwnProperty","previousComparisons","Map","equal","a","b","check","clear","aTag","call","bTag","length","previouslyCompared","aKeys","keys","bKeys","keyCount","k","key","message","aIterator","entries","isMap","info","done","value","aKey","aValue","has","get","bSet","set","Set","add","genericMessage","setPrototypeOf","obj","proto","__proto__","InvariantError","_super","_this","this","framesToPop","Error","invariant","condition","wrapConsoleMethod","console","apply","arguments","warn","processStub","env","process","Function","atLeastWeTried","extendStatics","d","Array","p","__extends","__","constructor","create","__assign","assign","t","s","n","__awaiter","thisArg","_arguments","P","generator","adopt","resolve","Promise","reject","fulfilled","step","e","rejected","__generator","f","y","g","_","label","sent","trys","ops","verb","Symbol","iterator","v","op","TypeError","pop","push","isStringValue","isBooleanValue","isIntValue","isFloatValue","isVariable","isObjectValue","isListValue","isEnumValue","isNullValue","valueToObjectRepresentation","argObj","variables","Number","nestedArgObj_1","fields","variableValue","values","listValue","nestedArgArrayObj","storeKeyNameFromField","field","directivesObj","directives","directive","getStoreKeyName","KNOWN_DIRECTIVES","fieldName","args","filterKeys","sort","queryArgs_1","filteredArgs_1","completeFieldName","stringifiedArgs","indexOf","argumentsObjectFromField","argObj_1","resultKeyNameFromField","alias","isField","selection","isInlineFragment","isIdValue","idObject","type","generated","toIdValue","idConfig","id","typename","undefined","isJsonValue","jsonObject","getDirectiveInfoFromField","directiveObj_1","shouldInclude","getInclusionDirectives","every","ifArgument","evaledValue","getDirectiveNames","doc","names","Directive","node","hasDirectives","hasClientExports","document","isInclusionDirective","filter","directiveArguments","ifValue","getFragmentQueryDocument","fragmentName","actualFragmentName","fragments","selectionSet","selections","target","sources","_i","source","checkDocument","operations","getOperationDefinition","getOperationName","x","getFragmentDefinitions","getQueryDefinition","queryDef","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","createFragmentMap","symTable","fragment","getDefaultValues","variableDefinitions","defaultValues","defaultValue","variable","defaultValueObj","filterInPlace","array","test","elem","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","enter","_key","parent","Field","shouldRemoveField","remove","arg","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","removeArgumentsFromDocument","fs","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","skip","lastIndexOf","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","getArgumentMatcher","config","argument","aConfig","argMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","def","FragmentDefinition","allFragments","buildQueryFromSelectionSet","definitionOperation","removeClientSetsFromDocument","isTypenameOnly","canUseWeakMap","WeakMap","navigator","product","cloneDeep","cloneDeepHelper","val","seen","copy_1","slice","child","copy_2","getPrototypeOf","getEnv","isEnv","isProduction","isDevelopment","isTest","tryFunctionOrLogError","graphQLResultHasError","deepFreeze","o","freeze","getOwnPropertyNames","prop","isFrozen","maybeDeepFreeze","symbolIsPolyfilled","mergeDeep","mergeDeepArray","count","pastCopies","shallowCopyForMerge","mergeHelper","isObject","isExtensible","sourceKey","sourceValue","targetValue","isArray","validateOperation","OPERATION_FIELDS","LinkError","link","isTerminating","request","transformOperation","transformedOperation","extensions","operationName","createOperation","starting","defineProperty","enumerable","getKey","passthrough","forward","of","toLink","handler","empty","from","links","reduce","concat","split","left","right","leftLink","rightLink","first","second","firstLink","nextLink","execute","NetworkStatus","isNetworkRequestInFlight","networkStatus","isNonEmptyArray","isApolloError","err","FetchType","generateErrorMessage","graphQLErrors","graphQLError","errorMessage","networkError","replace","ApolloError","extraInfo","hasError","storeValue","policy","ObservableQuery","queryManager","_b","shouldSubscribe","onSubscribe","observers","subscriptions","isTornDown","queryId","generateQueryId","opDef","queryName","delete","removeQuery","setTimeout","subscription","unsubscribe","subscribe","currentResult","getCurrentResult","lastResult","lastError","loading","getCurrentQueryResult","partial","queryStoreValue","queryStore","fetchPolicy","isNetworkFetchPolicy","errorPolicy","ready","updateLastResult","stale","isDifferentFromLastResult","newResult","snapshot","lastResultSnapshot","getLastResult","getLastError","resetLastResults","resetQueryStoreErrors","refetch","fetchQuery","fetchMore","fetchMoreOptions","updateQuery","combinedOptions","qid","normal","fetchMoreResult","previousResult","stopQuery","subscribeToMore","startGraphQLSubscription","subscriptionData","previous","onError","setOptions","opts","oldFetchPolicy","pollInterval","startPolling","stopPolling","setVariables","fetchResults","tryFetch","mapFn","getQueryWithPreviousResult","dataStore","markUpdateQueryResult","broadcastQueries","stopPollingQuery","assertNotCacheFirstOrOnly","startPollingQuery","assumeImmutableResults","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","setUpQuery","tearDownQuery","addObservableQuery","iterateObserversSafely","observeQuery","previousResult_1","query_1","fetchPolicy_1","transform","getLocalState","addExportedVariables","previousVariables","serverQuery","sub","removeObservableQuery","observersWithMethod","obs","obsQuery","MutationStore","store","getStore","mutationId","initMutation","mutation","markMutationError","markMutationResult","reset","QueryStore","initQuery","previousQuery","isSetVariables","storePreviousVariables","isPoll","poll","isRefetch","metadata","fetchMoreForQueryId","markQueryResult","markQueryError","markQueryResultClient","observableQueryIds","capitalizeFirstLetter","str","charAt","toUpperCase","LocalState","cache","client","resolvers","fragmentMatcher","addResolvers","setFragmentMatcher","resolverGroup","setResolvers","getResolvers","runResolvers","remoteResult","onlyRunForcedResolvers","_c","resolveDocument","localResult","getFragmentMatcher","clientQuery","prepareContext","newContext","getCacheKey","dataIdFromObject","buildRootValueFromCache","exportedVariables","shouldForceResolvers","forceResolvers","diff","returnPartialData","optimistic","rootValue","mainDefinition","fragmentMap","defaultOperationType","execContext","resolveSelectionSet","resultsToMerge","typeCondition","resolveField","fieldResult","fragmentResult","all","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","__typename","resolveSubSelectedArray","item","multiplex","inner","asyncMap","observable","activeNextCount","completed","QueryManager","queryDeduplication","onBroadcast","_d","ssrMode","_e","localState","mutationStore","idCounter","queries","fetchQueryRejectFns","transformCache","inFlightLinkObservables","pollingInfoByQueryId","getCache","stop","_info","stopQueryNoBroadcast","mutate","optimisticResponse","updateQueriesByName","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","update","generateUpdateQueriesInfo","self","_f","setQuery","getVariables","ret","observableQuery","updater","markMutationInit","storeResult","getObservableFromLink","markMutationComplete","refetchQueryPromises","refetchQuery","queryOptions","fetchType","isNetworkOnly","needToFetch","shouldFetch","requestId","cancel","networkResult","updateQueryWatch","lastRequestId","invalidated","invalidate","fetchRequest","getQuery","hasForcedResolvers","newData","queryListenerForObserver","invoke","networkStatusChanged","shouldNotifyIfLoading","notifyOnNetworkStatusChange","hasGraphQLErrors","isMissing","errorStatusChanged","diffResult","resultFromStore","transformed","transformDocument","forLink","transformForLink","cacheEntry_1","defaultVars","watchQuery","transformedOptions","watchedQuery","String","stopQueryInStore","stopQueryInStoreNoBroadcast","addQueryListener","listener","listeners","watch","callback","clearStore","resetIds","resetStore","reFetchObservableQueries","includeStandby","observableQueryPromises","startQuery","makeObservable","markSubscriptionResult","observablePromise_1","queryIdOrObservable","foundObserveableQuery","deduplication","inFlightLinkObservables_1","forceFetch","byVariables_1","varJson_1","cleanup","cleanupSub_1","errorsFromStore","fqrfId","result_1","prev","newInfo","checkInFlight","interval","maybeFetch_1","poll_1","clearTimeout","timeout","DataStore","initialCache","ignoreErrors","writeWithErrors","write","dataId","optimistic_1","recordOptimisticTransaction","c","orig","cacheWrites_1","updateQueries_1","currentQueryResult","nextQueryResult","mutationResult","queryVariables","performTransaction","removeOptimistic","ApolloClient","defaultOptions","resetStoreCallbacks","clearStoreCallbacks","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","disableNetworkFetches","bind","defaultConnectToDevTools","window","__APOLLO_CLIENT__","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","extract","readQuery","readFragment","writeQuery","writeFragment","writeData","__actionHookForDevTools","cb","__requestRaw","payload","initQueryManager","fn","onResetStore","onClearStore","restore","serializedState","setLocalStateFragmentMatcher","formData","root","global","__spreadArrays","il","r","j","jl","symbolObservablePonyfill"],"mappings":"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","file":"js/chunk-vendors~45876d5b.00d2dae8.js","sourcesContent":["\"use strict\";\n\nconst { ApolloLink, Observable } = require(\"@apollo/client/core\");\nconst {\n  createSignalIfSupported,\n  fallbackHttpConfig,\n  parseAndCheckHttpResponse,\n  rewriteURIForGET,\n  selectHttpOptionsAndBody,\n  selectURI,\n  serializeFetchParameter,\n} = require(\"@apollo/client/link/http\");\nconst extractFiles = require(\"extract-files/public/extractFiles.js\");\nconst formDataAppendFile = require(\"./formDataAppendFile.js\");\nconst isExtractableFile = require(\"./isExtractableFile.js\");\n\n/**\n * Creates a\n * [terminating Apollo Link](https://apollographql.com/docs/react/api/link/introduction/#the-terminating-link)\n * for [Apollo Client](https://apollographql.com/docs/react) that fetches a\n * [GraphQL multipart request](https://github.com/jaydenseric/graphql-multipart-request-spec)\n * if the GraphQL variables contain files (by default\n * [`FileList`](https://developer.mozilla.org/en-US/docs/Web/API/FileList),\n * [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File),\n * [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob), or\n * [`ReactNativeFile`](#class-reactnativefile) instances), or else fetches a\n * regular\n * [GraphQL POST or GET request](https://apollographql.com/docs/apollo-server/requests)\n * (depending on the config and GraphQL operation).\n *\n * Some of the options are similar to the\n * [`createHttpLink` options](https://apollographql.com/docs/react/api/link/apollo-link-http/#httplink-constructor-options).\n * @see [GraphQL multipart request spec](https://github.com/jaydenseric/graphql-multipart-request-spec).\n * @kind function\n * @name createUploadLink\n * @param {object} options Options.\n * @param {string} [options.uri=\"/graphql\"] GraphQL endpoint URI.\n * @param {boolean} [options.useGETForQueries] Should GET be used to fetch queries, if there are no files to upload.\n * @param {ExtractableFileMatcher} [options.isExtractableFile=isExtractableFile] Customizes how files are matched in the GraphQL operation for extraction.\n * @param {class} [options.FormData] [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) implementation to use, defaulting to the [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) global.\n * @param {FormDataFileAppender} [options.formDataAppendFile=formDataAppendFile] Customizes how extracted files are appended to the [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) instance.\n * @param {Function} [options.fetch] [`fetch`](https://fetch.spec.whatwg.org) implementation to use, defaulting to the [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch) global.\n * @param {FetchOptions} [options.fetchOptions] [`fetch` options]{@link FetchOptions}; overridden by upload requirements.\n * @param {string} [options.credentials] Overrides `options.fetchOptions.credentials`.\n * @param {object} [options.headers] Merges with and overrides `options.fetchOptions.headers`.\n * @param {boolean} [options.includeExtensions=false] Toggles sending `extensions` fields to the GraphQL server.\n * @returns {ApolloLink} A [terminating Apollo Link](https://apollographql.com/docs/react/api/link/introduction/#the-terminating-link).\n * @example <caption>Ways to `import`.</caption>\n * ```js\n * import { createUploadLink } from \"apollo-upload-client\";\n * ```\n *\n * ```js\n * import createUploadLink from \"apollo-upload-client/public/createUploadLink.js\";\n * ```\n * @example <caption>Ways to `require`.</caption>\n * ```js\n * const { createUploadLink } = require(\"apollo-upload-client\");\n * ```\n *\n * ```js\n * const createUploadLink = require(\"apollo-upload-client/public/createUploadLink.js\");\n * ```\n * @example <caption>A basic Apollo Client setup.</caption>\n * ```js\n * import { ApolloClient, InMemoryCache } from \"@apollo/client\";\n * import createUploadLink from \"apollo-upload-client/public/createUploadLink.js\";\n *\n * const client = new ApolloClient({\n *   cache: new InMemoryCache(),\n *   link: createUploadLink(),\n * });\n * ```\n */\nmodule.exports = function createUploadLink({\n  uri: fetchUri = \"/graphql\",\n  useGETForQueries,\n  isExtractableFile: customIsExtractableFile = isExtractableFile,\n  FormData: CustomFormData,\n  formDataAppendFile: customFormDataAppendFile = formDataAppendFile,\n  fetch: customFetch,\n  fetchOptions,\n  credentials,\n  headers,\n  includeExtensions,\n} = {}) {\n  const linkConfig = {\n    http: { includeExtensions },\n    options: fetchOptions,\n    credentials,\n    headers,\n  };\n\n  return new ApolloLink((operation) => {\n    const context = operation.getContext();\n    const {\n      // Apollo Studio client awareness `name` and `version` can be configured\n      // via `ApolloClient` constructor options:\n      // https://apollographql.com/docs/studio/client-awareness/#using-apollo-server-and-apollo-client\n      clientAwareness: { name, version } = {},\n      headers,\n    } = context;\n\n    const contextConfig = {\n      http: context.http,\n      options: context.fetchOptions,\n      credentials: context.credentials,\n      headers: {\n        // Client awareness headers can be overridden by context `headers`.\n        ...(name && { \"apollographql-client-name\": name }),\n        ...(version && { \"apollographql-client-version\": version }),\n        ...headers,\n      },\n    };\n\n    const { options, body } = selectHttpOptionsAndBody(\n      operation,\n      fallbackHttpConfig,\n      linkConfig,\n      contextConfig\n    );\n\n    const { clone, files } = extractFiles(body, \"\", customIsExtractableFile);\n\n    let uri = selectURI(operation, fetchUri);\n\n    if (files.size) {\n      // Automatically set by `fetch` when the `body` is a `FormData` instance.\n      delete options.headers[\"content-type\"];\n\n      // GraphQL multipart request spec:\n      // https://github.com/jaydenseric/graphql-multipart-request-spec\n\n      const RuntimeFormData = CustomFormData || FormData;\n\n      const form = new RuntimeFormData();\n\n      form.append(\"operations\", serializeFetchParameter(clone, \"Payload\"));\n\n      const map = {};\n      let i = 0;\n      files.forEach((paths) => {\n        map[++i] = paths;\n      });\n      form.append(\"map\", JSON.stringify(map));\n\n      i = 0;\n      files.forEach((paths, file) => {\n        customFormDataAppendFile(form, ++i, file);\n      });\n\n      options.body = form;\n    } else {\n      if (\n        useGETForQueries &&\n        // If the operation contains some mutations GET shouldn’t be used.\n        !operation.query.definitions.some(\n          (definition) =>\n            definition.kind === \"OperationDefinition\" &&\n            definition.operation === \"mutation\"\n        )\n      )\n        options.method = \"GET\";\n\n      if (options.method === \"GET\") {\n        const { newURI, parseError } = rewriteURIForGET(uri, body);\n        if (parseError)\n          // Apollo’s `HttpLink` uses `fromError` for this, but it’s not\n          // exported from `@apollo/client/link/http`.\n          return new Observable((observer) => {\n            observer.error(parseError);\n          });\n        uri = newURI;\n      } else options.body = serializeFetchParameter(clone, \"Payload\");\n    }\n\n    const { controller } = createSignalIfSupported();\n\n    if (controller) {\n      if (options.signal)\n        // Respect the user configured abort controller signal.\n        options.signal.aborted\n          ? // Signal already aborted, so immediately abort.\n            controller.abort()\n          : // Signal not already aborted, so setup a listener to abort when it\n            // does.\n            options.signal.addEventListener(\n              \"abort\",\n              () => {\n                controller.abort();\n              },\n              {\n                // Prevent a memory leak if the user configured abort controller\n                // is long lasting, or controls multiple things.\n                once: true,\n              }\n            );\n\n      options.signal = controller.signal;\n    }\n\n    const runtimeFetch = customFetch || fetch;\n\n    return new Observable((observer) => {\n      // Used to track if the observable is being cleaned up.\n      let cleaningUp;\n\n      runtimeFetch(uri, options)\n        .then((response) => {\n          // Forward the response on the context.\n          operation.setContext({ response });\n          return response;\n        })\n        .then(parseAndCheckHttpResponse(operation))\n        .then((result) => {\n          observer.next(result);\n          observer.complete();\n        })\n        .catch((error) => {\n          // If the observable is being cleaned up, there is no need to call\n          // next or error because there are no more subscribers. An error after\n          // cleanup begins is likely from the cleanup function aborting the\n          // fetch.\n          if (!cleaningUp) {\n            // For errors such as an invalid fetch URI there will be no GraphQL\n            // result with errors or data to forward.\n            if (error.result && error.result.errors && error.result.data)\n              observer.next(error.result);\n\n            observer.error(error);\n          }\n        });\n\n      // Cleanup function.\n      return () => {\n        cleaningUp = true;\n\n        // Abort fetch. It’s ok to signal an abort even when not fetching.\n        if (controller) controller.abort();\n      };\n    });\n  });\n};\n","\"use strict\";\n\n/**\n * The default implementation for [`createUploadLink`]{@link createUploadLink}\n * `options.isExtractableFile`.\n * @kind function\n * @name isExtractableFile\n * @type {ExtractableFileMatcher}\n * @param {*} value Value to check.\n * @returns {boolean} Is the value an extractable file.\n * @see [`extract-files` `isExtractableFile` docs](https://github.com/jaydenseric/extract-files#function-isextractablefile).\n * @example <caption>Ways to `import`.</caption>\n * ```js\n * import { isExtractableFile } from \"apollo-upload-client\";\n * ```\n *\n * ```js\n * import isExtractableFile from \"apollo-upload-client/public/isExtractableFile.js\";\n * ```\n * @example <caption>Ways to `require`.</caption>\n * ```js\n * const { isExtractableFile } = require(\"apollo-upload-client\");\n * ```\n *\n * ```js\n * const isExtractableFile = require(\"apollo-upload-client/public/isExtractableFile.js\");\n * ```\n */\nmodule.exports = require(\"extract-files/public/isExtractableFile.js\");\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 { __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","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","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","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","import zenObservable from 'zen-observable';\n\nvar Observable = zenObservable;\n\nexport default Observable;\nexport { Observable };\n//# sourceMappingURL=bundle.esm.js.map\n","import Observable from 'zen-observable-ts';\nexport { default as Observable } from 'zen-observable-ts';\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { __extends, __assign } from 'tslib';\nimport { getOperationName } from 'apollo-utilities';\nexport { getOperationName } from 'apollo-utilities';\n\nfunction validateOperation(operation) {\n    var OPERATION_FIELDS = [\n        'query',\n        'operationName',\n        'variables',\n        'extensions',\n        'context',\n    ];\n    for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (OPERATION_FIELDS.indexOf(key) < 0) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"illegal argument: \" + key);\n        }\n    }\n    return operation;\n}\nvar LinkError = (function (_super) {\n    __extends(LinkError, _super);\n    function LinkError(message, link) {\n        var _this = _super.call(this, message) || this;\n        _this.link = link;\n        return _this;\n    }\n    return LinkError;\n}(Error));\nfunction isTerminating(link) {\n    return link.request.length <= 1;\n}\nfunction toPromise(observable) {\n    var completed = false;\n    return new Promise(function (resolve, reject) {\n        observable.subscribe({\n            next: function (data) {\n                if (completed) {\n                    process.env.NODE_ENV === \"production\" || invariant.warn(\"Promise Wrapper does not support multiple results from Observable\");\n                }\n                else {\n                    completed = true;\n                    resolve(data);\n                }\n            },\n            error: reject,\n        });\n    });\n}\nvar makePromise = toPromise;\nfunction fromPromise(promise) {\n    return new Observable(function (observer) {\n        promise\n            .then(function (value) {\n            observer.next(value);\n            observer.complete();\n        })\n            .catch(observer.error.bind(observer));\n    });\n}\nfunction fromError(errorValue) {\n    return new Observable(function (observer) {\n        observer.error(errorValue);\n    });\n}\nfunction transformOperation(operation) {\n    var transformedOperation = {\n        variables: operation.variables || {},\n        extensions: operation.extensions || {},\n        operationName: operation.operationName,\n        query: operation.query,\n    };\n    if (!transformedOperation.operationName) {\n        transformedOperation.operationName =\n            typeof transformedOperation.query !== 'string'\n                ? getOperationName(transformedOperation.query)\n                : '';\n    }\n    return transformedOperation;\n}\nfunction createOperation(starting, operation) {\n    var context = __assign({}, starting);\n    var setContext = function (next) {\n        if (typeof next === 'function') {\n            context = __assign({}, context, next(context));\n        }\n        else {\n            context = __assign({}, context, next);\n        }\n    };\n    var getContext = function () { return (__assign({}, context)); };\n    Object.defineProperty(operation, 'setContext', {\n        enumerable: false,\n        value: setContext,\n    });\n    Object.defineProperty(operation, 'getContext', {\n        enumerable: false,\n        value: getContext,\n    });\n    Object.defineProperty(operation, 'toKey', {\n        enumerable: false,\n        value: function () { return getKey(operation); },\n    });\n    return operation;\n}\nfunction getKey(operation) {\n    var query = operation.query, variables = operation.variables, operationName = operation.operationName;\n    return JSON.stringify([operationName, query, variables]);\n}\n\nfunction passthrough(op, forward) {\n    return forward ? forward(op) : Observable.of();\n}\nfunction toLink(handler) {\n    return typeof handler === 'function' ? new ApolloLink(handler) : handler;\n}\nfunction empty() {\n    return new ApolloLink(function () { return Observable.of(); });\n}\nfunction from(links) {\n    if (links.length === 0)\n        return empty();\n    return links.map(toLink).reduce(function (x, y) { return x.concat(y); });\n}\nfunction split(test, left, right) {\n    var leftLink = toLink(left);\n    var rightLink = toLink(right || new ApolloLink(passthrough));\n    if (isTerminating(leftLink) && isTerminating(rightLink)) {\n        return new ApolloLink(function (operation) {\n            return test(operation)\n                ? leftLink.request(operation) || Observable.of()\n                : rightLink.request(operation) || Observable.of();\n        });\n    }\n    else {\n        return new ApolloLink(function (operation, forward) {\n            return test(operation)\n                ? leftLink.request(operation, forward) || Observable.of()\n                : rightLink.request(operation, forward) || Observable.of();\n        });\n    }\n}\nvar concat = function (first, second) {\n    var firstLink = toLink(first);\n    if (isTerminating(firstLink)) {\n        process.env.NODE_ENV === \"production\" || invariant.warn(new LinkError(\"You are calling concat on a terminating link, which will have no effect\", firstLink));\n        return firstLink;\n    }\n    var nextLink = toLink(second);\n    if (isTerminating(nextLink)) {\n        return new ApolloLink(function (operation) {\n            return firstLink.request(operation, function (op) { return nextLink.request(op) || Observable.of(); }) || Observable.of();\n        });\n    }\n    else {\n        return new ApolloLink(function (operation, forward) {\n            return (firstLink.request(operation, function (op) {\n                return nextLink.request(op, forward) || Observable.of();\n            }) || Observable.of());\n        });\n    }\n};\nvar ApolloLink = (function () {\n    function ApolloLink(request) {\n        if (request)\n            this.request = request;\n    }\n    ApolloLink.prototype.split = function (test, left, right) {\n        return this.concat(split(test, left, right || new ApolloLink(passthrough)));\n    };\n    ApolloLink.prototype.concat = function (next) {\n        return concat(this, next);\n    };\n    ApolloLink.prototype.request = function (operation, forward) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError('request is not implemented');\n    };\n    ApolloLink.empty = empty;\n    ApolloLink.from = from;\n    ApolloLink.split = split;\n    ApolloLink.execute = execute;\n    return ApolloLink;\n}());\nfunction execute(link, operation) {\n    return (link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of());\n}\n\nexport { ApolloLink, concat, createOperation, empty, execute, from, fromError, fromPromise, makePromise, split, toPromise };\n//# sourceMappingURL=bundle.esm.js.map\n","import { __extends, __assign, __awaiter, __generator } from 'tslib';\nimport { getOperationDefinition, isEqual, tryFunctionOrLogError, cloneDeep, mergeDeep, hasDirectives, removeClientSetsFromDocument, buildQueryFromSelectionSet, getMainDefinition, getFragmentDefinitions, createFragmentMap, mergeDeepArray, resultKeyNameFromField, argumentsObjectFromField, shouldInclude, isField, isInlineFragment, canUseWeakMap, graphQLResultHasError, removeConnectionDirectiveFromDocument, hasClientExports, getDefaultValues, getOperationName } from 'apollo-utilities';\nimport { Observable as Observable$1, execute, ApolloLink } from 'apollo-link';\nimport $$observable from 'symbol-observable';\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { visit, BREAK } from 'graphql/language/visitor';\n\nvar NetworkStatus;\n(function (NetworkStatus) {\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n})(NetworkStatus || (NetworkStatus = {}));\nfunction isNetworkRequestInFlight(networkStatus) {\n    return networkStatus < 7;\n}\n\nvar Observable = (function (_super) {\n    __extends(Observable, _super);\n    function Observable() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    Observable.prototype[$$observable] = function () {\n        return this;\n    };\n    Observable.prototype['@@observable'] = function () {\n        return this;\n    };\n    return Observable;\n}(Observable$1));\n\nfunction isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n\nfunction isApolloError(err) {\n    return err.hasOwnProperty('graphQLErrors');\n}\nvar generateErrorMessage = function (err) {\n    var message = '';\n    if (isNonEmptyArray(err.graphQLErrors)) {\n        err.graphQLErrors.forEach(function (graphQLError) {\n            var errorMessage = graphQLError\n                ? graphQLError.message\n                : 'Error message not found.';\n            message += \"GraphQL error: \" + errorMessage + \"\\n\";\n        });\n    }\n    if (err.networkError) {\n        message += 'Network error: ' + err.networkError.message + '\\n';\n    }\n    message = message.replace(/\\n$/, '');\n    return message;\n};\nvar ApolloError = (function (_super) {\n    __extends(ApolloError, _super);\n    function ApolloError(_a) {\n        var graphQLErrors = _a.graphQLErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;\n        var _this = _super.call(this, errorMessage) || this;\n        _this.graphQLErrors = graphQLErrors || [];\n        _this.networkError = networkError || null;\n        if (!errorMessage) {\n            _this.message = generateErrorMessage(_this);\n        }\n        else {\n            _this.message = errorMessage;\n        }\n        _this.extraInfo = extraInfo;\n        _this.__proto__ = ApolloError.prototype;\n        return _this;\n    }\n    return ApolloError;\n}(Error));\n\nvar FetchType;\n(function (FetchType) {\n    FetchType[FetchType[\"normal\"] = 1] = \"normal\";\n    FetchType[FetchType[\"refetch\"] = 2] = \"refetch\";\n    FetchType[FetchType[\"poll\"] = 3] = \"poll\";\n})(FetchType || (FetchType = {}));\n\nvar hasError = function (storeValue, policy) {\n    if (policy === void 0) { policy = 'none'; }\n    return storeValue && (storeValue.networkError ||\n        (policy === 'none' && isNonEmptyArray(storeValue.graphQLErrors)));\n};\nvar ObservableQuery = (function (_super) {\n    __extends(ObservableQuery, _super);\n    function ObservableQuery(_a) {\n        var queryManager = _a.queryManager, options = _a.options, _b = _a.shouldSubscribe, shouldSubscribe = _b === void 0 ? true : _b;\n        var _this = _super.call(this, function (observer) {\n            return _this.onSubscribe(observer);\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        _this.isTornDown = false;\n        _this.options = options;\n        _this.variables = options.variables || {};\n        _this.queryId = queryManager.generateQueryId();\n        _this.shouldSubscribe = shouldSubscribe;\n        var opDef = getOperationDefinition(options.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        _this.queryManager = queryManager;\n        return _this;\n    }\n    ObservableQuery.prototype.result = function () {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            var observer = {\n                next: function (result) {\n                    resolve(result);\n                    _this.observers.delete(observer);\n                    if (!_this.observers.size) {\n                        _this.queryManager.removeQuery(_this.queryId);\n                    }\n                    setTimeout(function () {\n                        subscription.unsubscribe();\n                    }, 0);\n                },\n                error: reject,\n            };\n            var subscription = _this.subscribe(observer);\n        });\n    };\n    ObservableQuery.prototype.currentResult = function () {\n        var result = this.getCurrentResult();\n        if (result.data === undefined) {\n            result.data = {};\n        }\n        return result;\n    };\n    ObservableQuery.prototype.getCurrentResult = function () {\n        if (this.isTornDown) {\n            var lastResult = this.lastResult;\n            return {\n                data: !this.lastError && lastResult && lastResult.data || void 0,\n                error: this.lastError,\n                loading: false,\n                networkStatus: NetworkStatus.error,\n            };\n        }\n        var _a = this.queryManager.getCurrentQueryResult(this), data = _a.data, partial = _a.partial;\n        var queryStoreValue = this.queryManager.queryStore.get(this.queryId);\n        var result;\n        var fetchPolicy = this.options.fetchPolicy;\n        var isNetworkFetchPolicy = fetchPolicy === 'network-only' ||\n            fetchPolicy === 'no-cache';\n        if (queryStoreValue) {\n            var networkStatus = queryStoreValue.networkStatus;\n            if (hasError(queryStoreValue, this.options.errorPolicy)) {\n                return {\n                    data: void 0,\n                    loading: false,\n                    networkStatus: networkStatus,\n                    error: new ApolloError({\n                        graphQLErrors: queryStoreValue.graphQLErrors,\n                        networkError: queryStoreValue.networkError,\n                    }),\n                };\n            }\n            if (queryStoreValue.variables) {\n                this.options.variables = __assign(__assign({}, this.options.variables), queryStoreValue.variables);\n                this.variables = this.options.variables;\n            }\n            result = {\n                data: data,\n                loading: isNetworkRequestInFlight(networkStatus),\n                networkStatus: networkStatus,\n            };\n            if (queryStoreValue.graphQLErrors && this.options.errorPolicy === 'all') {\n                result.errors = queryStoreValue.graphQLErrors;\n            }\n        }\n        else {\n            var loading = isNetworkFetchPolicy ||\n                (partial && fetchPolicy !== 'cache-only');\n            result = {\n                data: data,\n                loading: loading,\n                networkStatus: loading ? NetworkStatus.loading : NetworkStatus.ready,\n            };\n        }\n        if (!partial) {\n            this.updateLastResult(__assign(__assign({}, result), { stale: false }));\n        }\n        return __assign(__assign({}, result), { partial: partial });\n    };\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {\n        var snapshot = this.lastResultSnapshot;\n        return !(snapshot &&\n            newResult &&\n            snapshot.networkStatus === newResult.networkStatus &&\n            snapshot.stale === newResult.stale &&\n            isEqual(snapshot.data, newResult.data));\n    };\n    ObservableQuery.prototype.getLastResult = function () {\n        return this.lastResult;\n    };\n    ObservableQuery.prototype.getLastError = function () {\n        return this.lastError;\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.lastResult;\n        delete this.lastResultSnapshot;\n        delete this.lastError;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        var queryStore = this.queryManager.queryStore.get(this.queryId);\n        if (queryStore) {\n            queryStore.networkError = null;\n            queryStore.graphQLErrors = [];\n        }\n    };\n    ObservableQuery.prototype.refetch = function (variables) {\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === 'cache-only') {\n            return Promise.reject(process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError('cache-only fetchPolicy option should not be used together with query refetch.'));\n        }\n        if (fetchPolicy !== 'no-cache' &&\n            fetchPolicy !== 'cache-and-network') {\n            fetchPolicy = 'network-only';\n        }\n        if (!isEqual(this.variables, variables)) {\n            this.variables = __assign(__assign({}, this.variables), variables);\n        }\n        if (!isEqual(this.options.variables, this.variables)) {\n            this.options.variables = __assign(__assign({}, this.options.variables), this.variables);\n        }\n        return this.queryManager.fetchQuery(this.queryId, __assign(__assign({}, this.options), { fetchPolicy: fetchPolicy }), FetchType.refetch);\n    };\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(fetchMoreOptions.updateQuery, 2) : invariant(fetchMoreOptions.updateQuery, 'updateQuery option is required. This function defines how to update the query data with the new results.');\n        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : __assign(__assign(__assign({}, this.options), fetchMoreOptions), { variables: __assign(__assign({}, this.variables), fetchMoreOptions.variables) }))), { fetchPolicy: 'network-only' });\n        var qid = this.queryManager.generateQueryId();\n        return this.queryManager\n            .fetchQuery(qid, combinedOptions, FetchType.normal, this.queryId)\n            .then(function (fetchMoreResult) {\n            _this.updateQuery(function (previousResult) {\n                return fetchMoreOptions.updateQuery(previousResult, {\n                    fetchMoreResult: fetchMoreResult.data,\n                    variables: combinedOptions.variables,\n                });\n            });\n            _this.queryManager.stopQuery(qid);\n            return fetchMoreResult;\n        }, function (error) {\n            _this.queryManager.stopQuery(qid);\n            throw error;\n        });\n    };\n    ObservableQuery.prototype.subscribeToMore = function (options) {\n        var _this = this;\n        var subscription = this.queryManager\n            .startGraphQLSubscription({\n            query: options.document,\n            variables: options.variables,\n        })\n            .subscribe({\n            next: function (subscriptionData) {\n                var updateQuery = options.updateQuery;\n                if (updateQuery) {\n                    _this.updateQuery(function (previous, _a) {\n                        var variables = _a.variables;\n                        return updateQuery(previous, {\n                            subscriptionData: subscriptionData,\n                            variables: variables,\n                        });\n                    });\n                }\n            },\n            error: function (err) {\n                if (options.onError) {\n                    options.onError(err);\n                    return;\n                }\n                process.env.NODE_ENV === \"production\" || invariant.error('Unhandled GraphQL subscription error', err);\n            },\n        });\n        this.subscriptions.add(subscription);\n        return function () {\n            if (_this.subscriptions.delete(subscription)) {\n                subscription.unsubscribe();\n            }\n        };\n    };\n    ObservableQuery.prototype.setOptions = function (opts) {\n        var oldFetchPolicy = this.options.fetchPolicy;\n        this.options = __assign(__assign({}, this.options), opts);\n        if (opts.pollInterval) {\n            this.startPolling(opts.pollInterval);\n        }\n        else if (opts.pollInterval === 0) {\n            this.stopPolling();\n        }\n        var fetchPolicy = opts.fetchPolicy;\n        return this.setVariables(this.options.variables, oldFetchPolicy !== fetchPolicy && (oldFetchPolicy === 'cache-only' ||\n            oldFetchPolicy === 'standby' ||\n            fetchPolicy === 'network-only'), opts.fetchResults);\n    };\n    ObservableQuery.prototype.setVariables = function (variables, tryFetch, fetchResults) {\n        if (tryFetch === void 0) { tryFetch = false; }\n        if (fetchResults === void 0) { fetchResults = true; }\n        this.isTornDown = false;\n        variables = variables || this.variables;\n        if (!tryFetch && isEqual(variables, this.variables)) {\n            return this.observers.size && fetchResults\n                ? this.result()\n                : Promise.resolve();\n        }\n        this.variables = this.options.variables = variables;\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        return this.queryManager.fetchQuery(this.queryId, this.options);\n    };\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var queryManager = this.queryManager;\n        var _a = queryManager.getQueryWithPreviousResult(this.queryId), previousResult = _a.previousResult, variables = _a.variables, document = _a.document;\n        var newResult = tryFunctionOrLogError(function () {\n            return mapFn(previousResult, { variables: variables });\n        });\n        if (newResult) {\n            queryManager.dataStore.markUpdateQueryResult(document, variables, newResult);\n            queryManager.broadcastQueries();\n        }\n    };\n    ObservableQuery.prototype.stopPolling = function () {\n        this.queryManager.stopPollingQuery(this.queryId);\n        this.options.pollInterval = undefined;\n    };\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        assertNotCacheFirstOrOnly(this);\n        this.options.pollInterval = pollInterval;\n        this.queryManager.startPollingQuery(this.options, this.queryId);\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult) {\n        var previousResult = this.lastResult;\n        this.lastResult = newResult;\n        this.lastResultSnapshot = this.queryManager.assumeImmutableResults\n            ? newResult\n            : cloneDeep(newResult);\n        return previousResult;\n    };\n    ObservableQuery.prototype.onSubscribe = function (observer) {\n        var _this = this;\n        try {\n            var subObserver = observer._subscription._observer;\n            if (subObserver && !subObserver.error) {\n                subObserver.error = defaultSubscriptionObserverErrorCallback;\n            }\n        }\n        catch (_a) { }\n        var first = !this.observers.size;\n        this.observers.add(observer);\n        if (observer.next && this.lastResult)\n            observer.next(this.lastResult);\n        if (observer.error && this.lastError)\n            observer.error(this.lastError);\n        if (first) {\n            this.setUpQuery();\n        }\n        return function () {\n            if (_this.observers.delete(observer) && !_this.observers.size) {\n                _this.tearDownQuery();\n            }\n        };\n    };\n    ObservableQuery.prototype.setUpQuery = function () {\n        var _this = this;\n        var _a = this, queryManager = _a.queryManager, queryId = _a.queryId;\n        if (this.shouldSubscribe) {\n            queryManager.addObservableQuery(queryId, this);\n        }\n        if (this.options.pollInterval) {\n            assertNotCacheFirstOrOnly(this);\n            queryManager.startPollingQuery(this.options, queryId);\n        }\n        var onError = function (error) {\n            _this.updateLastResult(__assign(__assign({}, _this.lastResult), { errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false }));\n            iterateObserversSafely(_this.observers, 'error', _this.lastError = error);\n        };\n        queryManager.observeQuery(queryId, this.options, {\n            next: function (result) {\n                if (_this.lastError || _this.isDifferentFromLastResult(result)) {\n                    var previousResult_1 = _this.updateLastResult(result);\n                    var _a = _this.options, query_1 = _a.query, variables = _a.variables, fetchPolicy_1 = _a.fetchPolicy;\n                    if (queryManager.transform(query_1).hasClientExports) {\n                        queryManager.getLocalState().addExportedVariables(query_1, variables).then(function (variables) {\n                            var previousVariables = _this.variables;\n                            _this.variables = _this.options.variables = variables;\n                            if (!result.loading &&\n                                previousResult_1 &&\n                                fetchPolicy_1 !== 'cache-only' &&\n                                queryManager.transform(query_1).serverQuery &&\n                                !isEqual(previousVariables, variables)) {\n                                _this.refetch();\n                            }\n                            else {\n                                iterateObserversSafely(_this.observers, 'next', result);\n                            }\n                        });\n                    }\n                    else {\n                        iterateObserversSafely(_this.observers, 'next', result);\n                    }\n                }\n            },\n            error: onError,\n        }).catch(onError);\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        var queryManager = this.queryManager;\n        this.isTornDown = true;\n        queryManager.stopPollingQuery(this.queryId);\n        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n        this.subscriptions.clear();\n        queryManager.removeObservableQuery(this.queryId);\n        queryManager.stopQuery(this.queryId);\n        this.observers.clear();\n    };\n    return ObservableQuery;\n}(Observable));\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    process.env.NODE_ENV === \"production\" || invariant.error('Unhandled error', error.message, error.stack);\n}\nfunction iterateObserversSafely(observers, method, argument) {\n    var observersWithMethod = [];\n    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });\n    observersWithMethod.forEach(function (obs) { return obs[method](argument); });\n}\nfunction assertNotCacheFirstOrOnly(obsQuery) {\n    var fetchPolicy = obsQuery.options.fetchPolicy;\n    process.env.NODE_ENV === \"production\" ? invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 3) : invariant(fetchPolicy !== 'cache-first' && fetchPolicy !== 'cache-only', 'Queries that specify the cache-first and cache-only fetchPolicies cannot also be polling queries.');\n}\n\nvar MutationStore = (function () {\n    function MutationStore() {\n        this.store = {};\n    }\n    MutationStore.prototype.getStore = function () {\n        return this.store;\n    };\n    MutationStore.prototype.get = function (mutationId) {\n        return this.store[mutationId];\n    };\n    MutationStore.prototype.initMutation = function (mutationId, mutation, variables) {\n        this.store[mutationId] = {\n            mutation: mutation,\n            variables: variables || {},\n            loading: true,\n            error: null,\n        };\n    };\n    MutationStore.prototype.markMutationError = function (mutationId, error) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = error;\n        }\n    };\n    MutationStore.prototype.markMutationResult = function (mutationId) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = null;\n        }\n    };\n    MutationStore.prototype.reset = function () {\n        this.store = {};\n    };\n    return MutationStore;\n}());\n\nvar QueryStore = (function () {\n    function QueryStore() {\n        this.store = {};\n    }\n    QueryStore.prototype.getStore = function () {\n        return this.store;\n    };\n    QueryStore.prototype.get = function (queryId) {\n        return this.store[queryId];\n    };\n    QueryStore.prototype.initQuery = function (query) {\n        var previousQuery = this.store[query.queryId];\n        process.env.NODE_ENV === \"production\" ? invariant(!previousQuery ||\n            previousQuery.document === query.document ||\n            isEqual(previousQuery.document, query.document), 19) : invariant(!previousQuery ||\n            previousQuery.document === query.document ||\n            isEqual(previousQuery.document, query.document), 'Internal Error: may not update existing query string in store');\n        var isSetVariables = false;\n        var previousVariables = null;\n        if (query.storePreviousVariables &&\n            previousQuery &&\n            previousQuery.networkStatus !== NetworkStatus.loading) {\n            if (!isEqual(previousQuery.variables, query.variables)) {\n                isSetVariables = true;\n                previousVariables = previousQuery.variables;\n            }\n        }\n        var networkStatus;\n        if (isSetVariables) {\n            networkStatus = NetworkStatus.setVariables;\n        }\n        else if (query.isPoll) {\n            networkStatus = NetworkStatus.poll;\n        }\n        else if (query.isRefetch) {\n            networkStatus = NetworkStatus.refetch;\n        }\n        else {\n            networkStatus = NetworkStatus.loading;\n        }\n        var graphQLErrors = [];\n        if (previousQuery && previousQuery.graphQLErrors) {\n            graphQLErrors = previousQuery.graphQLErrors;\n        }\n        this.store[query.queryId] = {\n            document: query.document,\n            variables: query.variables,\n            previousVariables: previousVariables,\n            networkError: null,\n            graphQLErrors: graphQLErrors,\n            networkStatus: networkStatus,\n            metadata: query.metadata,\n        };\n        if (typeof query.fetchMoreForQueryId === 'string' &&\n            this.store[query.fetchMoreForQueryId]) {\n            this.store[query.fetchMoreForQueryId].networkStatus =\n                NetworkStatus.fetchMore;\n        }\n    };\n    QueryStore.prototype.markQueryResult = function (queryId, result, fetchMoreForQueryId) {\n        if (!this.store || !this.store[queryId])\n            return;\n        this.store[queryId].networkError = null;\n        this.store[queryId].graphQLErrors = isNonEmptyArray(result.errors) ? result.errors : [];\n        this.store[queryId].previousVariables = null;\n        this.store[queryId].networkStatus = NetworkStatus.ready;\n        if (typeof fetchMoreForQueryId === 'string' &&\n            this.store[fetchMoreForQueryId]) {\n            this.store[fetchMoreForQueryId].networkStatus = NetworkStatus.ready;\n        }\n    };\n    QueryStore.prototype.markQueryError = function (queryId, error, fetchMoreForQueryId) {\n        if (!this.store || !this.store[queryId])\n            return;\n        this.store[queryId].networkError = error;\n        this.store[queryId].networkStatus = NetworkStatus.error;\n        if (typeof fetchMoreForQueryId === 'string') {\n            this.markQueryResultClient(fetchMoreForQueryId, true);\n        }\n    };\n    QueryStore.prototype.markQueryResultClient = function (queryId, complete) {\n        var storeValue = this.store && this.store[queryId];\n        if (storeValue) {\n            storeValue.networkError = null;\n            storeValue.previousVariables = null;\n            if (complete) {\n                storeValue.networkStatus = NetworkStatus.ready;\n            }\n        }\n    };\n    QueryStore.prototype.stopQuery = function (queryId) {\n        delete this.store[queryId];\n    };\n    QueryStore.prototype.reset = function (observableQueryIds) {\n        var _this = this;\n        Object.keys(this.store).forEach(function (queryId) {\n            if (observableQueryIds.indexOf(queryId) < 0) {\n                _this.stopQuery(queryId);\n            }\n            else {\n                _this.store[queryId].networkStatus = NetworkStatus.loading;\n            }\n        });\n    };\n    return QueryStore;\n}());\n\nfunction capitalizeFirstLetter(str) {\n    return str.charAt(0).toUpperCase() + str.slice(1);\n}\n\nvar LocalState = (function () {\n    function LocalState(_a) {\n        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;\n        this.cache = cache;\n        if (client) {\n            this.client = client;\n        }\n        if (resolvers) {\n            this.addResolvers(resolvers);\n        }\n        if (fragmentMatcher) {\n            this.setFragmentMatcher(fragmentMatcher);\n        }\n    }\n    LocalState.prototype.addResolvers = function (resolvers) {\n        var _this = this;\n        this.resolvers = this.resolvers || {};\n        if (Array.isArray(resolvers)) {\n            resolvers.forEach(function (resolverGroup) {\n                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);\n            });\n        }\n        else {\n            this.resolvers = mergeDeep(this.resolvers, resolvers);\n        }\n    };\n    LocalState.prototype.setResolvers = function (resolvers) {\n        this.resolvers = {};\n        this.addResolvers(resolvers);\n    };\n    LocalState.prototype.getResolvers = function () {\n        return this.resolvers || {};\n    };\n    LocalState.prototype.runResolvers = function (_a) {\n        var document = _a.document, remoteResult = _a.remoteResult, context = _a.context, variables = _a.variables, _b = _a.onlyRunForcedResolvers, onlyRunForcedResolvers = _b === void 0 ? false : _b;\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_c) {\n                if (document) {\n                    return [2, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (__assign(__assign({}, remoteResult), { data: localResult.result })); })];\n                }\n                return [2, remoteResult];\n            });\n        });\n    };\n    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n        this.fragmentMatcher = fragmentMatcher;\n    };\n    LocalState.prototype.getFragmentMatcher = function () {\n        return this.fragmentMatcher;\n    };\n    LocalState.prototype.clientQuery = function (document) {\n        if (hasDirectives(['client'], document)) {\n            if (this.resolvers) {\n                return document;\n            }\n            process.env.NODE_ENV === \"production\" || invariant.warn('Found @client directives in a query but no ApolloClient resolvers ' +\n                'were specified. This means ApolloClient local resolver handling ' +\n                'has been disabled, and @client directives will be passed through ' +\n                'to your link chain.');\n        }\n        return null;\n    };\n    LocalState.prototype.serverQuery = function (document) {\n        return this.resolvers ? removeClientSetsFromDocument(document) : document;\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var cache = this.cache;\n        var newContext = __assign(__assign({}, context), { cache: cache, getCacheKey: function (obj) {\n                if (cache.config) {\n                    return cache.config.dataIdFromObject(obj);\n                }\n                else {\n                    process.env.NODE_ENV === \"production\" ? invariant(false, 6) : invariant(false, 'To use context.getCacheKey, you need to use a cache that has ' +\n                        'a configurable dataIdFromObject, like apollo-cache-inmemory.');\n                }\n            } });\n        return newContext;\n    };\n    LocalState.prototype.addExportedVariables = function (document, variables, context) {\n        if (variables === void 0) { variables = {}; }\n        if (context === void 0) { context = {}; }\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                if (document) {\n                    return [2, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (__assign(__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2, __assign({}, variables)];\n            });\n        });\n    };\n    LocalState.prototype.shouldForceResolvers = function (document) {\n        var forceResolvers = false;\n        visit(document, {\n            Directive: {\n                enter: function (node) {\n                    if (node.name.value === 'client' && node.arguments) {\n                        forceResolvers = node.arguments.some(function (arg) {\n                            return arg.name.value === 'always' &&\n                                arg.value.kind === 'BooleanValue' &&\n                                arg.value.value === true;\n                        });\n                        if (forceResolvers) {\n                            return BREAK;\n                        }\n                    }\n                },\n            },\n        });\n        return forceResolvers;\n    };\n    LocalState.prototype.buildRootValueFromCache = function (document, variables) {\n        return this.cache.diff({\n            query: buildQueryFromSelectionSet(document),\n            variables: variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n    };\n    LocalState.prototype.resolveDocument = function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n        if (context === void 0) { context = {}; }\n        if (variables === void 0) { variables = {}; }\n        if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }\n        if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }\n        return __awaiter(this, void 0, void 0, function () {\n            var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;\n            return __generator(this, function (_b) {\n                mainDefinition = getMainDefinition(document);\n                fragments = getFragmentDefinitions(document);\n                fragmentMap = createFragmentMap(fragments);\n                definitionOperation = mainDefinition\n                    .operation;\n                defaultOperationType = definitionOperation\n                    ? capitalizeFirstLetter(definitionOperation)\n                    : 'Query';\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: __assign(__assign({}, context), { cache: cache,\n                        client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                return [2, this.resolveSelectionSet(mainDefinition.selectionSet, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return __generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return __awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return __generator(this, function (_a) {\n                        if (!shouldInclude(selection, variables)) {\n                            return [2];\n                        }\n                        if (isField(selection)) {\n                            return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {\n                                    var _a;\n                                    if (typeof fieldResult !== 'undefined') {\n                                        resultsToMerge.push((_a = {},\n                                            _a[resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            fragment = fragmentMap[selection.name.value];\n                            process.env.NODE_ENV === \"production\" ? invariant(fragment, 7) : invariant(fragment, \"No fragment named \" + selection.name.value);\n                        }\n                        if (fragment && fragment.typeCondition) {\n                            typeCondition = fragment.typeCondition.name.value;\n                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {\n                                return [2, this.resolveSelectionSet(fragment.selectionSet, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2];\n                    });\n                }); };\n                return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return __generator(this, function (_a) {\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = resultKeyNameFromField(field);\n                aliasUsed = fieldName !== aliasedFieldName;\n                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];\n                resultPromise = Promise.resolve(defaultResult);\n                if (!execContext.onlyRunForcedResolvers ||\n                    this.shouldForceResolvers(field)) {\n                    resolverType = rootValue.__typename || execContext.defaultOperationType;\n                    resolverMap = this.resolvers && this.resolvers[resolverType];\n                    if (resolverMap) {\n                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n                        if (resolve) {\n                            resultPromise = Promise.resolve(resolve(rootValue, argumentsObjectFromField(field, variables), execContext.context, { field: field, fragmentMap: execContext.fragmentMap }));\n                        }\n                    }\n                }\n                return [2, resultPromise.then(function (result) {\n                        if (result === void 0) { result = defaultResult; }\n                        if (field.directives) {\n                            field.directives.forEach(function (directive) {\n                                if (directive.name.value === 'export' && directive.arguments) {\n                                    directive.arguments.forEach(function (arg) {\n                                        if (arg.name.value === 'as' && arg.value.kind === 'StringValue') {\n                                            execContext.exportedVariables[arg.value.value] = result;\n                                        }\n                                    });\n                                }\n                            });\n                        }\n                        if (!field.selectionSet) {\n                            return result;\n                        }\n                        if (result == null) {\n                            return result;\n                        }\n                        if (Array.isArray(result)) {\n                            return _this.resolveSubSelectedArray(field, result, execContext);\n                        }\n                        if (field.selectionSet) {\n                            return _this.resolveSelectionSet(field.selectionSet, result, execContext);\n                        }\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {\n        var _this = this;\n        return Promise.all(result.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return _this.resolveSubSelectedArray(field, item, execContext);\n            }\n            if (field.selectionSet) {\n                return _this.resolveSelectionSet(field.selectionSet, item, execContext);\n            }\n        }));\n    };\n    return LocalState;\n}());\n\nfunction multiplex(inner) {\n    var observers = new Set();\n    var sub = null;\n    return new Observable(function (observer) {\n        observers.add(observer);\n        sub = sub || inner.subscribe({\n            next: function (value) {\n                observers.forEach(function (obs) { return obs.next && obs.next(value); });\n            },\n            error: function (error) {\n                observers.forEach(function (obs) { return obs.error && obs.error(error); });\n            },\n            complete: function () {\n                observers.forEach(function (obs) { return obs.complete && obs.complete(); });\n            },\n        });\n        return function () {\n            if (observers.delete(observer) && !observers.size && sub) {\n                sub.unsubscribe();\n                sub = null;\n            }\n        };\n    });\n}\nfunction asyncMap(observable, mapFn) {\n    return new Observable(function (observer) {\n        var next = observer.next, error = observer.error, complete = observer.complete;\n        var activeNextCount = 0;\n        var completed = false;\n        var handler = {\n            next: function (value) {\n                ++activeNextCount;\n                new Promise(function (resolve) {\n                    resolve(mapFn(value));\n                }).then(function (result) {\n                    --activeNextCount;\n                    next && next.call(observer, result);\n                    completed && handler.complete();\n                }, function (e) {\n                    --activeNextCount;\n                    error && error.call(observer, e);\n                });\n            },\n            error: function (e) {\n                error && error.call(observer, e);\n            },\n            complete: function () {\n                completed = true;\n                if (!activeNextCount) {\n                    complete && complete.call(observer);\n                }\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar QueryManager = (function () {\n    function QueryManager(_a) {\n        var link = _a.link, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, store = _a.store, _c = _a.onBroadcast, onBroadcast = _c === void 0 ? function () { return undefined; } : _c, _d = _a.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = _a.clientAwareness, clientAwareness = _e === void 0 ? {} : _e, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;\n        this.mutationStore = new MutationStore();\n        this.queryStore = new QueryStore();\n        this.clientAwareness = {};\n        this.idCounter = 1;\n        this.queries = new Map();\n        this.fetchQueryRejectFns = new Map();\n        this.transformCache = new (canUseWeakMap ? WeakMap : Map)();\n        this.inFlightLinkObservables = new Map();\n        this.pollingInfoByQueryId = new Map();\n        this.link = link;\n        this.queryDeduplication = queryDeduplication;\n        this.dataStore = store;\n        this.onBroadcast = onBroadcast;\n        this.clientAwareness = clientAwareness;\n        this.localState = localState || new LocalState({ cache: store.getCache() });\n        this.ssrMode = ssrMode;\n        this.assumeImmutableResults = !!assumeImmutableResults;\n    }\n    QueryManager.prototype.stop = function () {\n        var _this = this;\n        this.queries.forEach(function (_info, queryId) {\n            _this.stopQueryNoBroadcast(queryId);\n        });\n        this.fetchQueryRejectFns.forEach(function (reject) {\n            reject(process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError('QueryManager stopped while query was in flight'));\n        });\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueriesByName = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, _e = _a.context, context = _e === void 0 ? {} : _e;\n        return __awaiter(this, void 0, void 0, function () {\n            var mutationId, generateUpdateQueriesInfo, self;\n            var _this = this;\n            return __generator(this, function (_f) {\n                switch (_f.label) {\n                    case 0:\n                        process.env.NODE_ENV === \"production\" ? invariant(mutation, 9) : invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.');\n                        process.env.NODE_ENV === \"production\" ? invariant(!fetchPolicy || fetchPolicy === 'no-cache', 10) : invariant(!fetchPolicy || fetchPolicy === 'no-cache', \"Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.\");\n                        mutationId = this.generateQueryId();\n                        mutation = this.transform(mutation).document;\n                        this.setQuery(mutationId, function () { return ({ document: mutation }); });\n                        variables = this.getVariables(mutation, variables);\n                        if (!this.transform(mutation).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = _f.sent();\n                        _f.label = 2;\n                    case 2:\n                        generateUpdateQueriesInfo = function () {\n                            var ret = {};\n                            if (updateQueriesByName) {\n                                _this.queries.forEach(function (_a, queryId) {\n                                    var observableQuery = _a.observableQuery;\n                                    if (observableQuery) {\n                                        var queryName = observableQuery.queryName;\n                                        if (queryName &&\n                                            hasOwnProperty.call(updateQueriesByName, queryName)) {\n                                            ret[queryId] = {\n                                                updater: updateQueriesByName[queryName],\n                                                query: _this.queryStore.get(queryId),\n                                            };\n                                        }\n                                    }\n                                });\n                            }\n                            return ret;\n                        };\n                        this.mutationStore.initMutation(mutationId, mutation, variables);\n                        this.dataStore.markMutationInit({\n                            mutationId: mutationId,\n                            document: mutation,\n                            variables: variables,\n                            updateQueries: generateUpdateQueriesInfo(),\n                            update: updateWithProxyFn,\n                            optimisticResponse: optimisticResponse,\n                        });\n                        this.broadcastQueries();\n                        self = this;\n                        return [2, new Promise(function (resolve, reject) {\n                                var storeResult;\n                                var error;\n                                self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false).subscribe({\n                                    next: function (result) {\n                                        if (graphQLResultHasError(result) && errorPolicy === 'none') {\n                                            error = new ApolloError({\n                                                graphQLErrors: result.errors,\n                                            });\n                                            return;\n                                        }\n                                        self.mutationStore.markMutationResult(mutationId);\n                                        if (fetchPolicy !== 'no-cache') {\n                                            self.dataStore.markMutationResult({\n                                                mutationId: mutationId,\n                                                result: result,\n                                                document: mutation,\n                                                variables: variables,\n                                                updateQueries: generateUpdateQueriesInfo(),\n                                                update: updateWithProxyFn,\n                                            });\n                                        }\n                                        storeResult = result;\n                                    },\n                                    error: function (err) {\n                                        self.mutationStore.markMutationError(mutationId, err);\n                                        self.dataStore.markMutationComplete({\n                                            mutationId: mutationId,\n                                            optimisticResponse: optimisticResponse,\n                                        });\n                                        self.broadcastQueries();\n                                        self.setQuery(mutationId, function () { return ({ document: null }); });\n                                        reject(new ApolloError({\n                                            networkError: err,\n                                        }));\n                                    },\n                                    complete: function () {\n                                        if (error) {\n                                            self.mutationStore.markMutationError(mutationId, error);\n                                        }\n                                        self.dataStore.markMutationComplete({\n                                            mutationId: mutationId,\n                                            optimisticResponse: optimisticResponse,\n                                        });\n                                        self.broadcastQueries();\n                                        if (error) {\n                                            reject(error);\n                                            return;\n                                        }\n                                        if (typeof refetchQueries === 'function') {\n                                            refetchQueries = refetchQueries(storeResult);\n                                        }\n                                        var refetchQueryPromises = [];\n                                        if (isNonEmptyArray(refetchQueries)) {\n                                            refetchQueries.forEach(function (refetchQuery) {\n                                                if (typeof refetchQuery === 'string') {\n                                                    self.queries.forEach(function (_a) {\n                                                        var observableQuery = _a.observableQuery;\n                                                        if (observableQuery &&\n                                                            observableQuery.queryName === refetchQuery) {\n                                                            refetchQueryPromises.push(observableQuery.refetch());\n                                                        }\n                                                    });\n                                                }\n                                                else {\n                                                    var queryOptions = {\n                                                        query: refetchQuery.query,\n                                                        variables: refetchQuery.variables,\n                                                        fetchPolicy: 'network-only',\n                                                    };\n                                                    if (refetchQuery.context) {\n                                                        queryOptions.context = refetchQuery.context;\n                                                    }\n                                                    refetchQueryPromises.push(self.query(queryOptions));\n                                                }\n                                            });\n                                        }\n                                        Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {\n                                            self.setQuery(mutationId, function () { return ({ document: null }); });\n                                            if (errorPolicy === 'ignore' &&\n                                                storeResult &&\n                                                graphQLResultHasError(storeResult)) {\n                                                delete storeResult.errors;\n                                            }\n                                            resolve(storeResult);\n                                        });\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, fetchType, fetchMoreForQueryId) {\n        return __awaiter(this, void 0, void 0, function () {\n            var _a, metadata, _b, fetchPolicy, _c, context, query, variables, storeResult, isNetworkOnly, needToFetch, _d, complete, result, shouldFetch, requestId, cancel, networkResult;\n            var _this = this;\n            return __generator(this, function (_e) {\n                switch (_e.label) {\n                    case 0:\n                        _a = options.metadata, metadata = _a === void 0 ? null : _a, _b = options.fetchPolicy, fetchPolicy = _b === void 0 ? 'cache-first' : _b, _c = options.context, context = _c === void 0 ? {} : _c;\n                        query = this.transform(options.query).document;\n                        variables = this.getVariables(query, options.variables);\n                        if (!this.transform(query).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(query, variables, context)];\n                    case 1:\n                        variables = _e.sent();\n                        _e.label = 2;\n                    case 2:\n                        options = __assign(__assign({}, options), { variables: variables });\n                        isNetworkOnly = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';\n                        needToFetch = isNetworkOnly;\n                        if (!isNetworkOnly) {\n                            _d = this.dataStore.getCache().diff({\n                                query: query,\n                                variables: variables,\n                                returnPartialData: true,\n                                optimistic: false,\n                            }), complete = _d.complete, result = _d.result;\n                            needToFetch = !complete || fetchPolicy === 'cache-and-network';\n                            storeResult = result;\n                        }\n                        shouldFetch = needToFetch && fetchPolicy !== 'cache-only' && fetchPolicy !== 'standby';\n                        if (hasDirectives(['live'], query))\n                            shouldFetch = true;\n                        requestId = this.idCounter++;\n                        cancel = fetchPolicy !== 'no-cache'\n                            ? this.updateQueryWatch(queryId, query, options)\n                            : undefined;\n                        this.setQuery(queryId, function () { return ({\n                            document: query,\n                            lastRequestId: requestId,\n                            invalidated: true,\n                            cancel: cancel,\n                        }); });\n                        this.invalidate(fetchMoreForQueryId);\n                        this.queryStore.initQuery({\n                            queryId: queryId,\n                            document: query,\n                            storePreviousVariables: shouldFetch,\n                            variables: variables,\n                            isPoll: fetchType === FetchType.poll,\n                            isRefetch: fetchType === FetchType.refetch,\n                            metadata: metadata,\n                            fetchMoreForQueryId: fetchMoreForQueryId,\n                        });\n                        this.broadcastQueries();\n                        if (shouldFetch) {\n                            networkResult = this.fetchRequest({\n                                requestId: requestId,\n                                queryId: queryId,\n                                document: query,\n                                options: options,\n                                fetchMoreForQueryId: fetchMoreForQueryId,\n                            }).catch(function (error) {\n                                if (isApolloError(error)) {\n                                    throw error;\n                                }\n                                else {\n                                    if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                                        _this.queryStore.markQueryError(queryId, error, fetchMoreForQueryId);\n                                        _this.invalidate(queryId);\n                                        _this.invalidate(fetchMoreForQueryId);\n                                        _this.broadcastQueries();\n                                    }\n                                    throw new ApolloError({ networkError: error });\n                                }\n                            });\n                            if (fetchPolicy !== 'cache-and-network') {\n                                return [2, networkResult];\n                            }\n                            networkResult.catch(function () { });\n                        }\n                        this.queryStore.markQueryResultClient(queryId, !shouldFetch);\n                        this.invalidate(queryId);\n                        this.invalidate(fetchMoreForQueryId);\n                        if (this.transform(query).hasForcedResolvers) {\n                            return [2, this.localState.runResolvers({\n                                    document: query,\n                                    remoteResult: { data: storeResult },\n                                    context: context,\n                                    variables: variables,\n                                    onlyRunForcedResolvers: true,\n                                }).then(function (result) {\n                                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n                                    _this.broadcastQueries();\n                                    return result;\n                                })];\n                        }\n                        this.broadcastQueries();\n                        return [2, { data: storeResult }];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.markQueryResult = function (queryId, result, _a, fetchMoreForQueryId) {\n        var fetchPolicy = _a.fetchPolicy, variables = _a.variables, errorPolicy = _a.errorPolicy;\n        if (fetchPolicy === 'no-cache') {\n            this.setQuery(queryId, function () { return ({\n                newData: { result: result.data, complete: true },\n            }); });\n        }\n        else {\n            this.dataStore.markQueryResult(result, this.getQuery(queryId).document, variables, fetchMoreForQueryId, errorPolicy === 'ignore' || errorPolicy === 'all');\n        }\n    };\n    QueryManager.prototype.queryListenerForObserver = function (queryId, options, observer) {\n        var _this = this;\n        function invoke(method, argument) {\n            if (observer[method]) {\n                try {\n                    observer[method](argument);\n                }\n                catch (e) {\n                    process.env.NODE_ENV === \"production\" || invariant.error(e);\n                }\n            }\n            else if (method === 'error') {\n                process.env.NODE_ENV === \"production\" || invariant.error(argument);\n            }\n        }\n        return function (queryStoreValue, newData) {\n            _this.invalidate(queryId, false);\n            if (!queryStoreValue)\n                return;\n            var _a = _this.getQuery(queryId), observableQuery = _a.observableQuery, document = _a.document;\n            var fetchPolicy = observableQuery\n                ? observableQuery.options.fetchPolicy\n                : options.fetchPolicy;\n            if (fetchPolicy === 'standby')\n                return;\n            var loading = isNetworkRequestInFlight(queryStoreValue.networkStatus);\n            var lastResult = observableQuery && observableQuery.getLastResult();\n            var networkStatusChanged = !!(lastResult &&\n                lastResult.networkStatus !== queryStoreValue.networkStatus);\n            var shouldNotifyIfLoading = options.returnPartialData ||\n                (!newData && queryStoreValue.previousVariables) ||\n                (networkStatusChanged && options.notifyOnNetworkStatusChange) ||\n                fetchPolicy === 'cache-only' ||\n                fetchPolicy === 'cache-and-network';\n            if (loading && !shouldNotifyIfLoading) {\n                return;\n            }\n            var hasGraphQLErrors = isNonEmptyArray(queryStoreValue.graphQLErrors);\n            var errorPolicy = observableQuery\n                && observableQuery.options.errorPolicy\n                || options.errorPolicy\n                || 'none';\n            if (errorPolicy === 'none' && hasGraphQLErrors || queryStoreValue.networkError) {\n                return invoke('error', new ApolloError({\n                    graphQLErrors: queryStoreValue.graphQLErrors,\n                    networkError: queryStoreValue.networkError,\n                }));\n            }\n            try {\n                var data = void 0;\n                var isMissing = void 0;\n                if (newData) {\n                    if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'network-only') {\n                        _this.setQuery(queryId, function () { return ({ newData: null }); });\n                    }\n                    data = newData.result;\n                    isMissing = !newData.complete;\n                }\n                else {\n                    var lastError = observableQuery && observableQuery.getLastError();\n                    var errorStatusChanged = errorPolicy !== 'none' &&\n                        (lastError && lastError.graphQLErrors) !==\n                            queryStoreValue.graphQLErrors;\n                    if (lastResult && lastResult.data && !errorStatusChanged) {\n                        data = lastResult.data;\n                        isMissing = false;\n                    }\n                    else {\n                        var diffResult = _this.dataStore.getCache().diff({\n                            query: document,\n                            variables: queryStoreValue.previousVariables ||\n                                queryStoreValue.variables,\n                            returnPartialData: true,\n                            optimistic: true,\n                        });\n                        data = diffResult.result;\n                        isMissing = !diffResult.complete;\n                    }\n                }\n                var stale = isMissing && !(options.returnPartialData ||\n                    fetchPolicy === 'cache-only');\n                var resultFromStore = {\n                    data: stale ? lastResult && lastResult.data : data,\n                    loading: loading,\n                    networkStatus: queryStoreValue.networkStatus,\n                    stale: stale,\n                };\n                if (errorPolicy === 'all' && hasGraphQLErrors) {\n                    resultFromStore.errors = queryStoreValue.graphQLErrors;\n                }\n                invoke('next', resultFromStore);\n            }\n            catch (networkError) {\n                invoke('error', new ApolloError({ networkError: networkError }));\n            }\n        };\n    };\n    QueryManager.prototype.transform = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var cache = this.dataStore.getCache();\n            var transformed = cache.transformDocument(document);\n            var forLink = removeConnectionDirectiveFromDocument(cache.transformForLink(transformed));\n            var clientQuery = this.localState.clientQuery(transformed);\n            var serverQuery = this.localState.serverQuery(forLink);\n            var cacheEntry_1 = {\n                document: transformed,\n                hasClientExports: hasClientExports(transformed),\n                hasForcedResolvers: this.localState.shouldForceResolvers(transformed),\n                clientQuery: clientQuery,\n                serverQuery: serverQuery,\n                defaultVars: getDefaultValues(getOperationDefinition(transformed)),\n            };\n            var add = function (doc) {\n                if (doc && !transformCache.has(doc)) {\n                    transformCache.set(doc, cacheEntry_1);\n                }\n            };\n            add(document);\n            add(transformed);\n            add(clientQuery);\n            add(serverQuery);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return __assign(__assign({}, this.transform(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options, shouldSubscribe) {\n        if (shouldSubscribe === void 0) { shouldSubscribe = true; }\n        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'standby', 11) : invariant(options.fetchPolicy !== 'standby', 'client.watchQuery cannot be called with fetchPolicy set to \"standby\"');\n        options.variables = this.getVariables(options.query, options.variables);\n        if (typeof options.notifyOnNetworkStatusChange === 'undefined') {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var transformedOptions = __assign({}, options);\n        return new ObservableQuery({\n            queryManager: this,\n            options: transformedOptions,\n            shouldSubscribe: shouldSubscribe,\n        });\n    };\n    QueryManager.prototype.query = function (options) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(options.query, 12) : invariant(options.query, 'query option is required. You must specify your GraphQL document ' +\n            'in the query option.');\n        process.env.NODE_ENV === \"production\" ? invariant(options.query.kind === 'Document', 13) : invariant(options.query.kind === 'Document', 'You must wrap the query string in a \"gql\" tag.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.returnPartialData, 14) : invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.pollInterval, 15) : invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.');\n        return new Promise(function (resolve, reject) {\n            var watchedQuery = _this.watchQuery(options, false);\n            _this.fetchQueryRejectFns.set(\"query:\" + watchedQuery.queryId, reject);\n            watchedQuery\n                .result()\n                .then(resolve, reject)\n                .then(function () {\n                return _this.fetchQueryRejectFns.delete(\"query:\" + watchedQuery.queryId);\n            });\n        });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.idCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        this.stopPollingQuery(queryId);\n        this.queryStore.stopQuery(queryId);\n        this.invalidate(queryId);\n    };\n    QueryManager.prototype.addQueryListener = function (queryId, listener) {\n        this.setQuery(queryId, function (_a) {\n            var listeners = _a.listeners;\n            listeners.add(listener);\n            return { invalidated: false };\n        });\n    };\n    QueryManager.prototype.updateQueryWatch = function (queryId, document, options) {\n        var _this = this;\n        var cancel = this.getQuery(queryId).cancel;\n        if (cancel)\n            cancel();\n        var previousResult = function () {\n            var previousResult = null;\n            var observableQuery = _this.getQuery(queryId).observableQuery;\n            if (observableQuery) {\n                var lastResult = observableQuery.getLastResult();\n                if (lastResult) {\n                    previousResult = lastResult.data;\n                }\n            }\n            return previousResult;\n        };\n        return this.dataStore.getCache().watch({\n            query: document,\n            variables: options.variables,\n            optimistic: true,\n            previousResult: previousResult,\n            callback: function (newData) {\n                _this.setQuery(queryId, function () { return ({ invalidated: true, newData: newData }); });\n            },\n        });\n    };\n    QueryManager.prototype.addObservableQuery = function (queryId, observableQuery) {\n        this.setQuery(queryId, function () { return ({ observableQuery: observableQuery }); });\n    };\n    QueryManager.prototype.removeObservableQuery = function (queryId) {\n        var cancel = this.getQuery(queryId).cancel;\n        this.setQuery(queryId, function () { return ({ observableQuery: null }); });\n        if (cancel)\n            cancel();\n    };\n    QueryManager.prototype.clearStore = function () {\n        this.fetchQueryRejectFns.forEach(function (reject) {\n            reject(process.env.NODE_ENV === \"production\" ? new InvariantError(16) : new InvariantError('Store reset while query was in flight (not completed in link chain)'));\n        });\n        var resetIds = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery)\n                resetIds.push(queryId);\n        });\n        this.queryStore.reset(resetIds);\n        this.mutationStore.reset();\n        return this.dataStore.reset();\n    };\n    QueryManager.prototype.resetStore = function () {\n        var _this = this;\n        return this.clearStore().then(function () {\n            return _this.reFetchObservableQueries();\n        });\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery) {\n                var fetchPolicy = observableQuery.options.fetchPolicy;\n                observableQuery.resetLastResults();\n                if (fetchPolicy !== 'cache-only' &&\n                    (includeStandby || fetchPolicy !== 'standby')) {\n                    observableQueryPromises.push(observableQuery.refetch());\n                }\n                _this.setQuery(queryId, function () { return ({ newData: null }); });\n                _this.invalidate(queryId);\n            }\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.observeQuery = function (queryId, options, observer) {\n        this.addQueryListener(queryId, this.queryListenerForObserver(queryId, options, observer));\n        return this.fetchQuery(queryId, options);\n    };\n    QueryManager.prototype.startQuery = function (queryId, options, listener) {\n        process.env.NODE_ENV === \"production\" || invariant.warn(\"The QueryManager.startQuery method has been deprecated\");\n        this.addQueryListener(queryId, listener);\n        this.fetchQuery(queryId, options)\n            .catch(function () { return undefined; });\n        return queryId;\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (_a) {\n        var _this = this;\n        var query = _a.query, fetchPolicy = _a.fetchPolicy, variables = _a.variables;\n        query = this.transform(query).document;\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, {}, variables, false).map(function (result) {\n                if (!fetchPolicy || fetchPolicy !== 'no-cache') {\n                    _this.dataStore.markSubscriptionResult(result, query, variables);\n                    _this.broadcastQueries();\n                }\n                if (graphQLResultHasError(result)) {\n                    throw new ApolloError({\n                        graphQLErrors: result.errors,\n                    });\n                }\n                return result;\n            });\n        };\n        if (this.transform(query).hasClientExports) {\n            var observablePromise_1 = this.localState.addExportedVariables(query, variables).then(makeObservable);\n            return new Observable(function (observer) {\n                var sub = null;\n                observablePromise_1.then(function (observable) { return sub = observable.subscribe(observer); }, observer.error);\n                return function () { return sub && sub.unsubscribe(); };\n            });\n        }\n        return makeObservable(variables);\n    };\n    QueryManager.prototype.stopQuery = function (queryId) {\n        this.stopQueryNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.removeQuery(queryId);\n    };\n    QueryManager.prototype.removeQuery = function (queryId) {\n        this.fetchQueryRejectFns.delete(\"query:\" + queryId);\n        this.fetchQueryRejectFns.delete(\"fetchRequest:\" + queryId);\n        this.getQuery(queryId).subscriptions.forEach(function (x) { return x.unsubscribe(); });\n        this.queries.delete(queryId);\n    };\n    QueryManager.prototype.getCurrentQueryResult = function (observableQuery, optimistic) {\n        if (optimistic === void 0) { optimistic = true; }\n        var _a = observableQuery.options, variables = _a.variables, query = _a.query, fetchPolicy = _a.fetchPolicy, returnPartialData = _a.returnPartialData;\n        var lastResult = observableQuery.getLastResult();\n        var newData = this.getQuery(observableQuery.queryId).newData;\n        if (newData && newData.complete) {\n            return { data: newData.result, partial: false };\n        }\n        if (fetchPolicy === 'no-cache' || fetchPolicy === 'network-only') {\n            return { data: undefined, partial: false };\n        }\n        var _b = this.dataStore.getCache().diff({\n            query: query,\n            variables: variables,\n            previousResult: lastResult ? lastResult.data : undefined,\n            returnPartialData: true,\n            optimistic: optimistic,\n        }), result = _b.result, complete = _b.complete;\n        return {\n            data: (complete || returnPartialData) ? result : void 0,\n            partial: !complete,\n        };\n    };\n    QueryManager.prototype.getQueryWithPreviousResult = function (queryIdOrObservable) {\n        var observableQuery;\n        if (typeof queryIdOrObservable === 'string') {\n            var foundObserveableQuery = this.getQuery(queryIdOrObservable).observableQuery;\n            process.env.NODE_ENV === \"production\" ? invariant(foundObserveableQuery, 17) : invariant(foundObserveableQuery, \"ObservableQuery with this id doesn't exist: \" + queryIdOrObservable);\n            observableQuery = foundObserveableQuery;\n        }\n        else {\n            observableQuery = queryIdOrObservable;\n        }\n        var _a = observableQuery.options, variables = _a.variables, query = _a.query;\n        return {\n            previousResult: this.getCurrentQueryResult(observableQuery, false).data,\n            variables: variables,\n            document: query,\n        };\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        var _this = this;\n        this.onBroadcast();\n        this.queries.forEach(function (info, id) {\n            if (info.invalidated) {\n                info.listeners.forEach(function (listener) {\n                    if (listener) {\n                        listener(_this.queryStore.get(id), info.newData);\n                    }\n                });\n            }\n        });\n    };\n    QueryManager.prototype.getLocalState = function () {\n        return this.localState;\n    };\n    QueryManager.prototype.getObservableFromLink = function (query, context, variables, deduplication) {\n        var _this = this;\n        if (deduplication === void 0) { deduplication = this.queryDeduplication; }\n        var observable;\n        var serverQuery = this.transform(query).serverQuery;\n        if (serverQuery) {\n            var _a = this, inFlightLinkObservables_1 = _a.inFlightLinkObservables, link = _a.link;\n            var operation = {\n                query: serverQuery,\n                variables: variables,\n                operationName: getOperationName(serverQuery) || void 0,\n                context: this.prepareContext(__assign(__assign({}, context), { forceFetch: !deduplication })),\n            };\n            context = operation.context;\n            if (deduplication) {\n                var byVariables_1 = inFlightLinkObservables_1.get(serverQuery) || new Map();\n                inFlightLinkObservables_1.set(serverQuery, byVariables_1);\n                var varJson_1 = JSON.stringify(variables);\n                observable = byVariables_1.get(varJson_1);\n                if (!observable) {\n                    byVariables_1.set(varJson_1, observable = multiplex(execute(link, operation)));\n                    var cleanup = function () {\n                        byVariables_1.delete(varJson_1);\n                        if (!byVariables_1.size)\n                            inFlightLinkObservables_1.delete(serverQuery);\n                        cleanupSub_1.unsubscribe();\n                    };\n                    var cleanupSub_1 = observable.subscribe({\n                        next: cleanup,\n                        error: cleanup,\n                        complete: cleanup,\n                    });\n                }\n            }\n            else {\n                observable = multiplex(execute(link, operation));\n            }\n        }\n        else {\n            observable = Observable.of({ data: {} });\n            context = this.prepareContext(context);\n        }\n        var clientQuery = this.transform(query).clientQuery;\n        if (clientQuery) {\n            observable = asyncMap(observable, function (result) {\n                return _this.localState.runResolvers({\n                    document: clientQuery,\n                    remoteResult: result,\n                    context: context,\n                    variables: variables,\n                });\n            });\n        }\n        return observable;\n    };\n    QueryManager.prototype.fetchRequest = function (_a) {\n        var _this = this;\n        var requestId = _a.requestId, queryId = _a.queryId, document = _a.document, options = _a.options, fetchMoreForQueryId = _a.fetchMoreForQueryId;\n        var variables = options.variables, _b = options.errorPolicy, errorPolicy = _b === void 0 ? 'none' : _b, fetchPolicy = options.fetchPolicy;\n        var resultFromStore;\n        var errorsFromStore;\n        return new Promise(function (resolve, reject) {\n            var observable = _this.getObservableFromLink(document, options.context, variables);\n            var fqrfId = \"fetchRequest:\" + queryId;\n            _this.fetchQueryRejectFns.set(fqrfId, reject);\n            var cleanup = function () {\n                _this.fetchQueryRejectFns.delete(fqrfId);\n                _this.setQuery(queryId, function (_a) {\n                    var subscriptions = _a.subscriptions;\n                    subscriptions.delete(subscription);\n                });\n            };\n            var subscription = observable.map(function (result) {\n                if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                    _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n                    _this.queryStore.markQueryResult(queryId, result, fetchMoreForQueryId);\n                    _this.invalidate(queryId);\n                    _this.invalidate(fetchMoreForQueryId);\n                    _this.broadcastQueries();\n                }\n                if (errorPolicy === 'none' && isNonEmptyArray(result.errors)) {\n                    return reject(new ApolloError({\n                        graphQLErrors: result.errors,\n                    }));\n                }\n                if (errorPolicy === 'all') {\n                    errorsFromStore = result.errors;\n                }\n                if (fetchMoreForQueryId || fetchPolicy === 'no-cache') {\n                    resultFromStore = result.data;\n                }\n                else {\n                    var _a = _this.dataStore.getCache().diff({\n                        variables: variables,\n                        query: document,\n                        optimistic: false,\n                        returnPartialData: true,\n                    }), result_1 = _a.result, complete = _a.complete;\n                    if (complete || options.returnPartialData) {\n                        resultFromStore = result_1;\n                    }\n                }\n            }).subscribe({\n                error: function (error) {\n                    cleanup();\n                    reject(error);\n                },\n                complete: function () {\n                    cleanup();\n                    resolve({\n                        data: resultFromStore,\n                        errors: errorsFromStore,\n                        loading: false,\n                        networkStatus: NetworkStatus.ready,\n                        stale: false,\n                    });\n                },\n            });\n            _this.setQuery(queryId, function (_a) {\n                var subscriptions = _a.subscriptions;\n                subscriptions.add(subscription);\n            });\n        });\n    };\n    QueryManager.prototype.getQuery = function (queryId) {\n        return (this.queries.get(queryId) || {\n            listeners: new Set(),\n            invalidated: false,\n            document: null,\n            newData: null,\n            lastRequestId: 1,\n            observableQuery: null,\n            subscriptions: new Set(),\n        });\n    };\n    QueryManager.prototype.setQuery = function (queryId, updater) {\n        var prev = this.getQuery(queryId);\n        var newInfo = __assign(__assign({}, prev), updater(prev));\n        this.queries.set(queryId, newInfo);\n    };\n    QueryManager.prototype.invalidate = function (queryId, invalidated) {\n        if (invalidated === void 0) { invalidated = true; }\n        if (queryId) {\n            this.setQuery(queryId, function () { return ({ invalidated: invalidated }); });\n        }\n    };\n    QueryManager.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var newContext = this.localState.prepareContext(context);\n        return __assign(__assign({}, newContext), { clientAwareness: this.clientAwareness });\n    };\n    QueryManager.prototype.checkInFlight = function (queryId) {\n        var query = this.queryStore.get(queryId);\n        return (query &&\n            query.networkStatus !== NetworkStatus.ready &&\n            query.networkStatus !== NetworkStatus.error);\n    };\n    QueryManager.prototype.startPollingQuery = function (options, queryId, listener) {\n        var _this = this;\n        var pollInterval = options.pollInterval;\n        process.env.NODE_ENV === \"production\" ? invariant(pollInterval, 18) : invariant(pollInterval, 'Attempted to start a polling query without a polling interval.');\n        if (!this.ssrMode) {\n            var info = this.pollingInfoByQueryId.get(queryId);\n            if (!info) {\n                this.pollingInfoByQueryId.set(queryId, (info = {}));\n            }\n            info.interval = pollInterval;\n            info.options = __assign(__assign({}, options), { fetchPolicy: 'network-only' });\n            var maybeFetch_1 = function () {\n                var info = _this.pollingInfoByQueryId.get(queryId);\n                if (info) {\n                    if (_this.checkInFlight(queryId)) {\n                        poll_1();\n                    }\n                    else {\n                        _this.fetchQuery(queryId, info.options, FetchType.poll).then(poll_1, poll_1);\n                    }\n                }\n            };\n            var poll_1 = function () {\n                var info = _this.pollingInfoByQueryId.get(queryId);\n                if (info) {\n                    clearTimeout(info.timeout);\n                    info.timeout = setTimeout(maybeFetch_1, info.interval);\n                }\n            };\n            if (listener) {\n                this.addQueryListener(queryId, listener);\n            }\n            poll_1();\n        }\n        return queryId;\n    };\n    QueryManager.prototype.stopPollingQuery = function (queryId) {\n        this.pollingInfoByQueryId.delete(queryId);\n    };\n    return QueryManager;\n}());\n\nvar DataStore = (function () {\n    function DataStore(initialCache) {\n        this.cache = initialCache;\n    }\n    DataStore.prototype.getCache = function () {\n        return this.cache;\n    };\n    DataStore.prototype.markQueryResult = function (result, document, variables, fetchMoreForQueryId, ignoreErrors) {\n        if (ignoreErrors === void 0) { ignoreErrors = false; }\n        var writeWithErrors = !graphQLResultHasError(result);\n        if (ignoreErrors && graphQLResultHasError(result) && result.data) {\n            writeWithErrors = true;\n        }\n        if (!fetchMoreForQueryId && writeWithErrors) {\n            this.cache.write({\n                result: result.data,\n                dataId: 'ROOT_QUERY',\n                query: document,\n                variables: variables,\n            });\n        }\n    };\n    DataStore.prototype.markSubscriptionResult = function (result, document, variables) {\n        if (!graphQLResultHasError(result)) {\n            this.cache.write({\n                result: result.data,\n                dataId: 'ROOT_SUBSCRIPTION',\n                query: document,\n                variables: variables,\n            });\n        }\n    };\n    DataStore.prototype.markMutationInit = function (mutation) {\n        var _this = this;\n        if (mutation.optimisticResponse) {\n            var optimistic_1;\n            if (typeof mutation.optimisticResponse === 'function') {\n                optimistic_1 = mutation.optimisticResponse(mutation.variables);\n            }\n            else {\n                optimistic_1 = mutation.optimisticResponse;\n            }\n            this.cache.recordOptimisticTransaction(function (c) {\n                var orig = _this.cache;\n                _this.cache = c;\n                try {\n                    _this.markMutationResult({\n                        mutationId: mutation.mutationId,\n                        result: { data: optimistic_1 },\n                        document: mutation.document,\n                        variables: mutation.variables,\n                        updateQueries: mutation.updateQueries,\n                        update: mutation.update,\n                    });\n                }\n                finally {\n                    _this.cache = orig;\n                }\n            }, mutation.mutationId);\n        }\n    };\n    DataStore.prototype.markMutationResult = function (mutation) {\n        var _this = this;\n        if (!graphQLResultHasError(mutation.result)) {\n            var cacheWrites_1 = [{\n                    result: mutation.result.data,\n                    dataId: 'ROOT_MUTATION',\n                    query: mutation.document,\n                    variables: mutation.variables,\n                }];\n            var updateQueries_1 = mutation.updateQueries;\n            if (updateQueries_1) {\n                Object.keys(updateQueries_1).forEach(function (id) {\n                    var _a = updateQueries_1[id], query = _a.query, updater = _a.updater;\n                    var _b = _this.cache.diff({\n                        query: query.document,\n                        variables: query.variables,\n                        returnPartialData: true,\n                        optimistic: false,\n                    }), currentQueryResult = _b.result, complete = _b.complete;\n                    if (complete) {\n                        var nextQueryResult = tryFunctionOrLogError(function () {\n                            return updater(currentQueryResult, {\n                                mutationResult: mutation.result,\n                                queryName: getOperationName(query.document) || undefined,\n                                queryVariables: query.variables,\n                            });\n                        });\n                        if (nextQueryResult) {\n                            cacheWrites_1.push({\n                                result: nextQueryResult,\n                                dataId: 'ROOT_QUERY',\n                                query: query.document,\n                                variables: query.variables,\n                            });\n                        }\n                    }\n                });\n            }\n            this.cache.performTransaction(function (c) {\n                cacheWrites_1.forEach(function (write) { return c.write(write); });\n                var update = mutation.update;\n                if (update) {\n                    tryFunctionOrLogError(function () { return update(c, mutation.result); });\n                }\n            });\n        }\n    };\n    DataStore.prototype.markMutationComplete = function (_a) {\n        var mutationId = _a.mutationId, optimisticResponse = _a.optimisticResponse;\n        if (optimisticResponse) {\n            this.cache.removeOptimistic(mutationId);\n        }\n    };\n    DataStore.prototype.markUpdateQueryResult = function (document, variables, newResult) {\n        this.cache.write({\n            result: newResult,\n            dataId: 'ROOT_QUERY',\n            variables: variables,\n            query: document,\n        });\n    };\n    DataStore.prototype.reset = function () {\n        return this.cache.reset();\n    };\n    return DataStore;\n}());\n\nvar version = \"2.6.10\";\n\nvar hasSuggestedDevtools = false;\nvar ApolloClient = (function () {\n    function ApolloClient(options) {\n        var _this = this;\n        this.defaultOptions = {};\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        var cache = options.cache, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, connectToDevTools = options.connectToDevTools, _c = options.queryDeduplication, queryDeduplication = _c === void 0 ? true : _c, defaultOptions = options.defaultOptions, _d = options.assumeImmutableResults, assumeImmutableResults = _d === void 0 ? false : _d, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;\n        var link = options.link;\n        if (!link && resolvers) {\n            link = ApolloLink.empty();\n        }\n        if (!link || !cache) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(4) : new InvariantError(\"In order to initialize Apollo Client, you must specify 'link' and 'cache' properties in the options object.\\n\" +\n                \"These options are part of the upgrade requirements when migrating from Apollo Client 1.x to Apollo Client 2.x.\\n\" +\n                \"For more information, please visit: https://www.apollographql.com/docs/tutorial/client.html#apollo-client-setup\");\n        }\n        this.link = link;\n        this.cache = cache;\n        this.store = new DataStore(cache);\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || {};\n        this.typeDefs = typeDefs;\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        var defaultConnectToDevTools = process.env.NODE_ENV !== 'production' &&\n            typeof window !== 'undefined' &&\n            !window.__APOLLO_CLIENT__;\n        if (typeof connectToDevTools === 'undefined'\n            ? defaultConnectToDevTools\n            : connectToDevTools && typeof window !== 'undefined') {\n            window.__APOLLO_CLIENT__ = this;\n        }\n        if (!hasSuggestedDevtools && process.env.NODE_ENV !== 'production') {\n            hasSuggestedDevtools = true;\n            if (typeof window !== 'undefined' &&\n                window.document &&\n                window.top === window.self) {\n                if (typeof window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n                    if (window.navigator &&\n                        window.navigator.userAgent &&\n                        window.navigator.userAgent.indexOf('Chrome') > -1) {\n                        console.debug('Download the Apollo DevTools ' +\n                            'for a better development experience: ' +\n                            'https://chrome.google.com/webstore/detail/apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm');\n                    }\n                }\n            }\n        }\n        this.version = version;\n        this.localState = new LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager({\n            link: this.link,\n            store: this.store,\n            queryDeduplication: queryDeduplication,\n            ssrMode: ssrMode,\n            clientAwareness: {\n                name: clientAwarenessName,\n                version: clientAwarenessVersion,\n            },\n            localState: this.localState,\n            assumeImmutableResults: assumeImmutableResults,\n            onBroadcast: function () {\n                if (_this.devToolsHookCb) {\n                    _this.devToolsHookCb({\n                        action: {},\n                        state: {\n                            queries: _this.queryManager.queryStore.getStore(),\n                            mutations: _this.queryManager.mutationStore.getStore(),\n                        },\n                        dataWithOptimisticResults: _this.cache.extract(true),\n                    });\n                }\n            },\n        });\n    }\n    ApolloClient.prototype.stop = function () {\n        this.queryManager.stop();\n    };\n    ApolloClient.prototype.watchQuery = function (options) {\n        if (this.defaultOptions.watchQuery) {\n            options = __assign(__assign({}, this.defaultOptions.watchQuery), options);\n        }\n        if (this.disableNetworkFetches &&\n            (options.fetchPolicy === 'network-only' ||\n                options.fetchPolicy === 'cache-and-network')) {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.watchQuery(options);\n    };\n    ApolloClient.prototype.query = function (options) {\n        if (this.defaultOptions.query) {\n            options = __assign(__assign({}, this.defaultOptions.query), options);\n        }\n        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'cache-and-network', 5) : invariant(options.fetchPolicy !== 'cache-and-network', 'The cache-and-network fetchPolicy does not work with client.query, because ' +\n            'client.query can only return a single result. Please use client.watchQuery ' +\n            'to receive multiple results from the cache and the network, or consider ' +\n            'using a different fetchPolicy, such as cache-first or network-only.');\n        if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.query(options);\n    };\n    ApolloClient.prototype.mutate = function (options) {\n        if (this.defaultOptions.mutate) {\n            options = __assign(__assign({}, this.defaultOptions.mutate), options);\n        }\n        return this.queryManager.mutate(options);\n    };\n    ApolloClient.prototype.subscribe = function (options) {\n        return this.queryManager.startGraphQLSubscription(options);\n    };\n    ApolloClient.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readQuery(options, optimistic);\n    };\n    ApolloClient.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readFragment(options, optimistic);\n    };\n    ApolloClient.prototype.writeQuery = function (options) {\n        var result = this.cache.writeQuery(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.writeFragment = function (options) {\n        var result = this.cache.writeFragment(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.writeData = function (options) {\n        var result = this.cache.writeData(options);\n        this.queryManager.broadcastQueries();\n        return result;\n    };\n    ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n        this.devToolsHookCb = cb;\n    };\n    ApolloClient.prototype.__requestRaw = function (payload) {\n        return execute(this.link, payload);\n    };\n    ApolloClient.prototype.initQueryManager = function () {\n        process.env.NODE_ENV === \"production\" || invariant.warn('Calling the initQueryManager method is no longer necessary, ' +\n            'and it will be removed from ApolloClient in version 3.0.');\n        return this.queryManager;\n    };\n    ApolloClient.prototype.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    ApolloClient.prototype.onResetStore = function (cb) {\n        var _this = this;\n        this.resetStoreCallbacks.push(cb);\n        return function () {\n            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.onClearStore = function (cb) {\n        var _this = this;\n        this.clearStoreCallbacks.push(cb);\n        return function () {\n            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    return ApolloClient;\n}());\n\nexport default ApolloClient;\nexport { ApolloClient, ApolloError, FetchType, NetworkStatus, ObservableQuery, isApolloError };\n//# sourceMappingURL=bundle.esm.js.map\n","\"use strict\";\n\n/**\n * The default implementation for [`createUploadLink`]{@link createUploadLink}\n * `options.formDataAppendFile` that uses the standard\n * [`FormData.append`](https://developer.mozilla.org/en-US/docs/Web/API/FormData/append)\n * method.\n * @kind function\n * @name formDataAppendFile\n * @type {FormDataFileAppender}\n * @param {FormData} formData [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) instance to append the specified file to.\n * @param {string} fieldName Field name for the file.\n * @param {*} file File to append.\n * @example <caption>Ways to `import`.</caption>\n * ```js\n * import { formDataAppendFile } from \"apollo-upload-client\";\n * ```\n *\n * ```js\n * import formDataAppendFile from \"apollo-upload-client/public/formDataAppendFile.js\";\n * ```\n * @example <caption>Ways to `require`.</caption>\n * ```js\n * const { formDataAppendFile } = require(\"apollo-upload-client\");\n * ```\n *\n * ```js\n * const formDataAppendFile = require(\"apollo-upload-client/public/formDataAppendFile.js\");\n * ```\n */\nmodule.exports = function formDataAppendFile(formData, fieldName, file) {\n  formData.append(fieldName, file, file.name);\n};\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","/* global window */\nimport ponyfill from './ponyfill.js';\n\nvar root;\n\nif (typeof self !== 'undefined') {\n  root = self;\n} else if (typeof window !== 'undefined') {\n  root = window;\n} else if (typeof global !== 'undefined') {\n  root = global;\n} else if (typeof module !== 'undefined') {\n  root = module;\n} else {\n  root = Function('return this')();\n}\n\nvar result = ponyfill(root);\nexport default result;\n","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","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","export default function symbolObservablePonyfill(root) {\n\tvar result;\n\tvar Symbol = root.Symbol;\n\n\tif (typeof Symbol === 'function') {\n\t\tif (Symbol.observable) {\n\t\t\tresult = Symbol.observable;\n\t\t} else {\n\t\t\tresult = Symbol('observable');\n\t\t\tSymbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n"],"sourceRoot":""}