{"version":3,"sources":["../../../node_modules/apollo-cache/lib/bundle.esm.js","../../../node_modules/apollo-cache-inmemory/lib/bundle.esm.js","../../../node_modules/apollo-link-batch/lib/bundle.esm.js","../../../node_modules/apollo-link-batch-http/lib/bundle.esm.js","../../../node_modules/@reach/visually-hidden/es/index.js","../../../node_modules/apollo-link/lib/bundle.esm.js","../../../node_modules/@wry/equality/lib/equality.esm.js","../../../node_modules/apollo-link-http-common/lib/bundle.esm.js","../../../node_modules/apollo-link-http/lib/bundle.esm.js","../../../node_modules/apollo-link-error/lib/bundle.esm.js","../../../node_modules/apollo-link-retry/lib/bundle.esm.js","../../../node_modules/babel-plugin-universal-import/universalImport.js","../../../node_modules/beaver-logger/index.js","../../../node_modules/beaver-logger/dist/beaver-logger.js","../../../node_modules/apollo-utilities/lib/bundle.esm.js","../../../node_modules/apollo-client/bundle.esm.js","../../../node_modules/classnames/index.js"],"names":["queryFromPojo","obj","kind","definitions","operation","name","value","selectionSet","selectionSetFromObj","Array","isArray","selections","Object","keys","forEach","key","field","undefined","push","Cache","justTypenameQuery","variableDefinitions","directives","alias","arguments","ApolloCache","prototype","transformDocument","document","transformForLink","readQuery","options","optimistic","this","read","query","variables","readFragment","fragment","fragmentName","rootId","id","writeQuery","write","dataId","result","data","writeFragment","writeData","_a","typename","typenameResult","e","__typename","dataToWrite","assign","typeCondition","haveWarned","shouldWarn","answer","HeuristicFragmentMatcher","ensureReady","Promise","resolve","canBypassInit","match","idValue","context","store","get","isRootQuery","hasOwn","IntrospectionFragmentMatcher","introspectionQueryResultData","possibleTypesMap","parseIntrospectionResult","isReady","bind","implementingTypes","indexOf","introspectionResultData","typeMap","__schema","types","type","possibleTypes","map","implementingType","hasOwnProperty","DepTrackingCache","_this","create","depend","disposable","makeCacheKey","toObject","set","dirty","delete","call","clear","replace","newData","defaultNormalizedCacheFactory","seed","StoreReader","_b","_c","cacheKeyRoot","_d","freezeResults","_e","executeStoreQuery","executeSelectionSet","executeSubSelectedArray","rootValue","contextValue","variableValues","fragmentMatcher","lookup","JSON","stringify","execContext","array","readQueryFromStore","diffQueryAgainstStore","returnPartialData","previousResult","fragmentMatcherFunction","config","queryDefinition","dataIdFromObject","cacheRedirects","execResult","generated","hasMissingFields","missing","length","info","tolerable","complete","defaultFragmentMatcher","mainDefinition","fragments","fragmentMap","finalResult","objectsToMerge","object","handleMissing","apply","selection","fieldResult","executeField","fragmentExecResult","readStoreResult","fieldName","args","resultKey","storeKeyName","fieldValue","resolver","getCacheKey","storeObj","json","readStoreResolver","combineExecResults","assertSelectionSetForIdValue","execResults","_i","pop","childResult","item","ObjectCache","_super","WriteError","Error","StoreWriter","writeQueryToStore","writeResultToStore","operationDefinition","writeSelectionSetToStore","processedData","error","enhancedError","message","stack","enhanceErrorWithDocument","resultFieldKey","writeFieldToStore","isDefered","isClient","some","directive","matches","fakeContext","storeValue","storeObject","storeFieldName","generatedId","processArrayValue","valueDataId","isGeneratedId","semanticId","isDataProcessed","escapedId","hadTypename","hasTypename","typenameChanged","mergeWithGenerated","index","itemDataId","generatedKey","realKey","cache","real","madeChanges","realValue","newRealValue","defaultConfig","defaultDataIdFromObject","addTypename","resultCaching","_id","hasOwn$1","OptimisticCacheLayer","optimisticId","parent","transaction","InMemoryCache","watches","Set","typenameDocumentCache","Map","silenceBroadcast","customResolvers","cacheResolvers","optimisticData","storeWriter","storeReader","maybeBroadcastWatch","c","restore","extract","broadcastWatches","diff","watch","add","evict","reset","removeOptimistic","idToRemove","toReapply","removedCount","layer","layer_1","performTransaction","recordOptimisticTransaction","callback","OperationBatcher","batchInterval","batchMax","batchHandler","batchKey","queuedRequests","enqueueRequest","request","requestCopy","queued","observable","observer","has","next","scheduleQueueConsumption","consumeQueue","requestKey","requests","queuedRequest","forwards","forward","observables","nexts","errors","completes","batchableRequest","batchedObservable","of","onError","rejecters","subscribe","results","setTimeout","BatchLink","fetchParams","batcher","BatchHttpLink","uri","fetcher","fetch","includeExtensions","requestOptions","linkConfig","http","fetchOptions","credentials","headers","getContext","contextConfig","operations","chosenURI","clientAwarenessHeaders","clientAwareness","name_1","version","controller","optsAndBody","loadedBody","body","method","parseError","signal","_controller","then","response","setContext","catch","err","abort","_extends","target","i","source","style","border","clip","height","width","margin","padding","overflow","position","whiteSpace","wordWrap","VisuallyHidden","props","createElement","displayName","LinkError","link","isTerminating","toPromise","completed","reject","makePromise","fromPromise","promise","fromError","errorValue","createOperation","starting","defineProperty","enumerable","operationName","getKey","passthrough","op","toLink","handler","ApolloLink","empty","from","links","reduce","x","y","concat","split","test","left","right","leftLink","rightLink","first","second","firstLink","nextLink","execute","transformedOperation","extensions","transformOperation","OPERATION_FIELDS","validateOperation","toString","previousComparisons","equal","a","b","check","aTag","previouslyCompared","aKeys","bKeys","keyCount","k","size","aIterator","entries","isMap","done","aKey","aValue","bSet","fallbackHttpConfig","includeQuery","accept","throwServerError","statusCode","status","parseAndCheckHttpResponse","text","bodyText","parse","checkFetcher","window","createSignalIfSupported","AbortController","selectHttpOptionsAndBody","fallbackConfig","configs","serializeFetchParameter","p","label","serialized","selectURI","fallbackURI","contextURI","createHttpLink","linkOptions","useGETForQueries","contextHeaders","d","queryParams","addQueryParam","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","newURI","join","rewriteURIForGET","HttpLink","opts","errorHandler","sub","retriedSub","retriedResult","graphQLErrors","networkError","unsubscribe","ErrorLink","RetryableOperation","delayFor","retryIf","retryCount","values","canceled","observers","currentSubscription","onNext","onComplete","sent","scheduleRetry","every","o","cancel","start","try","clearTimeout","timerId","delay","RetryLink","attempts","delayOptions","initial","jitter","max","Infinity","baseDelay","count","Math","min","pow","random","buildDelayFunction","retryOptions","buildRetryFunction","retryable","module","exports","makeThennable","load","cb","res","isSet","universal","isWebpack","__webpack_require__","require","setHasBabelPlugin","setHasPlugin","default","factory","modules","installedModules","moduleId","loaded","m","_interface","INTERFACE","__esModule","newObj","_interopRequireWildcard","_logger","_init","_transitions","_builders","_config","track","flush","tracking","buffer","getTransport","transport","setTransport","newTransport","print","immediateFlush","log","prefix","debug","event","payload","warn","_track","_flush","_util","ajax","level","console","logLevel","LOG_LEVEL","logLevels","isIE","warning","_ref","_ref$fireAndForget","fireAndForget","hasBuffer","hasTracking","meta","_iterator","metaBuilders","_isArray","Symbol","iterator","_ref2","builder","extend","_iterator2","headerBuilders","_isArray2","_i2","_ref3","_builder","events","req","promiseDebounce","debounceInterval","enqueue","autoLog","timestamp","Date","now","_iterator3","payloadBuilders","_isArray3","_i3","_ref4","silent","sizeLimit","_iterator4","trackingBuilders","_isArray4","_i4","_ref5","dest","src","over","isSameProtocol","isSameDomain","url","_src","ZalgoPromise","XRequest","XMLHttpRequest","ActiveXObject","XDomainRequest","open","toUpperCase","setRequestHeader","headerName","onreadystatechange","readyState","send","interval","debounce","timeout","rejector","onWindowReady","addEventListener","safeInterval","time","loop","uniqueID","chars","charAt","floor","Boolean","documentMode","location","protocol","host","_promise","_createClass","defineProperties","descriptor","configurable","writable","Constructor","protoProps","staticProps","_utils","_exceptions","instance","TypeError","_classCallCheck","resolved","rejected","errorHandled","handlers","_result","_error","isAsync","startActive","endActive","isPromise","dispatch","_this2","_err","dispatchPossiblyUnhandledError","_this3","dispatching","_loop","_handlers$i","onSuccess","onFinally","_this4","asyncReject","promises","_loop2","prom","all","items","onPossiblyUnhandledException","_delay","awaitActive","Window","constructor","_toString","dispatchedErrors","j","possiblyUnhandledPromiseHandlers","splice","activeCount","flushActive","Zalgo","flushPromise","addPayloadBuilder","addMetaBuilder","addTrackingBuilder","addHeaderBuilder","initial_state_name","flushInterval","heartbeat","heartbeatConsoleLog","heartbeatInterval","heartbeatTooBusy","heartbeatTooBusyThreshold","logUnload","logPerformance","init","conf","initiated","_performance","initPerformance","initHeartBeat","setInterval","beaverLogQueue","reqTimer","clientTimer","reqStartElapsed","heartBeatTimer","timer","heartbeatCount","heartbeatMaxThreshold","elapsed","lag","heartbeatPayload","noConsole","enablePerformance","client_elapsed","req_elapsed","timing","parseInt","performance","offset","connectEnd","navigationStart","startTime","memory","navigation","getEntries","resource","initiatorType","abs","startTransition","endTransition","transition","toState","windowID","pageID","currentState","currentTime","elapsedTime","transitionName","duration","transition_time","state","valueToObjectRepresentation","argObj","isIntValue","isFloatValue","Number","isBooleanValue","isStringValue","isObjectValue","nestedArgObj_1","fields","isVariable","variableValue","isListValue","listValue","nestedArgArrayObj","isEnumValue","isNullValue","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","filterKeys","sort","queryArgs_1","filteredArgs_1","completeFieldName","stringifiedArgs","argumentsObjectFromField","argObj_1","resultKeyNameFromField","isField","isInlineFragment","isIdValue","idObject","toIdValue","idConfig","isJsonValue","jsonObject","getDirectiveInfoFromField","directiveObj_1","shouldInclude","filter","isInclusionDirective","directiveArguments","ifArgument","ifValue","evaledValue","hasDirectives","names","doc","Directive","node","getDirectiveNames","hasClientExports","getFragmentQueryDocument","actualFragmentName","definition","sources","checkDocument","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","queryDef","getMainDefinition","queryDoc","fragmentDefinition","createFragmentMap","symTable","getDefaultValues","defaultValues","defaultValue","variable","defaultValueObj","filterInPlace","elem","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","fragmentDef","getFragmentDefinition","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","enter","_key","Field","remove","arg","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","v","argMatcher","argument","aConfig","getArgumentMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","removeArgumentsFromDocument","fs","def","FragmentDefinition","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","lastIndexOf","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","allFragments","buildQueryFromSelectionSet","removeClientSetsFromDocument","canUseWeakMap","WeakMap","navigator","product","cloneDeep","cloneDeepHelper","val","seen","copy_1","slice","child","copy_2","getPrototypeOf","isEnv","env","process","isProduction","isTest","tryFunctionOrLogError","f","graphQLResultHasError","deepFreeze","freeze","getOwnPropertyNames","prop","isFrozen","maybeDeepFreeze","mergeDeep","mergeDeepArray","pastCopies","shallowCopyForMerge","mergeHelper","isObject","isExtensible","sourceKey","sourceValue","targetValue","__proto__","NetworkStatus","isNetworkRequestInFlight","networkStatus","Observable","isNonEmptyArray","FetchType","ApolloError","errorMessage","extraInfo","graphQLError","generateErrorMessage","ObservableQuery","queryManager","shouldSubscribe","onSubscribe","subscriptions","isTornDown","queryId","generateQueryId","opDef","queryName","removeQuery","subscription","currentResult","getCurrentResult","lastResult","lastError","loading","policy","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","stopQuery","subscribeToMore","startGraphQLSubscription","subscriptionData","previous","setOptions","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","removeObservableQuery","observersWithMethod","obs","obsQuery","MutationStore","getStore","mutationId","initMutation","mutation","markMutationError","markMutationResult","QueryStore","initQuery","previousQuery","isSetVariables","storePreviousVariables","isPoll","poll","isRefetch","metadata","fetchMoreForQueryId","markQueryResult","markQueryError","markQueryResultClient","observableQueryIds","LocalState","client","resolvers","addResolvers","setFragmentMatcher","resolverGroup","setResolvers","getResolvers","runResolvers","remoteResult","onlyRunForcedResolvers","resolveDocument","localResult","getFragmentMatcher","clientQuery","prepareContext","buildRootValueFromCache","exportedVariables","shouldForceResolvers","forceResolvers","definitionOperation","defaultOperationType","str","resolveSelectionSet","resultsToMerge","resolveField","fragmentResult","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","resolveSubSelectedArray","multiplex","inner","QueryManager","queryDeduplication","onBroadcast","ssrMode","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","networkResult","updateQueryWatch","lastRequestId","invalidated","invalidate","fetchRequest","getQuery","hasForcedResolvers","queryListenerForObserver","invoke","networkStatusChanged","shouldNotifyIfLoading","notifyOnNetworkStatusChange","hasGraphQLErrors","isMissing","errorStatusChanged","diffResult","resultFromStore","transformed","forLink","cacheEntry_1","defaultVars","watchQuery","transformedOptions","watchedQuery","String","stopQueryInStore","stopQueryInStoreNoBroadcast","addQueryListener","listener","listeners","clearStore","resetIds","resetStore","reFetchObservableQueries","includeStandby","observableQueryPromises","startQuery","makeObservable","markSubscriptionResult","observablePromise_1","queryIdOrObservable","foundObserveableQuery","deduplication","inFlightLinkObservables_1","forceFetch","byVariables_1","varJson_1","cleanup","cleanupSub_1","_next","_error2","_complete","activeNextCount","asyncMap","errorsFromStore","fqrfId","result_1","_error3","prev","newInfo","newContext","checkInFlight","maybeFetch_1","poll_1","DataStore","initialCache","ignoreErrors","writeWithErrors","optimistic_1","orig","cacheWrites_1","updateQueries_1","currentQueryResult","nextQueryResult","mutationResult","queryVariables","ApolloClient","defaultOptions","resetStoreCallbacks","clearStoreCallbacks","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","disableNetworkFetches","__APOLLO_CLIENT__","devToolsHookCb","action","mutations","dataWithOptimisticResults","__actionHookForDevTools","__requestRaw","initQueryManager","fn","onResetStore","onClearStore","serializedState","setLocalStateFragmentMatcher","classNames","classes","argType"],"mappings":"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","file":"js/vendors~main~4134d62c.e975e253.js","sourcesContent":["import { getFragmentQueryDocument } from 'apollo-utilities';\n\nfunction queryFromPojo(obj) {\n  var op = {\n    kind: 'OperationDefinition',\n    operation: 'query',\n    name: {\n      kind: 'Name',\n      value: 'GeneratedClientQuery'\n    },\n    selectionSet: selectionSetFromObj(obj)\n  };\n  var out = {\n    kind: 'Document',\n    definitions: [op]\n  };\n  return out;\n}\n\nfunction fragmentFromPojo(obj, typename) {\n  var frag = {\n    kind: 'FragmentDefinition',\n    typeCondition: {\n      kind: 'NamedType',\n      name: {\n        kind: 'Name',\n        value: typename || '__FakeType'\n      }\n    },\n    name: {\n      kind: 'Name',\n      value: 'GeneratedClientQuery'\n    },\n    selectionSet: selectionSetFromObj(obj)\n  };\n  var out = {\n    kind: 'Document',\n    definitions: [frag]\n  };\n  return out;\n}\n\nfunction selectionSetFromObj(obj) {\n  if (typeof obj === 'number' || typeof obj === 'boolean' || typeof obj === 'string' || typeof obj === 'undefined' || obj === null) {\n    return null;\n  }\n\n  if (Array.isArray(obj)) {\n    return selectionSetFromObj(obj[0]);\n  }\n\n  var selections = [];\n  Object.keys(obj).forEach(function (key) {\n    var nestedSelSet = selectionSetFromObj(obj[key]);\n    var field = {\n      kind: 'Field',\n      name: {\n        kind: 'Name',\n        value: key\n      },\n      selectionSet: nestedSelSet || undefined\n    };\n    selections.push(field);\n  });\n  var selectionSet = {\n    kind: 'SelectionSet',\n    selections: selections\n  };\n  return selectionSet;\n}\n\nvar justTypenameQuery = {\n  kind: 'Document',\n  definitions: [{\n    kind: 'OperationDefinition',\n    operation: 'query',\n    name: null,\n    variableDefinitions: null,\n    directives: [],\n    selectionSet: {\n      kind: 'SelectionSet',\n      selections: [{\n        kind: 'Field',\n        alias: null,\n        name: {\n          kind: 'Name',\n          value: '__typename'\n        },\n        arguments: [],\n        directives: [],\n        selectionSet: null\n      }]\n    }\n  }]\n};\n\nvar ApolloCache = function () {\n  function ApolloCache() {}\n\n  ApolloCache.prototype.transformDocument = function (document) {\n    return document;\n  };\n\n  ApolloCache.prototype.transformForLink = function (document) {\n    return document;\n  };\n\n  ApolloCache.prototype.readQuery = function (options, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return this.read({\n      query: options.query,\n      variables: options.variables,\n      optimistic: optimistic\n    });\n  };\n\n  ApolloCache.prototype.readFragment = function (options, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return this.read({\n      query: getFragmentQueryDocument(options.fragment, options.fragmentName),\n      variables: options.variables,\n      rootId: options.id,\n      optimistic: optimistic\n    });\n  };\n\n  ApolloCache.prototype.writeQuery = function (options) {\n    this.write({\n      dataId: 'ROOT_QUERY',\n      result: options.data,\n      query: options.query,\n      variables: options.variables\n    });\n  };\n\n  ApolloCache.prototype.writeFragment = function (options) {\n    this.write({\n      dataId: options.id,\n      result: options.data,\n      variables: options.variables,\n      query: getFragmentQueryDocument(options.fragment, options.fragmentName)\n    });\n  };\n\n  ApolloCache.prototype.writeData = function (_a) {\n    var id = _a.id,\n        data = _a.data;\n\n    if (typeof id !== 'undefined') {\n      var typenameResult = null;\n\n      try {\n        typenameResult = this.read({\n          rootId: id,\n          optimistic: false,\n          query: justTypenameQuery\n        });\n      } catch (e) {}\n\n      var __typename = typenameResult && typenameResult.__typename || '__ClientData';\n\n      var dataToWrite = Object.assign({\n        __typename: __typename\n      }, data);\n      this.writeFragment({\n        id: id,\n        fragment: fragmentFromPojo(dataToWrite, __typename),\n        data: dataToWrite\n      });\n    } else {\n      this.writeQuery({\n        query: queryFromPojo(data),\n        data: data\n      });\n    }\n  };\n\n  return ApolloCache;\n}();\n\nvar Cache;\n\n(function (Cache) {})(Cache || (Cache = {}));\n\nexport { ApolloCache, Cache };","import { __assign, __extends } from 'tslib';\nimport { ApolloCache } from 'apollo-cache';\nimport { isTest, getQueryDefinition, assign, getDefaultValues, isEqual, getMainDefinition, getFragmentDefinitions, createFragmentMap, shouldInclude, isField, resultKeyNameFromField, isInlineFragment, mergeDeepArray, argumentsObjectFromField, getDirectiveInfoFromField, maybeDeepFreeze, isIdValue, getStoreKeyName, toIdValue, isJsonValue, canUseWeakMap, getOperationDefinition, isProduction, storeKeyNameFromField, addTypenameToDocument } from 'apollo-utilities';\nimport { wrap, KeyTrie } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\nvar haveWarned = false;\n\nfunction shouldWarn() {\n  var answer = !haveWarned;\n\n  if (!isTest()) {\n    haveWarned = true;\n  }\n\n  return answer;\n}\n\nvar HeuristicFragmentMatcher = function () {\n  function HeuristicFragmentMatcher() {}\n\n  HeuristicFragmentMatcher.prototype.ensureReady = function () {\n    return Promise.resolve();\n  };\n\n  HeuristicFragmentMatcher.prototype.canBypassInit = function () {\n    return true;\n  };\n\n  HeuristicFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n    var obj = context.store.get(idValue.id);\n    var isRootQuery = idValue.id === 'ROOT_QUERY';\n\n    if (!obj) {\n      return isRootQuery;\n    }\n\n    var _a = obj.__typename,\n        __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n\n    if (!__typename) {\n      if (shouldWarn()) {\n        process.env.NODE_ENV === \"production\" || invariant.warn(\"You're using fragments in your queries, but either don't have the addTypename:\\n  true option set in Apollo Client, or you are trying to write a fragment to the store without the __typename.\\n   Please turn on the addTypename option and include __typename when writing fragments so that Apollo Client\\n   can accurately match fragments.\");\n        process.env.NODE_ENV === \"production\" || invariant.warn('Could not find __typename on Fragment ', typeCondition, obj);\n        process.env.NODE_ENV === \"production\" || invariant.warn(\"DEPRECATION WARNING: using fragments without __typename is unsupported behavior \" + \"and will be removed in future versions of Apollo client. You should fix this and set addTypename to true now.\");\n      }\n\n      return 'heuristic';\n    }\n\n    if (__typename === typeCondition) {\n      return true;\n    }\n\n    if (shouldWarn()) {\n      process.env.NODE_ENV === \"production\" || invariant.error('You are using the simple (heuristic) fragment matcher, but your ' + 'queries contain union or interface types. Apollo Client will not be ' + 'able to accurately map fragments. To make this error go away, use ' + 'the `IntrospectionFragmentMatcher` as described in the docs: ' + 'https://www.apollographql.com/docs/react/advanced/fragments.html#fragment-matcher');\n    }\n\n    return 'heuristic';\n  };\n\n  return HeuristicFragmentMatcher;\n}();\n\nvar IntrospectionFragmentMatcher = function () {\n  function IntrospectionFragmentMatcher(options) {\n    if (options && options.introspectionQueryResultData) {\n      this.possibleTypesMap = this.parseIntrospectionResult(options.introspectionQueryResultData);\n      this.isReady = true;\n    } else {\n      this.isReady = false;\n    }\n\n    this.match = this.match.bind(this);\n  }\n\n  IntrospectionFragmentMatcher.prototype.match = function (idValue, typeCondition, context) {\n    process.env.NODE_ENV === \"production\" ? invariant(this.isReady, 1) : invariant(this.isReady, 'FragmentMatcher.match() was called before FragmentMatcher.init()');\n    var obj = context.store.get(idValue.id);\n    var isRootQuery = idValue.id === 'ROOT_QUERY';\n\n    if (!obj) {\n      return isRootQuery;\n    }\n\n    var _a = obj.__typename,\n        __typename = _a === void 0 ? isRootQuery && 'Query' : _a;\n\n    process.env.NODE_ENV === \"production\" ? invariant(__typename, 2) : invariant(__typename, \"Cannot match fragment because __typename property is missing: \" + JSON.stringify(obj));\n\n    if (__typename === typeCondition) {\n      return true;\n    }\n\n    var implementingTypes = this.possibleTypesMap[typeCondition];\n\n    if (__typename && implementingTypes && implementingTypes.indexOf(__typename) > -1) {\n      return true;\n    }\n\n    return false;\n  };\n\n  IntrospectionFragmentMatcher.prototype.parseIntrospectionResult = function (introspectionResultData) {\n    var typeMap = {};\n\n    introspectionResultData.__schema.types.forEach(function (type) {\n      if (type.kind === 'UNION' || type.kind === 'INTERFACE') {\n        typeMap[type.name] = type.possibleTypes.map(function (implementingType) {\n          return implementingType.name;\n        });\n      }\n    });\n\n    return typeMap;\n  };\n\n  return IntrospectionFragmentMatcher;\n}();\n\nvar hasOwn = Object.prototype.hasOwnProperty;\n\nvar DepTrackingCache = function () {\n  function DepTrackingCache(data) {\n    var _this = this;\n\n    if (data === void 0) {\n      data = Object.create(null);\n    }\n\n    this.data = data;\n    this.depend = wrap(function (dataId) {\n      return _this.data[dataId];\n    }, {\n      disposable: true,\n      makeCacheKey: function makeCacheKey(dataId) {\n        return dataId;\n      }\n    });\n  }\n\n  DepTrackingCache.prototype.toObject = function () {\n    return this.data;\n  };\n\n  DepTrackingCache.prototype.get = function (dataId) {\n    this.depend(dataId);\n    return this.data[dataId];\n  };\n\n  DepTrackingCache.prototype.set = function (dataId, value) {\n    var oldValue = this.data[dataId];\n\n    if (value !== oldValue) {\n      this.data[dataId] = value;\n      this.depend.dirty(dataId);\n    }\n  };\n\n  DepTrackingCache.prototype.delete = function (dataId) {\n    if (hasOwn.call(this.data, dataId)) {\n      delete this.data[dataId];\n      this.depend.dirty(dataId);\n    }\n  };\n\n  DepTrackingCache.prototype.clear = function () {\n    this.replace(null);\n  };\n\n  DepTrackingCache.prototype.replace = function (newData) {\n    var _this = this;\n\n    if (newData) {\n      Object.keys(newData).forEach(function (dataId) {\n        _this.set(dataId, newData[dataId]);\n      });\n      Object.keys(this.data).forEach(function (dataId) {\n        if (!hasOwn.call(newData, dataId)) {\n          _this.delete(dataId);\n        }\n      });\n    } else {\n      Object.keys(this.data).forEach(function (dataId) {\n        _this.delete(dataId);\n      });\n    }\n  };\n\n  return DepTrackingCache;\n}();\n\nfunction defaultNormalizedCacheFactory(seed) {\n  return new DepTrackingCache(seed);\n}\n\nvar StoreReader = function () {\n  function StoreReader(_a) {\n    var _this = this;\n\n    var _b = _a === void 0 ? {} : _a,\n        _c = _b.cacheKeyRoot,\n        cacheKeyRoot = _c === void 0 ? new KeyTrie(canUseWeakMap) : _c,\n        _d = _b.freezeResults,\n        freezeResults = _d === void 0 ? false : _d;\n\n    var _e = this,\n        executeStoreQuery = _e.executeStoreQuery,\n        executeSelectionSet = _e.executeSelectionSet,\n        executeSubSelectedArray = _e.executeSubSelectedArray;\n\n    this.freezeResults = freezeResults;\n    this.executeStoreQuery = wrap(function (options) {\n      return executeStoreQuery.call(_this, options);\n    }, {\n      makeCacheKey: function makeCacheKey(_a) {\n        var query = _a.query,\n            rootValue = _a.rootValue,\n            contextValue = _a.contextValue,\n            variableValues = _a.variableValues,\n            fragmentMatcher = _a.fragmentMatcher;\n\n        if (contextValue.store instanceof DepTrackingCache) {\n          return cacheKeyRoot.lookup(contextValue.store, query, fragmentMatcher, JSON.stringify(variableValues), rootValue.id);\n        }\n      }\n    });\n    this.executeSelectionSet = wrap(function (options) {\n      return executeSelectionSet.call(_this, options);\n    }, {\n      makeCacheKey: function makeCacheKey(_a) {\n        var selectionSet = _a.selectionSet,\n            rootValue = _a.rootValue,\n            execContext = _a.execContext;\n\n        if (execContext.contextValue.store instanceof DepTrackingCache) {\n          return cacheKeyRoot.lookup(execContext.contextValue.store, selectionSet, execContext.fragmentMatcher, JSON.stringify(execContext.variableValues), rootValue.id);\n        }\n      }\n    });\n    this.executeSubSelectedArray = wrap(function (options) {\n      return executeSubSelectedArray.call(_this, options);\n    }, {\n      makeCacheKey: function makeCacheKey(_a) {\n        var field = _a.field,\n            array = _a.array,\n            execContext = _a.execContext;\n\n        if (execContext.contextValue.store instanceof DepTrackingCache) {\n          return cacheKeyRoot.lookup(execContext.contextValue.store, field, array, JSON.stringify(execContext.variableValues));\n        }\n      }\n    });\n  }\n\n  StoreReader.prototype.readQueryFromStore = function (options) {\n    return this.diffQueryAgainstStore(__assign(__assign({}, options), {\n      returnPartialData: false\n    })).result;\n  };\n\n  StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n    var store = _a.store,\n        query = _a.query,\n        variables = _a.variables,\n        previousResult = _a.previousResult,\n        _b = _a.returnPartialData,\n        returnPartialData = _b === void 0 ? true : _b,\n        _c = _a.rootId,\n        rootId = _c === void 0 ? 'ROOT_QUERY' : _c,\n        fragmentMatcherFunction = _a.fragmentMatcherFunction,\n        config = _a.config;\n    var queryDefinition = getQueryDefinition(query);\n    variables = assign({}, getDefaultValues(queryDefinition), variables);\n    var context = {\n      store: store,\n      dataIdFromObject: config && config.dataIdFromObject,\n      cacheRedirects: config && config.cacheRedirects || {}\n    };\n    var execResult = this.executeStoreQuery({\n      query: query,\n      rootValue: {\n        type: 'id',\n        id: rootId,\n        generated: true,\n        typename: 'Query'\n      },\n      contextValue: context,\n      variableValues: variables,\n      fragmentMatcher: fragmentMatcherFunction\n    });\n    var hasMissingFields = execResult.missing && execResult.missing.length > 0;\n\n    if (hasMissingFields && !returnPartialData) {\n      execResult.missing.forEach(function (info) {\n        if (info.tolerable) return;\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError(\"Can't find field \" + info.fieldName + \" on object \" + JSON.stringify(info.object, null, 2) + \".\");\n      });\n    }\n\n    if (previousResult) {\n      if (isEqual(previousResult, execResult.result)) {\n        execResult.result = previousResult;\n      }\n    }\n\n    return {\n      result: execResult.result,\n      complete: !hasMissingFields\n    };\n  };\n\n  StoreReader.prototype.executeStoreQuery = function (_a) {\n    var query = _a.query,\n        rootValue = _a.rootValue,\n        contextValue = _a.contextValue,\n        variableValues = _a.variableValues,\n        _b = _a.fragmentMatcher,\n        fragmentMatcher = _b === void 0 ? defaultFragmentMatcher : _b;\n    var mainDefinition = getMainDefinition(query);\n    var fragments = getFragmentDefinitions(query);\n    var fragmentMap = createFragmentMap(fragments);\n    var execContext = {\n      query: query,\n      fragmentMap: fragmentMap,\n      contextValue: contextValue,\n      variableValues: variableValues,\n      fragmentMatcher: fragmentMatcher\n    };\n    return this.executeSelectionSet({\n      selectionSet: mainDefinition.selectionSet,\n      rootValue: rootValue,\n      execContext: execContext\n    });\n  };\n\n  StoreReader.prototype.executeSelectionSet = function (_a) {\n    var _this = this;\n\n    var selectionSet = _a.selectionSet,\n        rootValue = _a.rootValue,\n        execContext = _a.execContext;\n    var fragmentMap = execContext.fragmentMap,\n        contextValue = execContext.contextValue,\n        variables = execContext.variableValues;\n    var finalResult = {\n      result: null\n    };\n    var objectsToMerge = [];\n    var object = contextValue.store.get(rootValue.id);\n    var typename = object && object.__typename || rootValue.id === 'ROOT_QUERY' && 'Query' || void 0;\n\n    function handleMissing(result) {\n      var _a;\n\n      if (result.missing) {\n        finalResult.missing = finalResult.missing || [];\n\n        (_a = finalResult.missing).push.apply(_a, result.missing);\n      }\n\n      return result.result;\n    }\n\n    selectionSet.selections.forEach(function (selection) {\n      var _a;\n\n      if (!shouldInclude(selection, variables)) {\n        return;\n      }\n\n      if (isField(selection)) {\n        var fieldResult = handleMissing(_this.executeField(object, typename, selection, execContext));\n\n        if (typeof fieldResult !== 'undefined') {\n          objectsToMerge.push((_a = {}, _a[resultKeyNameFromField(selection)] = fieldResult, _a));\n        }\n      } else {\n        var fragment = void 0;\n\n        if (isInlineFragment(selection)) {\n          fragment = selection;\n        } else {\n          fragment = fragmentMap[selection.name.value];\n\n          if (!fragment) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(9) : new InvariantError(\"No fragment named \" + selection.name.value);\n          }\n        }\n\n        var typeCondition = fragment.typeCondition && fragment.typeCondition.name.value;\n        var match = !typeCondition || execContext.fragmentMatcher(rootValue, typeCondition, contextValue);\n\n        if (match) {\n          var fragmentExecResult = _this.executeSelectionSet({\n            selectionSet: fragment.selectionSet,\n            rootValue: rootValue,\n            execContext: execContext\n          });\n\n          if (match === 'heuristic' && fragmentExecResult.missing) {\n            fragmentExecResult = __assign(__assign({}, fragmentExecResult), {\n              missing: fragmentExecResult.missing.map(function (info) {\n                return __assign(__assign({}, info), {\n                  tolerable: true\n                });\n              })\n            });\n          }\n\n          objectsToMerge.push(handleMissing(fragmentExecResult));\n        }\n      }\n    });\n    finalResult.result = mergeDeepArray(objectsToMerge);\n\n    if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n      Object.freeze(finalResult.result);\n    }\n\n    return finalResult;\n  };\n\n  StoreReader.prototype.executeField = function (object, typename, field, execContext) {\n    var variables = execContext.variableValues,\n        contextValue = execContext.contextValue;\n    var fieldName = field.name.value;\n    var args = argumentsObjectFromField(field, variables);\n    var info = {\n      resultKey: resultKeyNameFromField(field),\n      directives: getDirectiveInfoFromField(field, variables)\n    };\n    var readStoreResult = readStoreResolver(object, typename, fieldName, args, contextValue, info);\n\n    if (Array.isArray(readStoreResult.result)) {\n      return this.combineExecResults(readStoreResult, this.executeSubSelectedArray({\n        field: field,\n        array: readStoreResult.result,\n        execContext: execContext\n      }));\n    }\n\n    if (!field.selectionSet) {\n      assertSelectionSetForIdValue(field, readStoreResult.result);\n\n      if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n        maybeDeepFreeze(readStoreResult);\n      }\n\n      return readStoreResult;\n    }\n\n    if (readStoreResult.result == null) {\n      return readStoreResult;\n    }\n\n    return this.combineExecResults(readStoreResult, this.executeSelectionSet({\n      selectionSet: field.selectionSet,\n      rootValue: readStoreResult.result,\n      execContext: execContext\n    }));\n  };\n\n  StoreReader.prototype.combineExecResults = function () {\n    var execResults = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      execResults[_i] = arguments[_i];\n    }\n\n    var missing;\n    execResults.forEach(function (execResult) {\n      if (execResult.missing) {\n        missing = missing || [];\n        missing.push.apply(missing, execResult.missing);\n      }\n    });\n    return {\n      result: execResults.pop().result,\n      missing: missing\n    };\n  };\n\n  StoreReader.prototype.executeSubSelectedArray = function (_a) {\n    var _this = this;\n\n    var field = _a.field,\n        array = _a.array,\n        execContext = _a.execContext;\n    var missing;\n\n    function handleMissing(childResult) {\n      if (childResult.missing) {\n        missing = missing || [];\n        missing.push.apply(missing, childResult.missing);\n      }\n\n      return childResult.result;\n    }\n\n    array = array.map(function (item) {\n      if (item === null) {\n        return null;\n      }\n\n      if (Array.isArray(item)) {\n        return handleMissing(_this.executeSubSelectedArray({\n          field: field,\n          array: item,\n          execContext: execContext\n        }));\n      }\n\n      if (field.selectionSet) {\n        return handleMissing(_this.executeSelectionSet({\n          selectionSet: field.selectionSet,\n          rootValue: item,\n          execContext: execContext\n        }));\n      }\n\n      assertSelectionSetForIdValue(field, item);\n      return item;\n    });\n\n    if (this.freezeResults && process.env.NODE_ENV !== 'production') {\n      Object.freeze(array);\n    }\n\n    return {\n      result: array,\n      missing: missing\n    };\n  };\n\n  return StoreReader;\n}();\n\nfunction assertSelectionSetForIdValue(field, value) {\n  if (!field.selectionSet && isIdValue(value)) {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(10) : new InvariantError(\"Missing selection set for object of type \" + value.typename + \" returned for query field \" + field.name.value);\n  }\n}\n\nfunction defaultFragmentMatcher() {\n  return true;\n}\n\nfunction assertIdValue(idValue) {\n  process.env.NODE_ENV === \"production\" ? invariant(isIdValue(idValue), 11) : invariant(isIdValue(idValue), \"Encountered a sub-selection on the query, but the store doesn't have an object reference. This should never happen during normal use unless you have custom code that is directly manipulating the store; please file an issue.\");\n}\n\nfunction readStoreResolver(object, typename, fieldName, args, context, _a) {\n  var resultKey = _a.resultKey,\n      directives = _a.directives;\n  var storeKeyName = fieldName;\n\n  if (args || directives) {\n    storeKeyName = getStoreKeyName(storeKeyName, args, directives);\n  }\n\n  var fieldValue = void 0;\n\n  if (object) {\n    fieldValue = object[storeKeyName];\n\n    if (typeof fieldValue === 'undefined' && context.cacheRedirects && typeof typename === 'string') {\n      var type = context.cacheRedirects[typename];\n\n      if (type) {\n        var resolver = type[fieldName];\n\n        if (resolver) {\n          fieldValue = resolver(object, args, {\n            getCacheKey: function getCacheKey(storeObj) {\n              var id = context.dataIdFromObject(storeObj);\n              return id && toIdValue({\n                id: id,\n                typename: storeObj.__typename\n              });\n            }\n          });\n        }\n      }\n    }\n  }\n\n  if (typeof fieldValue === 'undefined') {\n    return {\n      result: fieldValue,\n      missing: [{\n        object: object,\n        fieldName: storeKeyName,\n        tolerable: false\n      }]\n    };\n  }\n\n  if (isJsonValue(fieldValue)) {\n    fieldValue = fieldValue.json;\n  }\n\n  return {\n    result: fieldValue\n  };\n}\n\nvar ObjectCache = function () {\n  function ObjectCache(data) {\n    if (data === void 0) {\n      data = Object.create(null);\n    }\n\n    this.data = data;\n  }\n\n  ObjectCache.prototype.toObject = function () {\n    return this.data;\n  };\n\n  ObjectCache.prototype.get = function (dataId) {\n    return this.data[dataId];\n  };\n\n  ObjectCache.prototype.set = function (dataId, value) {\n    this.data[dataId] = value;\n  };\n\n  ObjectCache.prototype.delete = function (dataId) {\n    this.data[dataId] = void 0;\n  };\n\n  ObjectCache.prototype.clear = function () {\n    this.data = Object.create(null);\n  };\n\n  ObjectCache.prototype.replace = function (newData) {\n    this.data = newData || Object.create(null);\n  };\n\n  return ObjectCache;\n}();\n\nfunction defaultNormalizedCacheFactory$1(seed) {\n  return new ObjectCache(seed);\n}\n\nvar WriteError = function (_super) {\n  __extends(WriteError, _super);\n\n  function WriteError() {\n    var _this = _super !== null && _super.apply(this, arguments) || this;\n\n    _this.type = 'WriteError';\n    return _this;\n  }\n\n  return WriteError;\n}(Error);\n\nfunction enhanceErrorWithDocument(error, document) {\n  var enhancedError = new WriteError(\"Error writing result to store for query:\\n \" + JSON.stringify(document));\n  enhancedError.message += '\\n' + error.message;\n  enhancedError.stack = error.stack;\n  return enhancedError;\n}\n\nvar StoreWriter = function () {\n  function StoreWriter() {}\n\n  StoreWriter.prototype.writeQueryToStore = function (_a) {\n    var query = _a.query,\n        result = _a.result,\n        _b = _a.store,\n        store = _b === void 0 ? defaultNormalizedCacheFactory() : _b,\n        variables = _a.variables,\n        dataIdFromObject = _a.dataIdFromObject,\n        fragmentMatcherFunction = _a.fragmentMatcherFunction;\n    return this.writeResultToStore({\n      dataId: 'ROOT_QUERY',\n      result: result,\n      document: query,\n      store: store,\n      variables: variables,\n      dataIdFromObject: dataIdFromObject,\n      fragmentMatcherFunction: fragmentMatcherFunction\n    });\n  };\n\n  StoreWriter.prototype.writeResultToStore = function (_a) {\n    var dataId = _a.dataId,\n        result = _a.result,\n        document = _a.document,\n        _b = _a.store,\n        store = _b === void 0 ? defaultNormalizedCacheFactory() : _b,\n        variables = _a.variables,\n        dataIdFromObject = _a.dataIdFromObject,\n        fragmentMatcherFunction = _a.fragmentMatcherFunction;\n    var operationDefinition = getOperationDefinition(document);\n\n    try {\n      return this.writeSelectionSetToStore({\n        result: result,\n        dataId: dataId,\n        selectionSet: operationDefinition.selectionSet,\n        context: {\n          store: store,\n          processedData: {},\n          variables: assign({}, getDefaultValues(operationDefinition), variables),\n          dataIdFromObject: dataIdFromObject,\n          fragmentMap: createFragmentMap(getFragmentDefinitions(document)),\n          fragmentMatcherFunction: fragmentMatcherFunction\n        }\n      });\n    } catch (e) {\n      throw enhanceErrorWithDocument(e, document);\n    }\n  };\n\n  StoreWriter.prototype.writeSelectionSetToStore = function (_a) {\n    var _this = this;\n\n    var result = _a.result,\n        dataId = _a.dataId,\n        selectionSet = _a.selectionSet,\n        context = _a.context;\n    var variables = context.variables,\n        store = context.store,\n        fragmentMap = context.fragmentMap;\n    selectionSet.selections.forEach(function (selection) {\n      var _a;\n\n      if (!shouldInclude(selection, variables)) {\n        return;\n      }\n\n      if (isField(selection)) {\n        var resultFieldKey = resultKeyNameFromField(selection);\n        var value = result[resultFieldKey];\n\n        if (typeof value !== 'undefined') {\n          _this.writeFieldToStore({\n            dataId: dataId,\n            value: value,\n            field: selection,\n            context: context\n          });\n        } else {\n          var isDefered = false;\n          var isClient = false;\n\n          if (selection.directives && selection.directives.length) {\n            isDefered = selection.directives.some(function (directive) {\n              return directive.name && directive.name.value === 'defer';\n            });\n            isClient = selection.directives.some(function (directive) {\n              return directive.name && directive.name.value === 'client';\n            });\n          }\n\n          if (!isDefered && !isClient && context.fragmentMatcherFunction) {\n            process.env.NODE_ENV === \"production\" || invariant.warn(\"Missing field \" + resultFieldKey + \" in \" + JSON.stringify(result, null, 2).substring(0, 100));\n          }\n        }\n      } else {\n        var fragment = void 0;\n\n        if (isInlineFragment(selection)) {\n          fragment = selection;\n        } else {\n          fragment = (fragmentMap || {})[selection.name.value];\n          process.env.NODE_ENV === \"production\" ? invariant(fragment, 3) : invariant(fragment, \"No fragment named \" + selection.name.value + \".\");\n        }\n\n        var matches = true;\n\n        if (context.fragmentMatcherFunction && fragment.typeCondition) {\n          var id = dataId || 'self';\n          var idValue = toIdValue({\n            id: id,\n            typename: undefined\n          });\n          var fakeContext = {\n            store: new ObjectCache((_a = {}, _a[id] = result, _a)),\n            cacheRedirects: {}\n          };\n          var match = context.fragmentMatcherFunction(idValue, fragment.typeCondition.name.value, fakeContext);\n\n          if (!isProduction() && match === 'heuristic') {\n            process.env.NODE_ENV === \"production\" || invariant.error('WARNING: heuristic fragment matching going on!');\n          }\n\n          matches = !!match;\n        }\n\n        if (matches) {\n          _this.writeSelectionSetToStore({\n            result: result,\n            selectionSet: fragment.selectionSet,\n            dataId: dataId,\n            context: context\n          });\n        }\n      }\n    });\n    return store;\n  };\n\n  StoreWriter.prototype.writeFieldToStore = function (_a) {\n    var _b;\n\n    var field = _a.field,\n        value = _a.value,\n        dataId = _a.dataId,\n        context = _a.context;\n    var variables = context.variables,\n        dataIdFromObject = context.dataIdFromObject,\n        store = context.store;\n    var storeValue;\n    var storeObject;\n    var storeFieldName = storeKeyNameFromField(field, variables);\n\n    if (!field.selectionSet || value === null) {\n      storeValue = value != null && typeof value === 'object' ? {\n        type: 'json',\n        json: value\n      } : value;\n    } else if (Array.isArray(value)) {\n      var generatedId = dataId + \".\" + storeFieldName;\n      storeValue = this.processArrayValue(value, generatedId, field.selectionSet, context);\n    } else {\n      var valueDataId = dataId + \".\" + storeFieldName;\n      var generated = true;\n\n      if (!isGeneratedId(valueDataId)) {\n        valueDataId = '$' + valueDataId;\n      }\n\n      if (dataIdFromObject) {\n        var semanticId = dataIdFromObject(value);\n        process.env.NODE_ENV === \"production\" ? invariant(!semanticId || !isGeneratedId(semanticId), 4) : invariant(!semanticId || !isGeneratedId(semanticId), 'IDs returned by dataIdFromObject cannot begin with the \"$\" character.');\n\n        if (semanticId || typeof semanticId === 'number' && semanticId === 0) {\n          valueDataId = semanticId;\n          generated = false;\n        }\n      }\n\n      if (!isDataProcessed(valueDataId, field, context.processedData)) {\n        this.writeSelectionSetToStore({\n          dataId: valueDataId,\n          result: value,\n          selectionSet: field.selectionSet,\n          context: context\n        });\n      }\n\n      var typename = value.__typename;\n      storeValue = toIdValue({\n        id: valueDataId,\n        typename: typename\n      }, generated);\n      storeObject = store.get(dataId);\n      var escapedId = storeObject && storeObject[storeFieldName];\n\n      if (escapedId !== storeValue && isIdValue(escapedId)) {\n        var hadTypename = escapedId.typename !== undefined;\n        var hasTypename = typename !== undefined;\n        var typenameChanged = hadTypename && hasTypename && escapedId.typename !== typename;\n        process.env.NODE_ENV === \"production\" ? invariant(!generated || escapedId.generated || typenameChanged, 5) : invariant(!generated || escapedId.generated || typenameChanged, \"Store error: the application attempted to write an object with no provided id but the store already contains an id of \" + escapedId.id + \" for this object. The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n        process.env.NODE_ENV === \"production\" ? invariant(!hadTypename || hasTypename, 6) : invariant(!hadTypename || hasTypename, \"Store error: the application attempted to write an object with no provided typename but the store already contains an object with typename of \" + escapedId.typename + \" for the object of id \" + escapedId.id + \". The selectionSet that was trying to be written is:\\n\" + JSON.stringify(field));\n\n        if (escapedId.generated) {\n          if (typenameChanged) {\n            if (!generated) {\n              store.delete(escapedId.id);\n            }\n          } else {\n            mergeWithGenerated(escapedId.id, storeValue.id, store);\n          }\n        }\n      }\n    }\n\n    storeObject = store.get(dataId);\n\n    if (!storeObject || !isEqual(storeValue, storeObject[storeFieldName])) {\n      store.set(dataId, __assign(__assign({}, storeObject), (_b = {}, _b[storeFieldName] = storeValue, _b)));\n    }\n  };\n\n  StoreWriter.prototype.processArrayValue = function (value, generatedId, selectionSet, context) {\n    var _this = this;\n\n    return value.map(function (item, index) {\n      if (item === null) {\n        return null;\n      }\n\n      var itemDataId = generatedId + \".\" + index;\n\n      if (Array.isArray(item)) {\n        return _this.processArrayValue(item, itemDataId, selectionSet, context);\n      }\n\n      var generated = true;\n\n      if (context.dataIdFromObject) {\n        var semanticId = context.dataIdFromObject(item);\n\n        if (semanticId) {\n          itemDataId = semanticId;\n          generated = false;\n        }\n      }\n\n      if (!isDataProcessed(itemDataId, selectionSet, context.processedData)) {\n        _this.writeSelectionSetToStore({\n          dataId: itemDataId,\n          result: item,\n          selectionSet: selectionSet,\n          context: context\n        });\n      }\n\n      return toIdValue({\n        id: itemDataId,\n        typename: item.__typename\n      }, generated);\n    });\n  };\n\n  return StoreWriter;\n}();\n\nfunction isGeneratedId(id) {\n  return id[0] === '$';\n}\n\nfunction mergeWithGenerated(generatedKey, realKey, cache) {\n  if (generatedKey === realKey) {\n    return false;\n  }\n\n  var generated = cache.get(generatedKey);\n  var real = cache.get(realKey);\n  var madeChanges = false;\n  Object.keys(generated).forEach(function (key) {\n    var value = generated[key];\n    var realValue = real[key];\n\n    if (isIdValue(value) && isGeneratedId(value.id) && isIdValue(realValue) && !isEqual(value, realValue) && mergeWithGenerated(value.id, realValue.id, cache)) {\n      madeChanges = true;\n    }\n  });\n  cache.delete(generatedKey);\n\n  var newRealValue = __assign(__assign({}, generated), real);\n\n  if (isEqual(newRealValue, real)) {\n    return madeChanges;\n  }\n\n  cache.set(realKey, newRealValue);\n  return true;\n}\n\nfunction isDataProcessed(dataId, field, processedData) {\n  if (!processedData) {\n    return false;\n  }\n\n  if (processedData[dataId]) {\n    if (processedData[dataId].indexOf(field) >= 0) {\n      return true;\n    } else {\n      processedData[dataId].push(field);\n    }\n  } else {\n    processedData[dataId] = [field];\n  }\n\n  return false;\n}\n\nvar defaultConfig = {\n  fragmentMatcher: new HeuristicFragmentMatcher(),\n  dataIdFromObject: defaultDataIdFromObject,\n  addTypename: true,\n  resultCaching: true,\n  freezeResults: false\n};\n\nfunction defaultDataIdFromObject(result) {\n  if (result.__typename) {\n    if (result.id !== undefined) {\n      return result.__typename + \":\" + result.id;\n    }\n\n    if (result._id !== undefined) {\n      return result.__typename + \":\" + result._id;\n    }\n  }\n\n  return null;\n}\n\nvar hasOwn$1 = Object.prototype.hasOwnProperty;\n\nvar OptimisticCacheLayer = function (_super) {\n  __extends(OptimisticCacheLayer, _super);\n\n  function OptimisticCacheLayer(optimisticId, parent, transaction) {\n    var _this = _super.call(this, Object.create(null)) || this;\n\n    _this.optimisticId = optimisticId;\n    _this.parent = parent;\n    _this.transaction = transaction;\n    return _this;\n  }\n\n  OptimisticCacheLayer.prototype.toObject = function () {\n    return __assign(__assign({}, this.parent.toObject()), this.data);\n  };\n\n  OptimisticCacheLayer.prototype.get = function (dataId) {\n    return hasOwn$1.call(this.data, dataId) ? this.data[dataId] : this.parent.get(dataId);\n  };\n\n  return OptimisticCacheLayer;\n}(ObjectCache);\n\nvar InMemoryCache = function (_super) {\n  __extends(InMemoryCache, _super);\n\n  function InMemoryCache(config) {\n    if (config === void 0) {\n      config = {};\n    }\n\n    var _this = _super.call(this) || this;\n\n    _this.watches = new Set();\n    _this.typenameDocumentCache = new Map();\n    _this.cacheKeyRoot = new KeyTrie(canUseWeakMap);\n    _this.silenceBroadcast = false;\n    _this.config = __assign(__assign({}, defaultConfig), config);\n\n    if (_this.config.customResolvers) {\n      process.env.NODE_ENV === \"production\" || invariant.warn('customResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating customResolvers in the next major version.');\n      _this.config.cacheRedirects = _this.config.customResolvers;\n    }\n\n    if (_this.config.cacheResolvers) {\n      process.env.NODE_ENV === \"production\" || invariant.warn('cacheResolvers have been renamed to cacheRedirects. Please update your config as we will be deprecating cacheResolvers in the next major version.');\n      _this.config.cacheRedirects = _this.config.cacheResolvers;\n    }\n\n    _this.addTypename = !!_this.config.addTypename;\n    _this.data = _this.config.resultCaching ? new DepTrackingCache() : new ObjectCache();\n    _this.optimisticData = _this.data;\n    _this.storeWriter = new StoreWriter();\n    _this.storeReader = new StoreReader({\n      cacheKeyRoot: _this.cacheKeyRoot,\n      freezeResults: config.freezeResults\n    });\n    var cache = _this;\n    var maybeBroadcastWatch = cache.maybeBroadcastWatch;\n    _this.maybeBroadcastWatch = wrap(function (c) {\n      return maybeBroadcastWatch.call(_this, c);\n    }, {\n      makeCacheKey: function makeCacheKey(c) {\n        if (c.optimistic) {\n          return;\n        }\n\n        if (c.previousResult) {\n          return;\n        }\n\n        if (cache.data instanceof DepTrackingCache) {\n          return cache.cacheKeyRoot.lookup(c.query, JSON.stringify(c.variables));\n        }\n      }\n    });\n    return _this;\n  }\n\n  InMemoryCache.prototype.restore = function (data) {\n    if (data) this.data.replace(data);\n    return this;\n  };\n\n  InMemoryCache.prototype.extract = function (optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return (optimistic ? this.optimisticData : this.data).toObject();\n  };\n\n  InMemoryCache.prototype.read = function (options) {\n    if (typeof options.rootId === 'string' && typeof this.data.get(options.rootId) === 'undefined') {\n      return null;\n    }\n\n    var fragmentMatcher = this.config.fragmentMatcher;\n    var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n    return this.storeReader.readQueryFromStore({\n      store: options.optimistic ? this.optimisticData : this.data,\n      query: this.transformDocument(options.query),\n      variables: options.variables,\n      rootId: options.rootId,\n      fragmentMatcherFunction: fragmentMatcherFunction,\n      previousResult: options.previousResult,\n      config: this.config\n    }) || null;\n  };\n\n  InMemoryCache.prototype.write = function (write) {\n    var fragmentMatcher = this.config.fragmentMatcher;\n    var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n    this.storeWriter.writeResultToStore({\n      dataId: write.dataId,\n      result: write.result,\n      variables: write.variables,\n      document: this.transformDocument(write.query),\n      store: this.data,\n      dataIdFromObject: this.config.dataIdFromObject,\n      fragmentMatcherFunction: fragmentMatcherFunction\n    });\n    this.broadcastWatches();\n  };\n\n  InMemoryCache.prototype.diff = function (query) {\n    var fragmentMatcher = this.config.fragmentMatcher;\n    var fragmentMatcherFunction = fragmentMatcher && fragmentMatcher.match;\n    return this.storeReader.diffQueryAgainstStore({\n      store: query.optimistic ? this.optimisticData : this.data,\n      query: this.transformDocument(query.query),\n      variables: query.variables,\n      returnPartialData: query.returnPartialData,\n      previousResult: query.previousResult,\n      fragmentMatcherFunction: fragmentMatcherFunction,\n      config: this.config\n    });\n  };\n\n  InMemoryCache.prototype.watch = function (watch) {\n    var _this = this;\n\n    this.watches.add(watch);\n    return function () {\n      _this.watches.delete(watch);\n    };\n  };\n\n  InMemoryCache.prototype.evict = function (query) {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(7) : new InvariantError(\"eviction is not implemented on InMemory Cache\");\n  };\n\n  InMemoryCache.prototype.reset = function () {\n    this.data.clear();\n    this.broadcastWatches();\n    return Promise.resolve();\n  };\n\n  InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n    var toReapply = [];\n    var removedCount = 0;\n    var layer = this.optimisticData;\n\n    while (layer instanceof OptimisticCacheLayer) {\n      if (layer.optimisticId === idToRemove) {\n        ++removedCount;\n      } else {\n        toReapply.push(layer);\n      }\n\n      layer = layer.parent;\n    }\n\n    if (removedCount > 0) {\n      this.optimisticData = layer;\n\n      while (toReapply.length > 0) {\n        var layer_1 = toReapply.pop();\n        this.performTransaction(layer_1.transaction, layer_1.optimisticId);\n      }\n\n      this.broadcastWatches();\n    }\n  };\n\n  InMemoryCache.prototype.performTransaction = function (transaction, optimisticId) {\n    var _a = this,\n        data = _a.data,\n        silenceBroadcast = _a.silenceBroadcast;\n\n    this.silenceBroadcast = true;\n\n    if (typeof optimisticId === 'string') {\n      this.data = this.optimisticData = new OptimisticCacheLayer(optimisticId, this.optimisticData, transaction);\n    }\n\n    try {\n      transaction(this);\n    } finally {\n      this.silenceBroadcast = silenceBroadcast;\n      this.data = data;\n    }\n\n    this.broadcastWatches();\n  };\n\n  InMemoryCache.prototype.recordOptimisticTransaction = function (transaction, id) {\n    return this.performTransaction(transaction, id);\n  };\n\n  InMemoryCache.prototype.transformDocument = function (document) {\n    if (this.addTypename) {\n      var result = this.typenameDocumentCache.get(document);\n\n      if (!result) {\n        result = addTypenameToDocument(document);\n        this.typenameDocumentCache.set(document, result);\n        this.typenameDocumentCache.set(result, result);\n      }\n\n      return result;\n    }\n\n    return document;\n  };\n\n  InMemoryCache.prototype.broadcastWatches = function () {\n    var _this = this;\n\n    if (!this.silenceBroadcast) {\n      this.watches.forEach(function (c) {\n        return _this.maybeBroadcastWatch(c);\n      });\n    }\n  };\n\n  InMemoryCache.prototype.maybeBroadcastWatch = function (c) {\n    c.callback(this.diff({\n      query: c.query,\n      variables: c.variables,\n      previousResult: c.previousResult && c.previousResult(),\n      optimistic: c.optimistic\n    }));\n  };\n\n  return InMemoryCache;\n}(ApolloCache);\n\nexport { HeuristicFragmentMatcher, InMemoryCache, IntrospectionFragmentMatcher, ObjectCache, StoreReader, StoreWriter, WriteError, assertIdValue, defaultDataIdFromObject, defaultNormalizedCacheFactory$1 as defaultNormalizedCacheFactory, enhanceErrorWithDocument };","import { __assign, __extends } from 'tslib';\nimport { Observable, ApolloLink } from 'apollo-link';\n\nvar OperationBatcher = function () {\n  function OperationBatcher(_a) {\n    var batchInterval = _a.batchInterval,\n        batchMax = _a.batchMax,\n        batchHandler = _a.batchHandler,\n        batchKey = _a.batchKey;\n    this.queuedRequests = new Map();\n    this.batchInterval = batchInterval;\n    this.batchMax = batchMax || 0;\n    this.batchHandler = batchHandler;\n\n    this.batchKey = batchKey || function () {\n      return '';\n    };\n  }\n\n  OperationBatcher.prototype.enqueueRequest = function (request) {\n    var _this = this;\n\n    var requestCopy = __assign({}, request);\n\n    var queued = false;\n    var key = this.batchKey(request.operation);\n\n    if (!requestCopy.observable) {\n      requestCopy.observable = new Observable(function (observer) {\n        if (!_this.queuedRequests.has(key)) {\n          _this.queuedRequests.set(key, []);\n        }\n\n        if (!queued) {\n          _this.queuedRequests.get(key).push(requestCopy);\n\n          queued = true;\n        }\n\n        requestCopy.next = requestCopy.next || [];\n        if (observer.next) requestCopy.next.push(observer.next.bind(observer));\n        requestCopy.error = requestCopy.error || [];\n        if (observer.error) requestCopy.error.push(observer.error.bind(observer));\n        requestCopy.complete = requestCopy.complete || [];\n        if (observer.complete) requestCopy.complete.push(observer.complete.bind(observer));\n\n        if (_this.queuedRequests.get(key).length === 1) {\n          _this.scheduleQueueConsumption(key);\n        }\n\n        if (_this.queuedRequests.get(key).length === _this.batchMax) {\n          _this.consumeQueue(key);\n        }\n      });\n    }\n\n    return requestCopy.observable;\n  };\n\n  OperationBatcher.prototype.consumeQueue = function (key) {\n    var requestKey = key || '';\n    var queuedRequests = this.queuedRequests.get(requestKey);\n\n    if (!queuedRequests) {\n      return;\n    }\n\n    this.queuedRequests.delete(requestKey);\n    var requests = queuedRequests.map(function (queuedRequest) {\n      return queuedRequest.operation;\n    });\n    var forwards = queuedRequests.map(function (queuedRequest) {\n      return queuedRequest.forward;\n    });\n    var observables = [];\n    var nexts = [];\n    var errors = [];\n    var completes = [];\n    queuedRequests.forEach(function (batchableRequest, index) {\n      observables.push(batchableRequest.observable);\n      nexts.push(batchableRequest.next);\n      errors.push(batchableRequest.error);\n      completes.push(batchableRequest.complete);\n    });\n    var batchedObservable = this.batchHandler(requests, forwards) || Observable.of();\n\n    var onError = function onError(error) {\n      errors.forEach(function (rejecters) {\n        if (rejecters) {\n          rejecters.forEach(function (e) {\n            return e(error);\n          });\n        }\n      });\n    };\n\n    batchedObservable.subscribe({\n      next: function next(results) {\n        if (!Array.isArray(results)) {\n          results = [results];\n        }\n\n        if (nexts.length !== results.length) {\n          var error = new Error(\"server returned results with length \" + results.length + \", expected length of \" + nexts.length);\n          error.result = results;\n          return onError(error);\n        }\n\n        results.forEach(function (result, index) {\n          if (nexts[index]) {\n            nexts[index].forEach(function (next) {\n              return next(result);\n            });\n          }\n        });\n      },\n      error: onError,\n      complete: function complete() {\n        completes.forEach(function (complete) {\n          if (complete) {\n            complete.forEach(function (c) {\n              return c();\n            });\n          }\n        });\n      }\n    });\n    return observables;\n  };\n\n  OperationBatcher.prototype.scheduleQueueConsumption = function (key) {\n    var _this = this;\n\n    var requestKey = key || '';\n    setTimeout(function () {\n      if (_this.queuedRequests.get(requestKey) && _this.queuedRequests.get(requestKey).length) {\n        _this.consumeQueue(requestKey);\n      }\n    }, this.batchInterval);\n  };\n\n  return OperationBatcher;\n}();\n\nvar BatchLink = function (_super) {\n  __extends(BatchLink, _super);\n\n  function BatchLink(fetchParams) {\n    var _this = _super.call(this) || this;\n\n    var _a = fetchParams || {},\n        _b = _a.batchInterval,\n        batchInterval = _b === void 0 ? 10 : _b,\n        _c = _a.batchMax,\n        batchMax = _c === void 0 ? 0 : _c,\n        _d = _a.batchHandler,\n        batchHandler = _d === void 0 ? function () {\n      return null;\n    } : _d,\n        _e = _a.batchKey,\n        batchKey = _e === void 0 ? function () {\n      return '';\n    } : _e;\n\n    _this.batcher = new OperationBatcher({\n      batchInterval: batchInterval,\n      batchMax: batchMax,\n      batchHandler: batchHandler,\n      batchKey: batchKey\n    });\n\n    if (fetchParams.batchHandler.length <= 1) {\n      _this.request = function (operation) {\n        return _this.batcher.enqueueRequest({\n          operation: operation\n        });\n      };\n    }\n\n    return _this;\n  }\n\n  BatchLink.prototype.request = function (operation, forward) {\n    return this.batcher.enqueueRequest({\n      operation: operation,\n      forward: forward\n    });\n  };\n\n  return BatchLink;\n}(ApolloLink);\n\nexport { BatchLink, OperationBatcher };","import { __extends, __rest, __assign } from 'tslib';\nimport { ApolloLink, fromError, Observable } from 'apollo-link';\nimport { checkFetcher, selectURI, selectHttpOptionsAndBody, fallbackHttpConfig, serializeFetchParameter, createSignalIfSupported, parseAndCheckHttpResponse } from 'apollo-link-http-common';\nimport { BatchLink } from 'apollo-link-batch';\n\nvar BatchHttpLink = function (_super) {\n  __extends(BatchHttpLink, _super);\n\n  function BatchHttpLink(fetchParams) {\n    var _this = _super.call(this) || this;\n\n    var _a = fetchParams || {},\n        _b = _a.uri,\n        uri = _b === void 0 ? '/graphql' : _b,\n        fetcher = _a.fetch,\n        includeExtensions = _a.includeExtensions,\n        batchInterval = _a.batchInterval,\n        batchMax = _a.batchMax,\n        batchKey = _a.batchKey,\n        requestOptions = __rest(_a, [\"uri\", \"fetch\", \"includeExtensions\", \"batchInterval\", \"batchMax\", \"batchKey\"]);\n\n    checkFetcher(fetcher);\n\n    if (!fetcher) {\n      fetcher = fetch;\n    }\n\n    var linkConfig = {\n      http: {\n        includeExtensions: includeExtensions\n      },\n      options: requestOptions.fetchOptions,\n      credentials: requestOptions.credentials,\n      headers: requestOptions.headers\n    };\n    _this.batchInterval = batchInterval || 10;\n    _this.batchMax = batchMax || 10;\n\n    var batchHandler = function batchHandler(operations) {\n      var chosenURI = selectURI(operations[0], uri);\n      var context = operations[0].getContext();\n      var clientAwarenessHeaders = {};\n\n      if (context.clientAwareness) {\n        var _a = context.clientAwareness,\n            name_1 = _a.name,\n            version = _a.version;\n\n        if (name_1) {\n          clientAwarenessHeaders['apollographql-client-name'] = name_1;\n        }\n\n        if (version) {\n          clientAwarenessHeaders['apollographql-client-version'] = version;\n        }\n      }\n\n      var contextConfig = {\n        http: context.http,\n        options: context.fetchOptions,\n        credentials: context.credentials,\n        headers: __assign({}, clientAwarenessHeaders, context.headers)\n      };\n      var optsAndBody = operations.map(function (operation) {\n        return selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig);\n      });\n      var loadedBody = optsAndBody.map(function (_a) {\n        var body = _a.body;\n        return body;\n      });\n      var options = optsAndBody[0].options;\n\n      if (options.method === 'GET') {\n        return fromError(new Error('apollo-link-batch-http does not support GET requests'));\n      }\n\n      try {\n        options.body = serializeFetchParameter(loadedBody, 'Payload');\n      } catch (parseError) {\n        return fromError(parseError);\n      }\n\n      var controller;\n\n      if (!options.signal) {\n        var _b = createSignalIfSupported(),\n            _controller = _b.controller,\n            signal = _b.signal;\n\n        controller = _controller;\n        if (controller) options.signal = signal;\n      }\n\n      return new Observable(function (observer) {\n        fetcher(chosenURI, options).then(function (response) {\n          operations.forEach(function (operation) {\n            return operation.setContext({\n              response: response\n            });\n          });\n          return response;\n        }).then(parseAndCheckHttpResponse(operations)).then(function (result) {\n          observer.next(result);\n          observer.complete();\n          return result;\n        }).catch(function (err) {\n          if (err.name === 'AbortError') return;\n\n          if (err.result && err.result.errors && err.result.data) {\n            observer.next(err.result);\n          }\n\n          observer.error(err);\n        });\n        return function () {\n          if (controller) controller.abort();\n        };\n      });\n    };\n\n    batchKey = batchKey || function (operation) {\n      var context = operation.getContext();\n      var contextConfig = {\n        http: context.http,\n        options: context.fetchOptions,\n        credentials: context.credentials,\n        headers: context.headers\n      };\n      return selectURI(operation, uri) + JSON.stringify(contextConfig);\n    };\n\n    _this.batcher = new BatchLink({\n      batchInterval: _this.batchInterval,\n      batchMax: _this.batchMax,\n      batchKey: batchKey,\n      batchHandler: batchHandler\n    });\n    return _this;\n  }\n\n  BatchHttpLink.prototype.request = function (operation) {\n    return this.batcher.request(operation);\n  };\n\n  return BatchHttpLink;\n}(ApolloLink);\n\nexport { BatchHttpLink };","function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nimport React from \"react\";\nvar style = {\n  border: 0,\n  clip: \"rect(0 0 0 0)\",\n  height: \"1px\",\n  width: \"1px\",\n  margin: \"-1px\",\n  padding: 0,\n  overflow: \"hidden\",\n  position: \"absolute\",\n  // https://medium.com/@jessebeach/beware-smushed-off-screen-accessible-text-5952a4c2cbfe\n  whiteSpace: \"nowrap\",\n  wordWrap: \"normal\"\n};\n\nfunction VisuallyHidden(props) {\n  return /*#__PURE__*/React.createElement(\"span\", _extends({\n    style: style\n  }, props));\n}\n\nVisuallyHidden.displayName = \"VisuallyHidden\";\nexport default VisuallyHidden;","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 = ['query', 'operationName', 'variables', 'extensions', 'context'];\n\n  for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n    var key = _a[_i];\n\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\n  return operation;\n}\n\nvar LinkError = function (_super) {\n  __extends(LinkError, _super);\n\n  function LinkError(message, link) {\n    var _this = _super.call(this, message) || this;\n\n    _this.link = link;\n    return _this;\n  }\n\n  return LinkError;\n}(Error);\n\nfunction isTerminating(link) {\n  return link.request.length <= 1;\n}\n\nfunction toPromise(observable) {\n  var completed = false;\n  return new Promise(function (resolve, reject) {\n    observable.subscribe({\n      next: function next(data) {\n        if (completed) {\n          process.env.NODE_ENV === \"production\" || invariant.warn(\"Promise Wrapper does not support multiple results from Observable\");\n        } else {\n          completed = true;\n          resolve(data);\n        }\n      },\n      error: reject\n    });\n  });\n}\n\nvar makePromise = toPromise;\n\nfunction fromPromise(promise) {\n  return new Observable(function (observer) {\n    promise.then(function (value) {\n      observer.next(value);\n      observer.complete();\n    }).catch(observer.error.bind(observer));\n  });\n}\n\nfunction fromError(errorValue) {\n  return new Observable(function (observer) {\n    observer.error(errorValue);\n  });\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\n  if (!transformedOperation.operationName) {\n    transformedOperation.operationName = typeof transformedOperation.query !== 'string' ? getOperationName(transformedOperation.query) : '';\n  }\n\n  return transformedOperation;\n}\n\nfunction createOperation(starting, operation) {\n  var context = __assign({}, starting);\n\n  var setContext = function setContext(next) {\n    if (typeof next === 'function') {\n      context = __assign({}, context, next(context));\n    } else {\n      context = __assign({}, context, next);\n    }\n  };\n\n  var getContext = function getContext() {\n    return __assign({}, context);\n  };\n\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 value() {\n      return getKey(operation);\n    }\n  });\n  return operation;\n}\n\nfunction getKey(operation) {\n  var query = operation.query,\n      variables = operation.variables,\n      operationName = operation.operationName;\n  return JSON.stringify([operationName, query, variables]);\n}\n\nfunction passthrough(op, forward) {\n  return forward ? forward(op) : Observable.of();\n}\n\nfunction toLink(handler) {\n  return typeof handler === 'function' ? new ApolloLink(handler) : handler;\n}\n\nfunction empty() {\n  return new ApolloLink(function () {\n    return Observable.of();\n  });\n}\n\nfunction from(links) {\n  if (links.length === 0) return empty();\n  return links.map(toLink).reduce(function (x, y) {\n    return x.concat(y);\n  });\n}\n\nfunction split(test, left, right) {\n  var leftLink = toLink(left);\n  var rightLink = toLink(right || new ApolloLink(passthrough));\n\n  if (isTerminating(leftLink) && isTerminating(rightLink)) {\n    return new ApolloLink(function (operation) {\n      return test(operation) ? leftLink.request(operation) || Observable.of() : rightLink.request(operation) || Observable.of();\n    });\n  } else {\n    return new ApolloLink(function (operation, forward) {\n      return test(operation) ? leftLink.request(operation, forward) || Observable.of() : rightLink.request(operation, forward) || Observable.of();\n    });\n  }\n}\n\nvar concat = function concat(first, second) {\n  var firstLink = toLink(first);\n\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\n  var nextLink = toLink(second);\n\n  if (isTerminating(nextLink)) {\n    return new ApolloLink(function (operation) {\n      return firstLink.request(operation, function (op) {\n        return nextLink.request(op) || Observable.of();\n      }) || Observable.of();\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};\n\nvar ApolloLink = function () {\n  function ApolloLink(request) {\n    if (request) this.request = request;\n  }\n\n  ApolloLink.prototype.split = function (test, left, right) {\n    return this.concat(split(test, left, right || new ApolloLink(passthrough)));\n  };\n\n  ApolloLink.prototype.concat = function (next) {\n    return concat(this, next);\n  };\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\n  ApolloLink.empty = empty;\n  ApolloLink.from = from;\n  ApolloLink.split = split;\n  ApolloLink.execute = execute;\n  return ApolloLink;\n}();\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 };","var _a = Object.prototype,\n    toString = _a.toString,\n    hasOwnProperty = _a.hasOwnProperty;\nvar previousComparisons = new Map();\n/**\r\n * Performs a deep equality check on two JavaScript values, tolerating cycles.\r\n */\n\nfunction equal(a, b) {\n  try {\n    return check(a, b);\n  } finally {\n    previousComparisons.clear();\n  }\n}\n\nfunction check(a, b) {\n  // If the two values are strictly equal, our job is easy.\n  if (a === b) {\n    return true;\n  } // Object.prototype.toString returns a representation of the runtime type of\n  // the given value that is considerably more precise than typeof.\n\n\n  var aTag = toString.call(a);\n  var bTag = toString.call(b); // If the runtime types of a and b are different, they could maybe be equal\n  // under some interpretation of equality, but for simplicity and performance\n  // we just return false instead.\n\n  if (aTag !== bTag) {\n    return false;\n  }\n\n  switch (aTag) {\n    case '[object Array]':\n      // Arrays are a lot like other objects, but we can cheaply compare their\n      // lengths as a short-cut before comparing their elements.\n      if (a.length !== b.length) return false;\n    // Fall through to object case...\n\n    case '[object Object]':\n      {\n        if (previouslyCompared(a, b)) return true;\n        var aKeys = Object.keys(a);\n        var bKeys = Object.keys(b); // If `a` and `b` have a different number of enumerable keys, they\n        // must be different.\n\n        var keyCount = aKeys.length;\n        if (keyCount !== bKeys.length) return false; // Now make sure they have the same keys.\n\n        for (var k = 0; k < keyCount; ++k) {\n          if (!hasOwnProperty.call(b, aKeys[k])) {\n            return false;\n          }\n        } // Finally, check deep equality of all child properties.\n\n\n        for (var k = 0; k < keyCount; ++k) {\n          var key = aKeys[k];\n\n          if (!check(a[key], b[key])) {\n            return false;\n          }\n        }\n\n        return true;\n      }\n\n    case '[object Error]':\n      return a.name === b.name && a.message === b.message;\n\n    case '[object Number]':\n      // Handle NaN, which is !== itself.\n      if (a !== a) return b !== b;\n    // Fall through to shared +a === +b case...\n\n    case '[object Boolean]':\n    case '[object Date]':\n      return +a === +b;\n\n    case '[object RegExp]':\n    case '[object String]':\n      return a == \"\" + b;\n\n    case '[object Map]':\n    case '[object Set]':\n      {\n        if (a.size !== b.size) return false;\n        if (previouslyCompared(a, b)) return true;\n        var aIterator = a.entries();\n        var isMap = aTag === '[object Map]';\n\n        while (true) {\n          var info = aIterator.next();\n          if (info.done) break; // If a instanceof Set, aValue === aKey.\n\n          var _a = info.value,\n              aKey = _a[0],\n              aValue = _a[1]; // So this works the same way for both Set and Map.\n\n          if (!b.has(aKey)) {\n            return false;\n          } // However, we care about deep equality of values only when dealing\n          // with Map structures.\n\n\n          if (isMap && !check(aValue, b.get(aKey))) {\n            return false;\n          }\n        }\n\n        return true;\n      }\n  } // Otherwise the values are not equal.\n\n\n  return false;\n}\n\nfunction previouslyCompared(a, b) {\n  // Though cyclic references can make an object graph appear infinite from the\n  // perspective of a depth-first traversal, the graph still contains a finite\n  // number of distinct object references. We use the previousComparisons cache\n  // to avoid comparing the same pair of object references more than once, which\n  // guarantees termination (even if we end up comparing every object in one\n  // graph to every object in the other graph, which is extremely unlikely),\n  // while still allowing weird isomorphic structures (like rings with different\n  // lengths) a chance to pass the equality test.\n  var bSet = previousComparisons.get(a);\n\n  if (bSet) {\n    // Return true here because we can be sure false will be returned somewhere\n    // else if the objects are not equivalent.\n    if (bSet.has(b)) return true;\n  } else {\n    previousComparisons.set(a, bSet = new Set());\n  }\n\n  bSet.add(b);\n  return false;\n}\n\nexport default equal;\nexport { equal };","import { __assign } from 'tslib';\nimport { print } from 'graphql/language/printer';\nimport { InvariantError } from 'ts-invariant';\nvar defaultHttpOptions = {\n  includeQuery: true,\n  includeExtensions: false\n};\nvar defaultHeaders = {\n  accept: '*/*',\n  'content-type': 'application/json'\n};\nvar defaultOptions = {\n  method: 'POST'\n};\nvar fallbackHttpConfig = {\n  http: defaultHttpOptions,\n  headers: defaultHeaders,\n  options: defaultOptions\n};\n\nvar throwServerError = function throwServerError(response, result, message) {\n  var error = new Error(message);\n  error.name = 'ServerError';\n  error.response = response;\n  error.statusCode = response.status;\n  error.result = result;\n  throw error;\n};\n\nvar parseAndCheckHttpResponse = function parseAndCheckHttpResponse(operations) {\n  return function (response) {\n    return response.text().then(function (bodyText) {\n      try {\n        return JSON.parse(bodyText);\n      } catch (err) {\n        var parseError = err;\n        parseError.name = 'ServerParseError';\n        parseError.response = response;\n        parseError.statusCode = response.status;\n        parseError.bodyText = bodyText;\n        return Promise.reject(parseError);\n      }\n    }).then(function (result) {\n      if (response.status >= 300) {\n        throwServerError(response, result, \"Response not successful: Received status code \" + response.status);\n      }\n\n      if (!Array.isArray(result) && !result.hasOwnProperty('data') && !result.hasOwnProperty('errors')) {\n        throwServerError(response, result, \"Server response was missing for query '\" + (Array.isArray(operations) ? operations.map(function (op) {\n          return op.operationName;\n        }) : operations.operationName) + \"'.\");\n      }\n\n      return result;\n    });\n  };\n};\n\nvar checkFetcher = function checkFetcher(fetcher) {\n  if (!fetcher && typeof fetch === 'undefined') {\n    var library = 'unfetch';\n    if (typeof window === 'undefined') library = 'node-fetch';\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(1) : new InvariantError(\"\\nfetch is not found globally and no fetcher passed, to fix pass a fetch for\\nyour environment like https://www.npmjs.com/package/\" + library + \".\\n\\nFor example:\\nimport fetch from '\" + library + \"';\\nimport { createHttpLink } from 'apollo-link-http';\\n\\nconst link = createHttpLink({ uri: '/graphql', fetch: fetch });\");\n  }\n};\n\nvar createSignalIfSupported = function createSignalIfSupported() {\n  if (typeof AbortController === 'undefined') return {\n    controller: false,\n    signal: false\n  };\n  var controller = new AbortController();\n  var signal = controller.signal;\n  return {\n    controller: controller,\n    signal: signal\n  };\n};\n\nvar selectHttpOptionsAndBody = function selectHttpOptionsAndBody(operation, fallbackConfig) {\n  var configs = [];\n\n  for (var _i = 2; _i < arguments.length; _i++) {\n    configs[_i - 2] = arguments[_i];\n  }\n\n  var options = __assign({}, fallbackConfig.options, {\n    headers: fallbackConfig.headers,\n    credentials: fallbackConfig.credentials\n  });\n\n  var http = fallbackConfig.http;\n  configs.forEach(function (config) {\n    options = __assign({}, options, config.options, {\n      headers: __assign({}, options.headers, config.headers)\n    });\n    if (config.credentials) options.credentials = config.credentials;\n    http = __assign({}, http, config.http);\n  });\n  var operationName = operation.operationName,\n      extensions = operation.extensions,\n      variables = operation.variables,\n      query = operation.query;\n  var body = {\n    operationName: operationName,\n    variables: variables\n  };\n  if (http.includeExtensions) body.extensions = extensions;\n  if (http.includeQuery) body.query = print(query);\n  return {\n    options: options,\n    body: body\n  };\n};\n\nvar serializeFetchParameter = function serializeFetchParameter(p, label) {\n  var serialized;\n\n  try {\n    serialized = JSON.stringify(p);\n  } catch (e) {\n    var parseError = process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"Network request failed. \" + label + \" is not serializable: \" + e.message);\n    parseError.parseError = e;\n    throw parseError;\n  }\n\n  return serialized;\n};\n\nvar selectURI = function selectURI(operation, fallbackURI) {\n  var context = operation.getContext();\n  var contextURI = context.uri;\n\n  if (contextURI) {\n    return contextURI;\n  } else if (typeof fallbackURI === 'function') {\n    return fallbackURI(operation);\n  } else {\n    return fallbackURI || '/graphql';\n  }\n};\n\nexport { checkFetcher, createSignalIfSupported, fallbackHttpConfig, parseAndCheckHttpResponse, selectHttpOptionsAndBody, selectURI, serializeFetchParameter, throwServerError };","import { __rest, __assign, __extends } from 'tslib';\nimport { ApolloLink, fromError, Observable } from 'apollo-link';\nimport { checkFetcher, selectURI, selectHttpOptionsAndBody, fallbackHttpConfig, createSignalIfSupported, serializeFetchParameter, parseAndCheckHttpResponse } from 'apollo-link-http-common';\n\nvar createHttpLink = function createHttpLink(linkOptions) {\n  if (linkOptions === void 0) {\n    linkOptions = {};\n  }\n\n  var _a = linkOptions.uri,\n      uri = _a === void 0 ? '/graphql' : _a,\n      fetcher = linkOptions.fetch,\n      includeExtensions = linkOptions.includeExtensions,\n      useGETForQueries = linkOptions.useGETForQueries,\n      requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"includeExtensions\", \"useGETForQueries\"]);\n\n  checkFetcher(fetcher);\n\n  if (!fetcher) {\n    fetcher = fetch;\n  }\n\n  var linkConfig = {\n    http: {\n      includeExtensions: includeExtensions\n    },\n    options: requestOptions.fetchOptions,\n    credentials: requestOptions.credentials,\n    headers: requestOptions.headers\n  };\n  return new ApolloLink(function (operation) {\n    var chosenURI = selectURI(operation, uri);\n    var context = operation.getContext();\n    var clientAwarenessHeaders = {};\n\n    if (context.clientAwareness) {\n      var _a = context.clientAwareness,\n          name_1 = _a.name,\n          version = _a.version;\n\n      if (name_1) {\n        clientAwarenessHeaders['apollographql-client-name'] = name_1;\n      }\n\n      if (version) {\n        clientAwarenessHeaders['apollographql-client-version'] = version;\n      }\n    }\n\n    var contextHeaders = __assign({}, clientAwarenessHeaders, context.headers);\n\n    var contextConfig = {\n      http: context.http,\n      options: context.fetchOptions,\n      credentials: context.credentials,\n      headers: contextHeaders\n    };\n\n    var _b = selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig),\n        options = _b.options,\n        body = _b.body;\n\n    var controller;\n\n    if (!options.signal) {\n      var _c = createSignalIfSupported(),\n          _controller = _c.controller,\n          signal = _c.signal;\n\n      controller = _controller;\n      if (controller) options.signal = signal;\n    }\n\n    var definitionIsMutation = function definitionIsMutation(d) {\n      return d.kind === 'OperationDefinition' && d.operation === 'mutation';\n    };\n\n    if (useGETForQueries && !operation.query.definitions.some(definitionIsMutation)) {\n      options.method = 'GET';\n    }\n\n    if (options.method === 'GET') {\n      var _d = rewriteURIForGET(chosenURI, body),\n          newURI = _d.newURI,\n          parseError = _d.parseError;\n\n      if (parseError) {\n        return fromError(parseError);\n      }\n\n      chosenURI = newURI;\n    } else {\n      try {\n        options.body = serializeFetchParameter(body, 'Payload');\n      } catch (parseError) {\n        return fromError(parseError);\n      }\n    }\n\n    return new Observable(function (observer) {\n      fetcher(chosenURI, options).then(function (response) {\n        operation.setContext({\n          response: response\n        });\n        return response;\n      }).then(parseAndCheckHttpResponse(operation)).then(function (result) {\n        observer.next(result);\n        observer.complete();\n        return result;\n      }).catch(function (err) {\n        if (err.name === 'AbortError') return;\n\n        if (err.result && err.result.errors && err.result.data) {\n          observer.next(err.result);\n        }\n\n        observer.error(err);\n      });\n      return function () {\n        if (controller) controller.abort();\n      };\n    });\n  });\n};\n\nfunction rewriteURIForGET(chosenURI, body) {\n  var queryParams = [];\n\n  var addQueryParam = function addQueryParam(key, value) {\n    queryParams.push(key + \"=\" + encodeURIComponent(value));\n  };\n\n  if ('query' in body) {\n    addQueryParam('query', body.query);\n  }\n\n  if (body.operationName) {\n    addQueryParam('operationName', body.operationName);\n  }\n\n  if (body.variables) {\n    var serializedVariables = void 0;\n\n    try {\n      serializedVariables = serializeFetchParameter(body.variables, 'Variables map');\n    } catch (parseError) {\n      return {\n        parseError: parseError\n      };\n    }\n\n    addQueryParam('variables', serializedVariables);\n  }\n\n  if (body.extensions) {\n    var serializedExtensions = void 0;\n\n    try {\n      serializedExtensions = serializeFetchParameter(body.extensions, 'Extensions map');\n    } catch (parseError) {\n      return {\n        parseError: parseError\n      };\n    }\n\n    addQueryParam('extensions', serializedExtensions);\n  }\n\n  var fragment = '',\n      preFragment = chosenURI;\n  var fragmentStart = chosenURI.indexOf('#');\n\n  if (fragmentStart !== -1) {\n    fragment = chosenURI.substr(fragmentStart);\n    preFragment = chosenURI.substr(0, fragmentStart);\n  }\n\n  var queryParamsPrefix = preFragment.indexOf('?') === -1 ? '?' : '&';\n  var newURI = preFragment + queryParamsPrefix + queryParams.join('&') + fragment;\n  return {\n    newURI: newURI\n  };\n}\n\nvar HttpLink = function (_super) {\n  __extends(HttpLink, _super);\n\n  function HttpLink(opts) {\n    return _super.call(this, createHttpLink(opts).request) || this;\n  }\n\n  return HttpLink;\n}(ApolloLink);\n\nexport { HttpLink, createHttpLink };","import { __extends } from 'tslib';\nimport { ApolloLink, Observable } from 'apollo-link';\n\nfunction onError(errorHandler) {\n  return new ApolloLink(function (operation, forward) {\n    return new Observable(function (observer) {\n      var sub;\n      var retriedSub;\n      var retriedResult;\n\n      try {\n        sub = forward(operation).subscribe({\n          next: function next(result) {\n            if (result.errors) {\n              retriedResult = errorHandler({\n                graphQLErrors: result.errors,\n                response: result,\n                operation: operation,\n                forward: forward\n              });\n\n              if (retriedResult) {\n                retriedSub = retriedResult.subscribe({\n                  next: observer.next.bind(observer),\n                  error: observer.error.bind(observer),\n                  complete: observer.complete.bind(observer)\n                });\n                return;\n              }\n            }\n\n            observer.next(result);\n          },\n          error: function error(networkError) {\n            retriedResult = errorHandler({\n              operation: operation,\n              networkError: networkError,\n              graphQLErrors: networkError && networkError.result && networkError.result.errors,\n              forward: forward\n            });\n\n            if (retriedResult) {\n              retriedSub = retriedResult.subscribe({\n                next: observer.next.bind(observer),\n                error: observer.error.bind(observer),\n                complete: observer.complete.bind(observer)\n              });\n              return;\n            }\n\n            observer.error(networkError);\n          },\n          complete: function complete() {\n            if (!retriedResult) {\n              observer.complete.bind(observer)();\n            }\n          }\n        });\n      } catch (e) {\n        errorHandler({\n          networkError: e,\n          operation: operation,\n          forward: forward\n        });\n        observer.error(e);\n      }\n\n      return function () {\n        if (sub) sub.unsubscribe();\n        if (retriedSub) sub.unsubscribe();\n      };\n    });\n  });\n}\n\nvar ErrorLink = function (_super) {\n  __extends(ErrorLink, _super);\n\n  function ErrorLink(errorHandler) {\n    var _this = _super.call(this) || this;\n\n    _this.link = onError(errorHandler);\n    return _this;\n  }\n\n  ErrorLink.prototype.request = function (operation, forward) {\n    return this.link.request(operation, forward);\n  };\n\n  return ErrorLink;\n}(ApolloLink);\n\nexport { ErrorLink, onError };","import { __extends, __awaiter, __generator } from 'tslib';\nimport { Observable, ApolloLink } from 'apollo-link';\n\nfunction buildDelayFunction(delayOptions) {\n  var _a = delayOptions || {},\n      _b = _a.initial,\n      initial = _b === void 0 ? 300 : _b,\n      _c = _a.jitter,\n      jitter = _c === void 0 ? true : _c,\n      _d = _a.max,\n      max = _d === void 0 ? Infinity : _d;\n\n  var baseDelay = jitter ? initial : initial / 2;\n  return function delayFunction(count) {\n    var delay = Math.min(max, baseDelay * Math.pow(2, count));\n\n    if (jitter) {\n      delay = Math.random() * delay;\n    }\n\n    return delay;\n  };\n}\n\nfunction buildRetryFunction(retryOptions) {\n  var _a = retryOptions || {},\n      retryIf = _a.retryIf,\n      _b = _a.max,\n      max = _b === void 0 ? 5 : _b;\n\n  return function retryFunction(count, operation, error) {\n    if (count >= max) return false;\n    return retryIf ? retryIf(error, operation) : !!error;\n  };\n}\n\nvar RetryableOperation = function () {\n  function RetryableOperation(operation, nextLink, delayFor, retryIf) {\n    var _this = this;\n\n    this.operation = operation;\n    this.nextLink = nextLink;\n    this.delayFor = delayFor;\n    this.retryIf = retryIf;\n    this.retryCount = 0;\n    this.values = [];\n    this.complete = false;\n    this.canceled = false;\n    this.observers = [];\n    this.currentSubscription = null;\n\n    this.onNext = function (value) {\n      _this.values.push(value);\n\n      for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {\n        var observer = _a[_i];\n        if (!observer) continue;\n        observer.next(value);\n      }\n    };\n\n    this.onComplete = function () {\n      _this.complete = true;\n\n      for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {\n        var observer = _a[_i];\n        if (!observer) continue;\n        observer.complete();\n      }\n    };\n\n    this.onError = function (error) {\n      return __awaiter(_this, void 0, void 0, function () {\n        var shouldRetry, _i, _a, observer;\n\n        return __generator(this, function (_b) {\n          switch (_b.label) {\n            case 0:\n              this.retryCount += 1;\n              return [4, this.retryIf(this.retryCount, this.operation, error)];\n\n            case 1:\n              shouldRetry = _b.sent();\n\n              if (shouldRetry) {\n                this.scheduleRetry(this.delayFor(this.retryCount, this.operation, error));\n                return [2];\n              }\n\n              this.error = error;\n\n              for (_i = 0, _a = this.observers; _i < _a.length; _i++) {\n                observer = _a[_i];\n                if (!observer) continue;\n                observer.error(error);\n              }\n\n              return [2];\n          }\n        });\n      });\n    };\n  }\n\n  RetryableOperation.prototype.subscribe = function (observer) {\n    if (this.canceled) {\n      throw new Error(\"Subscribing to a retryable link that was canceled is not supported\");\n    }\n\n    this.observers.push(observer);\n\n    for (var _i = 0, _a = this.values; _i < _a.length; _i++) {\n      var value = _a[_i];\n      observer.next(value);\n    }\n\n    if (this.complete) {\n      observer.complete();\n    } else if (this.error) {\n      observer.error(this.error);\n    }\n  };\n\n  RetryableOperation.prototype.unsubscribe = function (observer) {\n    var index = this.observers.indexOf(observer);\n\n    if (index < 0) {\n      throw new Error(\"RetryLink BUG! Attempting to unsubscribe unknown observer!\");\n    }\n\n    this.observers[index] = null;\n\n    if (this.observers.every(function (o) {\n      return o === null;\n    })) {\n      this.cancel();\n    }\n  };\n\n  RetryableOperation.prototype.start = function () {\n    if (this.currentSubscription) return;\n    this.try();\n  };\n\n  RetryableOperation.prototype.cancel = function () {\n    if (this.currentSubscription) {\n      this.currentSubscription.unsubscribe();\n    }\n\n    clearTimeout(this.timerId);\n    this.timerId = null;\n    this.currentSubscription = null;\n    this.canceled = true;\n  };\n\n  RetryableOperation.prototype.try = function () {\n    this.currentSubscription = this.nextLink(this.operation).subscribe({\n      next: this.onNext,\n      error: this.onError,\n      complete: this.onComplete\n    });\n  };\n\n  RetryableOperation.prototype.scheduleRetry = function (delay) {\n    var _this = this;\n\n    if (this.timerId) {\n      throw new Error(\"RetryLink BUG! Encountered overlapping retries\");\n    }\n\n    this.timerId = setTimeout(function () {\n      _this.timerId = null;\n\n      _this.try();\n    }, delay);\n  };\n\n  return RetryableOperation;\n}();\n\nvar RetryLink = function (_super) {\n  __extends(RetryLink, _super);\n\n  function RetryLink(options) {\n    var _this = _super.call(this) || this;\n\n    var _a = options || {},\n        attempts = _a.attempts,\n        delay = _a.delay;\n\n    _this.delayFor = typeof delay === 'function' ? delay : buildDelayFunction(delay);\n    _this.retryIf = typeof attempts === 'function' ? attempts : buildRetryFunction(attempts);\n    return _this;\n  }\n\n  RetryLink.prototype.request = function (operation, nextLink) {\n    var retryable = new RetryableOperation(operation, nextLink, this.delayFor, this.retryIf);\n    retryable.start();\n    return new Observable(function (observer) {\n      retryable.subscribe(observer);\n      return function () {\n        retryable.unsubscribe(observer);\n      };\n    });\n  };\n\n  return RetryLink;\n}(ApolloLink);\n\nexport { RetryLink };","/* eslint-disable */\nmodule.exports = function (config, makeThennable) {\n  if (makeThennable === false) return config;\n  var load = config.load;\n\n  config.then = function (cb) {\n    return load().then(function (res) {\n      return cb && cb(res);\n    });\n  };\n\n  config.catch = function (cb) {\n    return load().catch(function (e) {\n      return cb && cb(e);\n    });\n  };\n\n  return config;\n};\n\nvar isSet = false;\n\nfunction setHasPlugin() {\n  if (isSet) return;\n  var universal;\n  var isWebpack = typeof __webpack_require__ !== 'undefined';\n\n  try {\n    if (isWebpack) {\n      var weakId = require.resolveWeak('react-universal-component');\n\n      universal = __webpack_require__(weakId);\n    } else {\n      var nodeRequire = typeof __non_webpack_require__ === 'undefined' ? module.require : __non_webpack_require__;\n      universal = nodeRequire('react-universal-component');\n    }\n\n    if (universal) {\n      universal.setHasBabelPlugin();\n      isSet = true;\n    }\n  } catch (e) {}\n}\n\nsetHasPlugin();","module.exports = require('./dist/beaver-logger');\nmodule.exports.default = module.exports;","(function webpackUniversalModuleDefinition(root, factory) {\n  if (typeof exports === 'object' && typeof module === 'object') module.exports = factory();else if (typeof define === 'function' && define.amd) define(\"$logger\", [], factory);else if (typeof exports === 'object') exports[\"$logger\"] = factory();else root[\"$logger\"] = factory();\n})(this, function () {\n  return (\n    /******/\n    function (modules) {\n      // webpackBootstrap\n\n      /******/\n      // The module cache\n\n      /******/\n      var installedModules = {};\n      /******/\n      // The require function\n\n      /******/\n\n      function __webpack_require__(moduleId) {\n        /******/\n        // Check if module is in cache\n\n        /******/\n        if (installedModules[moduleId])\n          /******/\n          return installedModules[moduleId].exports;\n        /******/\n        // Create a new module (and put it into the cache)\n\n        /******/\n\n        var module = installedModules[moduleId] = {\n          /******/\n          exports: {},\n\n          /******/\n          id: moduleId,\n\n          /******/\n          loaded: false\n          /******/\n\n        };\n        /******/\n        // Execute the module function\n\n        /******/\n\n        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n        /******/\n        // Flag the module as loaded\n\n        /******/\n\n        module.loaded = true;\n        /******/\n        // Return the exports of the module\n\n        /******/\n\n        return module.exports;\n        /******/\n      }\n      /******/\n      // expose the modules object (__webpack_modules__)\n\n      /******/\n\n\n      __webpack_require__.m = modules;\n      /******/\n      // expose the module cache\n\n      /******/\n\n      __webpack_require__.c = installedModules;\n      /******/\n      // __webpack_public_path__\n\n      /******/\n\n      __webpack_require__.p = \"\";\n      /******/\n      // Load entry module and return exports\n\n      /******/\n\n      return __webpack_require__(0);\n      /******/\n    }(\n    /************************************************************************/\n\n    /******/\n    [\n    /* 0 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var _interface = __webpack_require__(1);\n\n      Object.keys(_interface).forEach(function (key) {\n        if (key === \"default\" || key === \"__esModule\") return;\n        Object.defineProperty(exports, key, {\n          enumerable: true,\n          get: function get() {\n            return _interface[key];\n          }\n        });\n      });\n\n      var INTERFACE = _interopRequireWildcard(_interface);\n\n      function _interopRequireWildcard(obj) {\n        if (obj && obj.__esModule) {\n          return obj;\n        } else {\n          var newObj = {};\n\n          if (obj != null) {\n            for (var key in obj) {\n              if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];\n            }\n          }\n\n          newObj['default'] = obj;\n          return newObj;\n        }\n      }\n\n      exports['default'] = INTERFACE;\n      /***/\n    },\n    /* 1 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var _logger = __webpack_require__(2);\n\n      Object.keys(_logger).forEach(function (key) {\n        if (key === \"default\" || key === \"__esModule\") return;\n        Object.defineProperty(exports, key, {\n          enumerable: true,\n          get: function get() {\n            return _logger[key];\n          }\n        });\n      });\n\n      var _init = __webpack_require__(11);\n\n      Object.keys(_init).forEach(function (key) {\n        if (key === \"default\" || key === \"__esModule\") return;\n        Object.defineProperty(exports, key, {\n          enumerable: true,\n          get: function get() {\n            return _init[key];\n          }\n        });\n      });\n\n      var _transitions = __webpack_require__(13);\n\n      Object.keys(_transitions).forEach(function (key) {\n        if (key === \"default\" || key === \"__esModule\") return;\n        Object.defineProperty(exports, key, {\n          enumerable: true,\n          get: function get() {\n            return _transitions[key];\n          }\n        });\n      });\n\n      var _builders = __webpack_require__(9);\n\n      Object.keys(_builders).forEach(function (key) {\n        if (key === \"default\" || key === \"__esModule\") return;\n        Object.defineProperty(exports, key, {\n          enumerable: true,\n          get: function get() {\n            return _builders[key];\n          }\n        });\n      });\n\n      var _config = __webpack_require__(10);\n\n      Object.keys(_config).forEach(function (key) {\n        if (key === \"default\" || key === \"__esModule\") return;\n        Object.defineProperty(exports, key, {\n          enumerable: true,\n          get: function get() {\n            return _config[key];\n          }\n        });\n      });\n      /***/\n    },\n    /* 2 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.track = exports.flush = exports.tracking = exports.buffer = undefined;\n      exports.getTransport = getTransport;\n      exports.setTransport = setTransport;\n      exports.print = print;\n      exports.immediateFlush = immediateFlush;\n      exports.log = log;\n      exports.prefix = prefix;\n      exports.debug = debug;\n      exports.info = info;\n      exports.warn = warn;\n      exports.error = error;\n\n      var _util = __webpack_require__(3);\n\n      var _builders = __webpack_require__(9);\n\n      var _config = __webpack_require__(10);\n\n      var buffer = exports.buffer = [];\n      var tracking = exports.tracking = [];\n\n      var transport = function transport(headers, data, options) {\n        return (0, _util.ajax)('post', _config.config.uri, headers, data, options);\n      };\n\n      function getTransport() {\n        return transport;\n      }\n\n      function setTransport(newTransport) {\n        transport = newTransport;\n      }\n\n      var loaded = false;\n      setTimeout(function () {\n        loaded = true;\n      }, 1);\n\n      function print(level, event, payload) {\n        if (typeof window === 'undefined' || !window.console || !window.console.log) {\n          return;\n        }\n\n        if (!loaded) {\n          return setTimeout(function () {\n            return print(level, event, payload);\n          }, 1);\n        }\n\n        var logLevel = _config.config.logLevel;\n\n        if (window.LOG_LEVEL) {\n          logLevel = window.LOG_LEVEL;\n        }\n\n        if (_config.logLevels.indexOf(level) > _config.logLevels.indexOf(logLevel)) {\n          return;\n        }\n\n        payload = payload || {};\n        var args = [event];\n\n        if ((0, _util.isIE)()) {\n          payload = JSON.stringify(payload);\n        }\n\n        args.push(payload);\n\n        if (payload.error || payload.warning) {\n          args.push('\\n\\n', payload.error || payload.warning);\n        }\n\n        try {\n          if (window.console[level] && window.console[level].apply) {\n            window.console[level].apply(window.console, args);\n          } else if (window.console.log && window.console.log.apply) {\n            window.console.log.apply(window.console, args);\n          }\n        } catch (err) {// pass\n        }\n      }\n\n      function immediateFlush() {\n        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n            _ref$fireAndForget = _ref.fireAndForget,\n            fireAndForget = _ref$fireAndForget === undefined ? false : _ref$fireAndForget;\n\n        if (typeof window === 'undefined') {\n          return;\n        }\n\n        if (!_config.config.uri) {\n          return;\n        }\n\n        var hasBuffer = buffer.length;\n        var hasTracking = tracking.length;\n\n        if (!hasBuffer && !hasTracking) {\n          return;\n        }\n\n        var meta = {};\n\n        for (var _iterator = _builders.metaBuilders, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n          var _ref2;\n\n          if (_isArray) {\n            if (_i >= _iterator.length) break;\n            _ref2 = _iterator[_i++];\n          } else {\n            _i = _iterator.next();\n            if (_i.done) break;\n            _ref2 = _i.value;\n          }\n\n          var builder = _ref2;\n\n          try {\n            (0, _util.extend)(meta, builder(meta), false);\n          } catch (err) {\n            console.error('Error in custom meta builder:', err.stack || err.toString());\n          }\n        }\n\n        var headers = {};\n\n        for (var _iterator2 = _builders.headerBuilders, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {\n          var _ref3;\n\n          if (_isArray2) {\n            if (_i2 >= _iterator2.length) break;\n            _ref3 = _iterator2[_i2++];\n          } else {\n            _i2 = _iterator2.next();\n            if (_i2.done) break;\n            _ref3 = _i2.value;\n          }\n\n          var _builder = _ref3;\n\n          try {\n            (0, _util.extend)(headers, _builder(headers), false);\n          } catch (err) {\n            console.error('Error in custom header builder:', err.stack || err.toString());\n          }\n        }\n\n        var events = buffer;\n        var req = transport(headers, {\n          events: events,\n          meta: meta,\n          tracking: tracking\n        }, {\n          fireAndForget: fireAndForget\n        });\n        exports.buffer = buffer = [];\n        exports.tracking = tracking = [];\n        return req;\n      }\n\n      var _flush = (0, _util.promiseDebounce)(immediateFlush, _config.config.debounceInterval);\n\n      exports.flush = _flush;\n\n      function enqueue(level, event, payload) {\n        buffer.push({\n          level: level,\n          event: event,\n          payload: payload\n        });\n\n        if (_config.config.autoLog.indexOf(level) > -1) {\n          _flush();\n        }\n      }\n\n      function log(level, event, payload) {\n        if (typeof window === 'undefined') {\n          return;\n        }\n\n        if (_config.config.prefix) {\n          event = _config.config.prefix + '_' + event;\n        }\n\n        payload = payload || {};\n\n        if (typeof payload === 'string') {\n          payload = {\n            message: payload\n          };\n        } else if (payload instanceof Error) {\n          payload = {\n            error: payload.stack || payload.toString()\n          };\n        }\n\n        try {\n          JSON.stringify(payload);\n        } catch (err) {\n          return;\n        }\n\n        payload.timestamp = Date.now();\n\n        for (var _iterator3 = _builders.payloadBuilders, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {\n          var _ref4;\n\n          if (_isArray3) {\n            if (_i3 >= _iterator3.length) break;\n            _ref4 = _iterator3[_i3++];\n          } else {\n            _i3 = _iterator3.next();\n            if (_i3.done) break;\n            _ref4 = _i3.value;\n          }\n\n          var builder = _ref4;\n\n          try {\n            (0, _util.extend)(payload, builder(payload), false);\n          } catch (err) {\n            console.error('Error in custom payload builder:', err.stack || err.toString());\n          }\n        }\n\n        if (!_config.config.silent) {\n          print(level, event, payload);\n        }\n\n        if (buffer.length === _config.config.sizeLimit) {\n          enqueue('info', 'logger_max_buffer_length');\n        } else if (buffer.length < _config.config.sizeLimit) {\n          enqueue(level, event, payload);\n        }\n      }\n\n      function prefix(name) {\n        return {\n          debug: function debug(event, payload) {\n            return log('debug', name + '_' + event, payload);\n          },\n          info: function info(event, payload) {\n            return log('info', name + '_' + event, payload);\n          },\n          warn: function warn(event, payload) {\n            return log('warn', name + '_' + event, payload);\n          },\n          error: function error(event, payload) {\n            return log('error', name + '_' + event, payload);\n          },\n          track: function track(payload) {\n            return _track(payload);\n          },\n          flush: function flush() {\n            return _flush();\n          }\n        };\n      }\n\n      function debug(event, payload) {\n        return log('debug', event, payload);\n      }\n\n      function info(event, payload) {\n        return log('info', event, payload);\n      }\n\n      function warn(event, payload) {\n        return log('warn', event, payload);\n      }\n\n      function error(event, payload) {\n        return log('error', event, payload);\n      }\n\n      function _track(payload) {\n        if (typeof window === 'undefined') {\n          return;\n        }\n\n        if (payload) {\n          try {\n            JSON.stringify(payload);\n          } catch (err) {\n            return;\n          }\n\n          for (var _iterator4 = _builders.trackingBuilders, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {\n            var _ref5;\n\n            if (_isArray4) {\n              if (_i4 >= _iterator4.length) break;\n              _ref5 = _iterator4[_i4++];\n            } else {\n              _i4 = _iterator4.next();\n              if (_i4.done) break;\n              _ref5 = _i4.value;\n            }\n\n            var builder = _ref5;\n\n            try {\n              (0, _util.extend)(payload, builder(payload), false);\n            } catch (err) {\n              console.error('Error in custom tracking builder:', err.stack || err.toString());\n            }\n          }\n\n          print('debug', 'tracking', payload);\n          tracking.push(payload);\n        }\n      }\n\n      exports.track = _track;\n      /***/\n    },\n    /* 3 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.extend = extend;\n      exports.isSameProtocol = isSameProtocol;\n      exports.isSameDomain = isSameDomain;\n      exports.ajax = ajax;\n      exports.promiseDebounce = promiseDebounce;\n      exports.onWindowReady = onWindowReady;\n      exports.safeInterval = safeInterval;\n      exports.uniqueID = uniqueID;\n      exports.isIE = isIE;\n\n      var _src = __webpack_require__(4);\n\n      function extend(dest, src) {\n        var over = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n        dest = dest || {};\n        src = src || {};\n\n        for (var i in src) {\n          if (src.hasOwnProperty(i)) {\n            if (over || !dest.hasOwnProperty(i)) {\n              dest[i] = src[i];\n            }\n          }\n        }\n\n        return dest;\n      }\n\n      function isSameProtocol(url) {\n        return window.location.protocol === url.split('/')[0];\n      }\n\n      function isSameDomain(url) {\n        var match = url.match(/https?:\\/\\/[^/]+/);\n\n        if (!match) {\n          return true;\n        }\n\n        return match[0] === window.location.protocol + '//' + window.location.host;\n      }\n\n      function ajax(method, url) {\n        var headers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n        var data = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n\n        var _ref = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},\n            _ref$fireAndForget = _ref.fireAndForget,\n            fireAndForget = _ref$fireAndForget === undefined ? false : _ref$fireAndForget;\n\n        return new _src.ZalgoPromise(function (resolve) {\n          var XRequest = window.XMLHttpRequest || window.ActiveXObject;\n\n          if (window.XDomainRequest && !isSameDomain(url)) {\n            if (!isSameProtocol(url)) {\n              return resolve();\n            }\n\n            XRequest = window.XDomainRequest;\n          }\n\n          var req = new XRequest('MSXML2.XMLHTTP.3.0');\n          req.open(method.toUpperCase(), url, true);\n\n          if (typeof req.setRequestHeader === 'function') {\n            req.setRequestHeader('X-Requested-With', 'XMLHttpRequest');\n            req.setRequestHeader('Content-type', 'application/json');\n\n            for (var headerName in headers) {\n              if (headers.hasOwnProperty(headerName)) {\n                req.setRequestHeader(headerName, headers[headerName]);\n              }\n            }\n          }\n\n          if (fireAndForget) {\n            resolve();\n          } else {\n            req.onreadystatechange = function () {\n              if (req.readyState > 3) {\n                resolve();\n              }\n            };\n          }\n\n          req.send(JSON.stringify(data).replace(/&/g, '%26'));\n        });\n      }\n\n      function promiseDebounce(method, interval) {\n        var debounce = {};\n        return function () {\n          var args = arguments;\n\n          if (debounce.timeout) {\n            clearTimeout(debounce.timeout);\n            delete debounce.timeout;\n          }\n\n          debounce.timeout = setTimeout(function () {\n            var resolver = debounce.resolver;\n            var rejector = debounce.rejector;\n            delete debounce.promise;\n            delete debounce.resolver;\n            delete debounce.rejector;\n            delete debounce.timeout;\n            return _src.ZalgoPromise.resolve().then(function () {\n              return method.apply(null, args);\n            }).then(resolver, rejector);\n          }, interval);\n          debounce.promise = debounce.promise || new _src.ZalgoPromise(function (resolver, rejector) {\n            debounce.resolver = resolver;\n            debounce.rejector = rejector;\n          });\n          return debounce.promise;\n        };\n      }\n\n      function onWindowReady() {\n        return new _src.ZalgoPromise(function (resolve) {\n          if (typeof document !== 'undefined' && document.readyState === 'complete') {\n            resolve();\n          }\n\n          window.addEventListener('load', resolve);\n        });\n      }\n\n      function safeInterval(method, time) {\n        var timeout = void 0;\n\n        function loop() {\n          timeout = setTimeout(function () {\n            method();\n            loop();\n          }, time);\n        }\n\n        loop();\n        return {\n          cancel: function cancel() {\n            clearTimeout(timeout);\n          }\n        };\n      }\n\n      function uniqueID() {\n        var chars = '0123456789abcdef';\n        return 'xxxxxxxxxx'.replace(/./g, function () {\n          return chars.charAt(Math.floor(Math.random() * chars.length));\n        });\n      }\n\n      function isIE() {\n        return Boolean(window.document.documentMode);\n      }\n      /***/\n\n    },\n    /* 4 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n\n      var _promise = __webpack_require__(5);\n\n      Object.defineProperty(exports, 'ZalgoPromise', {\n        enumerable: true,\n        get: function get() {\n          return _promise.ZalgoPromise;\n        }\n      });\n      /***/\n    },\n    /* 5 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.ZalgoPromise = undefined;\n\n      var _createClass = function () {\n        function defineProperties(target, props) {\n          for (var i = 0; i < props.length; i++) {\n            var descriptor = props[i];\n            descriptor.enumerable = descriptor.enumerable || false;\n            descriptor.configurable = true;\n            if (\"value\" in descriptor) descriptor.writable = true;\n            Object.defineProperty(target, descriptor.key, descriptor);\n          }\n        }\n\n        return function (Constructor, protoProps, staticProps) {\n          if (protoProps) defineProperties(Constructor.prototype, protoProps);\n          if (staticProps) defineProperties(Constructor, staticProps);\n          return Constructor;\n        };\n      }();\n\n      var _utils = __webpack_require__(6);\n\n      var _exceptions = __webpack_require__(7);\n\n      var _flush = __webpack_require__(8);\n\n      function _classCallCheck(instance, Constructor) {\n        if (!(instance instanceof Constructor)) {\n          throw new TypeError(\"Cannot call a class as a function\");\n        }\n      }\n\n      var ZalgoPromise = function () {\n        function ZalgoPromise(handler) {\n          var _this = this;\n\n          _classCallCheck(this, ZalgoPromise);\n\n          this.resolved = false;\n          this.rejected = false;\n          this.errorHandled = false;\n          this.handlers = [];\n\n          if (handler) {\n            var _result = void 0;\n\n            var _error = void 0;\n\n            var resolved = false;\n            var rejected = false;\n            var isAsync = false;\n            (0, _flush.startActive)();\n\n            try {\n              handler(function (res) {\n                if (isAsync) {\n                  _this.resolve(res);\n                } else {\n                  resolved = true;\n                  _result = res;\n                }\n              }, function (err) {\n                if (isAsync) {\n                  _this.reject(err);\n                } else {\n                  rejected = true;\n                  _error = err;\n                }\n              });\n            } catch (err) {\n              (0, _flush.endActive)();\n              this.reject(err);\n              return;\n            }\n\n            (0, _flush.endActive)();\n            isAsync = true;\n\n            if (resolved) {\n              // $FlowFixMe\n              this.resolve(_result);\n            } else if (rejected) {\n              this.reject(_error);\n            }\n          }\n\n          if (false) {\n            try {\n              throw new Error('ZalgoPromise');\n            } catch (err) {\n              this.stack = err.stack;\n            }\n          }\n        }\n\n        _createClass(ZalgoPromise, [{\n          key: 'resolve',\n          value: function resolve(result) {\n            if (this.resolved || this.rejected) {\n              return this;\n            }\n\n            if ((0, _utils.isPromise)(result)) {\n              throw new Error('Can not resolve promise with another promise');\n            }\n\n            this.resolved = true;\n            this.value = result;\n            this.dispatch();\n            return this;\n          }\n        }, {\n          key: 'reject',\n          value: function reject(error) {\n            var _this2 = this;\n\n            if (this.resolved || this.rejected) {\n              return this;\n            }\n\n            if ((0, _utils.isPromise)(error)) {\n              throw new Error('Can not reject promise with another promise');\n            }\n\n            if (!error) {\n              // $FlowFixMe\n              var _err = error && typeof error.toString === 'function' ? error.toString() : Object.prototype.toString.call(error);\n\n              error = new Error('Expected reject to be called with Error, got ' + _err);\n            }\n\n            this.rejected = true;\n            this.error = error;\n\n            if (!this.errorHandled) {\n              setTimeout(function () {\n                if (!_this2.errorHandled) {\n                  (0, _exceptions.dispatchPossiblyUnhandledError)(error, _this2);\n                }\n              }, 1);\n            }\n\n            this.dispatch();\n            return this;\n          }\n        }, {\n          key: 'asyncReject',\n          value: function asyncReject(error) {\n            this.errorHandled = true;\n            this.reject(error);\n            return this;\n          }\n        }, {\n          key: 'dispatch',\n          value: function dispatch() {\n            var _this3 = this;\n\n            var dispatching = this.dispatching,\n                resolved = this.resolved,\n                rejected = this.rejected,\n                handlers = this.handlers;\n\n            if (dispatching) {\n              return;\n            }\n\n            if (!resolved && !rejected) {\n              return;\n            }\n\n            this.dispatching = true;\n            (0, _flush.startActive)();\n\n            var _loop = function _loop(i) {\n              var _handlers$i = handlers[i],\n                  onSuccess = _handlers$i.onSuccess,\n                  onError = _handlers$i.onError,\n                  promise = _handlers$i.promise;\n              var result = void 0;\n\n              if (resolved) {\n                try {\n                  result = onSuccess ? onSuccess(_this3.value) : _this3.value;\n                } catch (err) {\n                  promise.reject(err);\n                  return 'continue';\n                }\n              } else if (rejected) {\n                if (!onError) {\n                  promise.reject(_this3.error);\n                  return 'continue';\n                }\n\n                try {\n                  result = onError(_this3.error);\n                } catch (err) {\n                  promise.reject(err);\n                  return 'continue';\n                }\n              }\n\n              if (result instanceof ZalgoPromise && (result.resolved || result.rejected)) {\n                if (result.resolved) {\n                  promise.resolve(result.value);\n                } else {\n                  promise.reject(result.error);\n                }\n\n                result.errorHandled = true;\n              } else if ((0, _utils.isPromise)(result)) {\n                if (result instanceof ZalgoPromise && (result.resolved || result.rejected)) {\n                  if (result.resolved) {\n                    promise.resolve(result.value);\n                  } else {\n                    promise.reject(result.error);\n                  }\n                } else {\n                  // $FlowFixMe\n                  result.then(function (res) {\n                    promise.resolve(res);\n                  }, function (err) {\n                    promise.reject(err);\n                  });\n                }\n              } else {\n                promise.resolve(result);\n              }\n            };\n\n            for (var i = 0; i < handlers.length; i++) {\n              var _ret = _loop(i);\n\n              if (_ret === 'continue') continue;\n            }\n\n            handlers.length = 0;\n            this.dispatching = false;\n            (0, _flush.endActive)();\n          }\n        }, {\n          key: 'then',\n          value: function then(onSuccess, onError) {\n            if (onSuccess && typeof onSuccess !== 'function' && !onSuccess.call) {\n              throw new Error('Promise.then expected a function for success handler');\n            }\n\n            if (onError && typeof onError !== 'function' && !onError.call) {\n              throw new Error('Promise.then expected a function for error handler');\n            }\n\n            var promise = new ZalgoPromise();\n            this.handlers.push({\n              promise: promise,\n              onSuccess: onSuccess,\n              onError: onError\n            });\n            this.errorHandled = true;\n            this.dispatch();\n            return promise;\n          }\n        }, {\n          key: 'catch',\n          value: function _catch(onError) {\n            return this.then(undefined, onError);\n          }\n        }, {\n          key: 'finally',\n          value: function _finally(onFinally) {\n            if (onFinally && typeof onFinally !== 'function' && !onFinally.call) {\n              throw new Error('Promise.finally expected a function');\n            }\n\n            return this.then(function (result) {\n              return ZalgoPromise['try'](onFinally).then(function () {\n                return result;\n              });\n            }, function (err) {\n              return ZalgoPromise['try'](onFinally).then(function () {\n                throw err;\n              });\n            });\n          }\n        }, {\n          key: 'timeout',\n          value: function timeout(time, err) {\n            var _this4 = this;\n\n            if (this.resolved || this.rejected) {\n              return this;\n            }\n\n            var timeout = setTimeout(function () {\n              if (_this4.resolved || _this4.rejected) {\n                return;\n              }\n\n              _this4.reject(err || new Error('Promise timed out after ' + time + 'ms'));\n            }, time);\n            return this.then(function (result) {\n              clearTimeout(timeout);\n              return result;\n            });\n          } // $FlowFixMe\n\n        }, {\n          key: 'toPromise',\n          value: function toPromise() {\n            // $FlowFixMe\n            if (typeof Promise === 'undefined') {\n              throw new TypeError('Could not find Promise');\n            } // $FlowFixMe\n\n\n            return Promise.resolve(this); // eslint-disable-line compat/compat\n          }\n        }], [{\n          key: 'resolve',\n          value: function resolve(value) {\n            if (value instanceof ZalgoPromise) {\n              return value;\n            }\n\n            if ((0, _utils.isPromise)(value)) {\n              // $FlowFixMe\n              return new ZalgoPromise(function (resolve, reject) {\n                return value.then(resolve, reject);\n              });\n            }\n\n            return new ZalgoPromise().resolve(value);\n          }\n        }, {\n          key: 'reject',\n          value: function reject(error) {\n            return new ZalgoPromise().reject(error);\n          }\n        }, {\n          key: 'asyncReject',\n          value: function asyncReject(error) {\n            return new ZalgoPromise().asyncReject(error);\n          }\n        }, {\n          key: 'all',\n          value: function all(promises) {\n            // eslint-disable-line no-undef\n            var promise = new ZalgoPromise();\n            var count = promises.length;\n            var results = [];\n\n            if (!count) {\n              promise.resolve(results);\n              return promise;\n            }\n\n            var _loop2 = function _loop2(i) {\n              var prom = promises[i];\n\n              if (prom instanceof ZalgoPromise) {\n                if (prom.resolved) {\n                  results[i] = prom.value;\n                  count -= 1;\n                  return 'continue';\n                }\n              } else if (!(0, _utils.isPromise)(prom)) {\n                results[i] = prom;\n                count -= 1;\n                return 'continue';\n              }\n\n              ZalgoPromise.resolve(prom).then(function (result) {\n                results[i] = result;\n                count -= 1;\n\n                if (count === 0) {\n                  promise.resolve(results);\n                }\n              }, function (err) {\n                promise.reject(err);\n              });\n            };\n\n            for (var i = 0; i < promises.length; i++) {\n              var _ret2 = _loop2(i);\n\n              if (_ret2 === 'continue') continue;\n            }\n\n            if (count === 0) {\n              promise.resolve(results);\n            }\n\n            return promise;\n          }\n        }, {\n          key: 'hash',\n          value: function hash(promises) {\n            // eslint-disable-line no-undef\n            var result = {};\n            return ZalgoPromise.all(Object.keys(promises).map(function (key) {\n              return ZalgoPromise.resolve(promises[key]).then(function (value) {\n                result[key] = value;\n              });\n            })).then(function () {\n              return result;\n            });\n          }\n        }, {\n          key: 'map',\n          value: function map(items, method) {\n            // $FlowFixMe\n            return ZalgoPromise.all(items.map(method));\n          }\n        }, {\n          key: 'onPossiblyUnhandledException',\n          value: function onPossiblyUnhandledException(handler) {\n            return (0, _exceptions.onPossiblyUnhandledException)(handler);\n          }\n        }, {\n          key: 'try',\n          value: function _try(method, context, args) {\n            if (method && typeof method !== 'function' && !method.call) {\n              throw new Error('Promise.try expected a function');\n            }\n\n            var result = void 0;\n            (0, _flush.startActive)();\n\n            try {\n              // $FlowFixMe\n              result = method.apply(context, args || []);\n            } catch (err) {\n              (0, _flush.endActive)();\n              return ZalgoPromise.reject(err);\n            }\n\n            (0, _flush.endActive)();\n            return ZalgoPromise.resolve(result);\n          }\n        }, {\n          key: 'delay',\n          value: function delay(_delay) {\n            return new ZalgoPromise(function (resolve) {\n              setTimeout(resolve, _delay);\n            });\n          }\n        }, {\n          key: 'isPromise',\n          value: function isPromise(value) {\n            if (value && value instanceof ZalgoPromise) {\n              return true;\n            }\n\n            return (0, _utils.isPromise)(value);\n          }\n        }, {\n          key: 'flush',\n          value: function flush() {\n            return (0, _flush.awaitActive)(ZalgoPromise);\n          }\n        }]);\n\n        return ZalgoPromise;\n      }();\n\n      exports.ZalgoPromise = ZalgoPromise;\n      /***/\n    },\n    /* 6 */\n\n    /***/\n    function (module, exports) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.isPromise = isPromise;\n\n      function isPromise(item) {\n        try {\n          if (!item) {\n            return false;\n          }\n\n          if (typeof Promise !== 'undefined' && item instanceof Promise) {\n            return true;\n          }\n\n          if (typeof window !== 'undefined' && window.Window && item instanceof window.Window) {\n            return false;\n          }\n\n          if (typeof window !== 'undefined' && window.constructor && item instanceof window.constructor) {\n            return false;\n          }\n\n          var _toString = {}.toString;\n\n          if (_toString) {\n            var name = _toString.call(item);\n\n            if (name === '[object Window]' || name === '[object global]' || name === '[object DOMWindow]') {\n              return false;\n            }\n          }\n\n          if (typeof item.then === 'function') {\n            return true;\n          }\n        } catch (err) {\n          return false;\n        }\n\n        return false;\n      }\n      /***/\n\n    },\n    /* 7 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.dispatchPossiblyUnhandledError = dispatchPossiblyUnhandledError;\n      exports.onPossiblyUnhandledException = onPossiblyUnhandledException;\n      var dispatchedErrors = [];\n      var possiblyUnhandledPromiseHandlers = [];\n\n      function dispatchPossiblyUnhandledError(err, promise) {\n        if (dispatchedErrors.indexOf(err) !== -1) {\n          return;\n        }\n\n        dispatchedErrors.push(err);\n        setTimeout(function () {\n          if (false) {\n            // $FlowFixMe\n            throw new Error((err.stack || err.toString()) + '\\n\\nFrom promise:\\n\\n' + promise.stack);\n          }\n\n          throw err;\n        }, 1);\n\n        for (var j = 0; j < possiblyUnhandledPromiseHandlers.length; j++) {\n          // $FlowFixMe\n          possiblyUnhandledPromiseHandlers[j](err, promise);\n        }\n      }\n\n      function onPossiblyUnhandledException(handler) {\n        possiblyUnhandledPromiseHandlers.push(handler);\n        return {\n          cancel: function cancel() {\n            possiblyUnhandledPromiseHandlers.splice(possiblyUnhandledPromiseHandlers.indexOf(handler), 1);\n          }\n        };\n      }\n      /***/\n\n    },\n    /* 8 */\n\n    /***/\n    function (module, exports) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.startActive = startActive;\n      exports.endActive = endActive;\n      exports.awaitActive = awaitActive;\n      var activeCount = 0;\n      var flushPromise = void 0;\n\n      function flushActive() {\n        if (!activeCount && flushPromise) {\n          var promise = flushPromise;\n          flushPromise = null;\n          promise.resolve();\n        }\n      }\n\n      function startActive() {\n        activeCount += 1;\n      }\n\n      function endActive() {\n        activeCount -= 1;\n        flushActive();\n      }\n\n      function awaitActive(Zalgo) {\n        // eslint-disable-line no-undef\n        var promise = flushPromise = flushPromise || new Zalgo();\n        flushActive();\n        return promise;\n      }\n      /***/\n\n    },\n    /* 9 */\n\n    /***/\n    function (module, exports) {\n      \"use strict\";\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.addPayloadBuilder = addPayloadBuilder;\n      exports.addMetaBuilder = addMetaBuilder;\n      exports.addTrackingBuilder = addTrackingBuilder;\n      exports.addHeaderBuilder = addHeaderBuilder;\n      var payloadBuilders = exports.payloadBuilders = [];\n      var metaBuilders = exports.metaBuilders = [];\n      var trackingBuilders = exports.trackingBuilders = [];\n      var headerBuilders = exports.headerBuilders = [];\n\n      function addPayloadBuilder(builder) {\n        payloadBuilders.push(builder);\n      }\n\n      function addMetaBuilder(builder) {\n        metaBuilders.push(builder);\n      }\n\n      function addTrackingBuilder(builder) {\n        trackingBuilders.push(builder);\n      }\n\n      function addHeaderBuilder(builder) {\n        headerBuilders.push(builder);\n      }\n      /***/\n\n    },\n    /* 10 */\n\n    /***/\n    function (module, exports) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      var config = exports.config = {\n        uri: '',\n        prefix: '',\n        initial_state_name: 'init',\n        flushInterval: 10 * 60 * 1000,\n        debounceInterval: 10,\n        sizeLimit: 300,\n        // Supress `console.log`s when `true`\n        // Recommended for production usage\n        silent: false,\n        heartbeat: true,\n        heartbeatConsoleLog: true,\n        heartbeatInterval: 5000,\n        heartbeatTooBusy: false,\n        heartbeatTooBusyThreshold: 10000,\n        logLevel: 'warn',\n        autoLog: ['warn', 'error'],\n        logUnload: true,\n        logPerformance: true\n      };\n      var logLevels = exports.logLevels = ['error', 'warn', 'info', 'debug'];\n      /***/\n    },\n    /* 11 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.init = init;\n\n      var _config = __webpack_require__(10);\n\n      var _util = __webpack_require__(3);\n\n      var _performance = __webpack_require__(12);\n\n      var _logger = __webpack_require__(2);\n\n      var initiated = false;\n\n      function init(conf) {\n        (0, _util.extend)(_config.config, conf || {});\n\n        if (initiated) {\n          return;\n        }\n\n        initiated = true;\n\n        if (_config.config.logPerformance) {\n          (0, _performance.initPerformance)();\n        }\n\n        if (_config.config.heartbeat) {\n          (0, _performance.initHeartBeat)();\n        }\n\n        if (_config.config.logUnload) {\n          window.addEventListener('beforeunload', function () {\n            (0, _logger.info)('window_beforeunload');\n            (0, _logger.immediateFlush)({\n              fireAndForget: true\n            });\n          });\n          window.addEventListener('unload', function () {\n            (0, _logger.info)('window_unload');\n            (0, _logger.immediateFlush)({\n              fireAndForget: true\n            });\n          });\n        }\n\n        if (_config.config.flushInterval) {\n          setInterval(_logger.flush, _config.config.flushInterval);\n        }\n\n        if (window.beaverLogQueue) {\n          window.beaverLogQueue.forEach(function (payload) {\n            (0, _logger.log)(payload.level, payload.event, payload);\n          });\n          delete window.beaverLogQueue;\n        }\n      }\n      /***/\n\n    },\n    /* 12 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.reqTimer = exports.clientTimer = undefined;\n      exports.now = now;\n      exports.reqStartElapsed = reqStartElapsed;\n      exports.initHeartBeat = initHeartBeat;\n      exports.initPerformance = initPerformance;\n\n      var _config = __webpack_require__(10);\n\n      var _logger = __webpack_require__(2);\n\n      var _builders = __webpack_require__(9);\n\n      var _util = __webpack_require__(3);\n\n      var enablePerformance = window && window.performance && performance.now && performance.timing && performance.timing.connectEnd && performance.timing.navigationStart && Math.abs(performance.now() - Date.now()) > 1000 && performance.now() - (performance.timing.connectEnd - performance.timing.navigationStart) > 0;\n\n      function now() {\n        if (enablePerformance) {\n          return performance.now();\n        } else {\n          return Date.now();\n        }\n      }\n\n      function timer(startTime) {\n        startTime = startTime !== undefined ? startTime : now();\n        return {\n          startTime: startTime,\n          elapsed: function elapsed() {\n            return parseInt(now() - startTime, 10);\n          },\n          reset: function reset() {\n            startTime = now();\n          }\n        };\n      }\n\n      function reqStartElapsed() {\n        if (enablePerformance) {\n          var timing = window.performance.timing;\n          return parseInt(timing.connectEnd - timing.navigationStart, 10);\n        }\n      }\n\n      var clientTimer = exports.clientTimer = timer();\n      var reqTimer = exports.reqTimer = timer(reqStartElapsed());\n\n      function initHeartBeat() {\n        var heartBeatTimer = timer();\n        var heartbeatCount = 0;\n        (0, _util.safeInterval)(function () {\n          if (_config.config.heartbeatMaxThreshold && heartbeatCount > _config.config.heartbeatMaxThreshold) {\n            return;\n          }\n\n          heartbeatCount += 1;\n          var elapsed = heartBeatTimer.elapsed();\n          var lag = elapsed - _config.config.heartbeatInterval;\n          var heartbeatPayload = {\n            count: heartbeatCount,\n            elapsed: elapsed\n          };\n\n          if (_config.config.heartbeatTooBusy) {\n            heartbeatPayload.lag = lag;\n\n            if (lag >= _config.config.heartbeatTooBusyThreshold) {\n              (0, _logger.info)('toobusy', heartbeatPayload, {\n                noConsole: !_config.config.heartbeatConsoleLog\n              });\n            }\n          }\n\n          (0, _logger.info)('heartbeat', heartbeatPayload, {\n            noConsole: !_config.config.heartbeatConsoleLog\n          });\n        }, _config.config.heartbeatInterval);\n      }\n\n      function initPerformance() {\n        if (!enablePerformance) {\n          return (0, _logger.info)('no_performance_data');\n        }\n\n        (0, _builders.addPayloadBuilder)(function () {\n          var payload = {};\n          payload.client_elapsed = clientTimer.elapsed();\n\n          if (enablePerformance) {\n            payload.req_elapsed = reqTimer.elapsed();\n          }\n\n          return payload;\n        });\n        (0, _util.onWindowReady)().then(function () {\n          var keys = ['connectEnd', 'connectStart', 'domComplete', 'domContentLoadedEventEnd', 'domContentLoadedEventStart', 'domInteractive', 'domLoading', 'domainLookupEnd', 'domainLookupStart', 'fetchStart', 'loadEventEnd', 'loadEventStart', 'navigationStart', 'redirectEnd', 'redirectStart', 'requestStart', 'responseEnd', 'responseStart', 'secureConnectionStart', 'unloadEventEnd', 'unloadEventStart'];\n          var timing = {};\n          keys.forEach(function (key) {\n            timing[key] = parseInt(window.performance.timing[key], 10) || 0;\n          });\n          var offset = timing.connectEnd - timing.navigationStart;\n\n          if (timing.connectEnd) {\n            Object.keys(timing).forEach(function (name) {\n              var time = timing[name];\n\n              if (time) {\n                (0, _logger.info)('timing_' + name, {\n                  client_elapsed: parseInt(time - timing.connectEnd - (clientTimer.startTime - offset), 10),\n                  req_elapsed: parseInt(time - timing.connectEnd, 10)\n                });\n              }\n            });\n          }\n\n          (0, _logger.info)('timing', timing);\n          (0, _logger.info)('memory', window.performance.memory);\n          (0, _logger.info)('navigation', window.performance.navigation);\n\n          if (window.performance.getEntries) {\n            window.performance.getEntries().forEach(function (resource) {\n              if (['link', 'script', 'img', 'css'].indexOf(resource.initiatorType) > -1) {\n                (0, _logger.info)(resource.initiatorType, resource);\n              }\n            });\n          }\n        });\n      }\n      /***/\n\n    },\n    /* 13 */\n\n    /***/\n    function (module, exports, __webpack_require__) {\n      'use strict';\n\n      Object.defineProperty(exports, \"__esModule\", {\n        value: true\n      });\n      exports.startTransition = startTransition;\n      exports.endTransition = endTransition;\n      exports.transition = transition;\n\n      var _performance = __webpack_require__(12);\n\n      var _logger = __webpack_require__(2);\n\n      var _builders = __webpack_require__(9);\n\n      var _util = __webpack_require__(3);\n\n      var _config = __webpack_require__(10);\n\n      var windowID = (0, _util.uniqueID)();\n      var pageID = (0, _util.uniqueID)();\n      var currentState = _config.config.initial_state_name;\n      var startTime = void 0;\n\n      function startTransition() {\n        startTime = (0, _performance.now)();\n      }\n\n      function endTransition(toState) {\n        startTime = startTime || (0, _performance.reqStartElapsed)();\n        var currentTime = (0, _performance.now)();\n        var elapsedTime = void 0;\n\n        if (startTime !== undefined) {\n          elapsedTime = parseInt(currentTime - startTime, 0);\n        }\n\n        var transitionName = 'transition_' + currentState + '_to_' + toState;\n        (0, _logger.info)(transitionName, {\n          duration: elapsedTime\n        });\n        (0, _logger.track)({\n          transition: transitionName,\n          transition_time: elapsedTime\n        });\n        (0, _logger.immediateFlush)();\n        startTime = currentTime;\n        currentState = toState;\n        pageID = (0, _util.uniqueID)();\n      }\n\n      function transition(toState) {\n        startTransition();\n        endTransition(toState);\n      }\n\n      (0, _builders.addPayloadBuilder)(function () {\n        return {\n          windowID: windowID,\n          pageID: pageID\n        };\n      });\n      (0, _builders.addMetaBuilder)(function () {\n        return {\n          state: 'ui_' + currentState\n        };\n      });\n      /***/\n    }\n    /******/\n    ])\n  );\n});\n\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}\n\nfunction isNumberValue(value) {\n  return ['IntValue', 'FloatValue'].indexOf(value.kind) > -1;\n}\n\nfunction isStringValue(value) {\n  return value.kind === 'StringValue';\n}\n\nfunction isBooleanValue(value) {\n  return value.kind === 'BooleanValue';\n}\n\nfunction isIntValue(value) {\n  return value.kind === 'IntValue';\n}\n\nfunction isFloatValue(value) {\n  return value.kind === 'FloatValue';\n}\n\nfunction isVariable(value) {\n  return value.kind === 'Variable';\n}\n\nfunction isObjectValue(value) {\n  return value.kind === 'ObjectValue';\n}\n\nfunction isListValue(value) {\n  return value.kind === 'ListValue';\n}\n\nfunction isEnumValue(value) {\n  return value.kind === 'EnumValue';\n}\n\nfunction isNullValue(value) {\n  return value.kind === 'NullValue';\n}\n\nfunction valueToObjectRepresentation(argObj, name, value, variables) {\n  if (isIntValue(value) || isFloatValue(value)) {\n    argObj[name.value] = Number(value.value);\n  } else if (isBooleanValue(value) || isStringValue(value)) {\n    argObj[name.value] = value.value;\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  } else if (isVariable(value)) {\n    var variableValue = (variables || {})[value.name.value];\n    argObj[name.value] = variableValue;\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  } else if (isEnumValue(value)) {\n    argObj[name.value] = value.value;\n  } else if (isNullValue(value)) {\n    argObj[name.value] = null;\n  } else {\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(17) : new InvariantError(\"The inline argument \\\"\" + name.value + \"\\\" of kind \\\"\" + value.kind + \"\\\"\" + 'is not supported. Use variables instead of inline arguments to ' + 'overcome this limitation.');\n  }\n}\n\nfunction storeKeyNameFromField(field, variables) {\n  var directivesObj = null;\n\n  if (field.directives) {\n    directivesObj = {};\n    field.directives.forEach(function (directive) {\n      directivesObj[directive.name.value] = {};\n\n      if (directive.arguments) {\n        directive.arguments.forEach(function (_a) {\n          var name = _a.name,\n              value = _a.value;\n          return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n        });\n      }\n    });\n  }\n\n  var argObj = null;\n\n  if (field.arguments && field.arguments.length) {\n    argObj = {};\n    field.arguments.forEach(function (_a) {\n      var name = _a.name,\n          value = _a.value;\n      return valueToObjectRepresentation(argObj, name, value, variables);\n    });\n  }\n\n  return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\n\nvar KNOWN_DIRECTIVES = ['connection', 'include', 'skip', 'client', 'rest', 'export'];\n\nfunction getStoreKeyName(fieldName, args, directives) {\n  if (directives && directives['connection'] && directives['connection']['key']) {\n    if (directives['connection']['filter'] && directives['connection']['filter'].length > 0) {\n      var filterKeys = directives['connection']['filter'] ? directives['connection']['filter'] : [];\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    } else {\n      return directives['connection']['key'];\n    }\n  }\n\n  var completeFieldName = fieldName;\n\n  if (args) {\n    var stringifiedArgs = stringify(args);\n    completeFieldName += \"(\" + stringifiedArgs + \")\";\n  }\n\n  if (directives) {\n    Object.keys(directives).forEach(function (key) {\n      if (KNOWN_DIRECTIVES.indexOf(key) !== -1) return;\n\n      if (directives[key] && Object.keys(directives[key]).length) {\n        completeFieldName += \"@\" + key + \"(\" + JSON.stringify(directives[key]) + \")\";\n      } else {\n        completeFieldName += \"@\" + key;\n      }\n    });\n  }\n\n  return completeFieldName;\n}\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,\n          value = _a.value;\n      return valueToObjectRepresentation(argObj_1, name, value, variables);\n    });\n    return argObj_1;\n  }\n\n  return null;\n}\n\nfunction resultKeyNameFromField(field) {\n  return field.alias ? field.alias.value : field.name.value;\n}\n\nfunction isField(selection) {\n  return selection.kind === 'Field';\n}\n\nfunction isInlineFragment(selection) {\n  return selection.kind === 'InlineFragment';\n}\n\nfunction isIdValue(idObject) {\n  return idObject && idObject.type === 'id' && typeof idObject.generated === 'boolean';\n}\n\nfunction toIdValue(idConfig, generated) {\n  if (generated === void 0) {\n    generated = false;\n  }\n\n  return __assign({\n    type: 'id',\n    generated: generated\n  }, typeof idConfig === 'string' ? {\n    id: idConfig,\n    typename: undefined\n  } : idConfig);\n}\n\nfunction isJsonValue(jsonObject) {\n  return jsonObject != null && typeof jsonObject === 'object' && jsonObject.type === 'json';\n}\n\nfunction defaultValueFromVariable(node) {\n  throw process.env.NODE_ENV === \"production\" ? new InvariantError(18) : new InvariantError(\"Variable nodes are not supported by valueFromNode\");\n}\n\nfunction valueFromNode(node, onVariable) {\n  if (onVariable === void 0) {\n    onVariable = defaultValueFromVariable;\n  }\n\n  switch (node.kind) {\n    case 'Variable':\n      return onVariable(node);\n\n    case 'NullValue':\n      return null;\n\n    case 'IntValue':\n      return parseInt(node.value, 10);\n\n    case 'FloatValue':\n      return parseFloat(node.value);\n\n    case 'ListValue':\n      return node.values.map(function (v) {\n        return valueFromNode(v, onVariable);\n      });\n\n    case 'ObjectValue':\n      {\n        var value = {};\n\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\n        return value;\n      }\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\n  return null;\n}\n\nfunction shouldInclude(selection, variables) {\n  if (variables === void 0) {\n    variables = {};\n  }\n\n  return getInclusionDirectives(selection.directives).every(function (_a) {\n    var directive = _a.directive,\n        ifArgument = _a.ifArgument;\n    var evaledValue = false;\n\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    } else {\n      evaledValue = ifArgument.value.value;\n    }\n\n    return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n  });\n}\n\nfunction getDirectiveNames(doc) {\n  var names = [];\n  visit(doc, {\n    Directive: function Directive(node) {\n      names.push(node.name.value);\n    }\n  });\n  return names;\n}\n\nfunction hasDirectives(names, doc) {\n  return getDirectiveNames(doc).some(function (name) {\n    return names.indexOf(name) > -1;\n  });\n}\n\nfunction hasClientExports(document) {\n  return document && hasDirectives(['client'], document) && hasDirectives(['export'], document);\n}\n\nfunction isInclusionDirective(_a) {\n  var value = _a.name.value;\n  return value === 'skip' || value === 'include';\n}\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 && (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 16) : invariant(ifValue && (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), \"Argument for the @\" + directiveName + \" directive must be a variable or a boolean value.\");\n    return {\n      directive: directive,\n      ifArgument: ifArgument\n    };\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 + \"'\" : '') + \". \" + 'No operations are allowed when using a fragment as a query. Only fragments are allowed.');\n    }\n\n    if (definition.kind === 'FragmentDefinition') {\n      fragments.push(definition);\n    }\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\n  var query = __assign(__assign({}, document), {\n    definitions: __spreadArrays([{\n      kind: 'OperationDefinition',\n      operation: 'query',\n      selectionSet: {\n        kind: 'SelectionSet',\n        selections: [{\n          kind: 'FragmentSpread',\n          name: {\n            kind: 'Name',\n            value: actualFragmentName\n          }\n        }]\n      }\n    }], document.definitions)\n  });\n\n  return query;\n}\n\nfunction assign(target) {\n  var sources = [];\n\n  for (var _i = 1; _i < arguments.length; _i++) {\n    sources[_i - 1] = arguments[_i];\n  }\n\n  sources.forEach(function (source) {\n    if (typeof source === 'undefined' || source === null) {\n      return;\n    }\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' && 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}\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.filter(function (d) {\n    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\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}\n\nfunction getOperationDefinition(doc) {\n  checkDocument(doc);\n  return doc.definitions.filter(function (definition) {\n    return definition.kind === 'OperationDefinition';\n  })[0];\n}\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}\n\nfunction getOperationName(doc) {\n  return doc.definitions.filter(function (definition) {\n    return definition.kind === 'OperationDefinition' && definition.name;\n  }).map(function (x) {\n    return x.name.value;\n  })[0] || null;\n}\n\nfunction getFragmentDefinitions(doc) {\n  return doc.definitions.filter(function (definition) {\n    return definition.kind === 'FragmentDefinition';\n  });\n}\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}\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}\n\nfunction getMainDefinition(queryDoc) {\n  checkDocument(queryDoc);\n  var fragmentDefinition;\n\n  for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n    var definition = _a[_i];\n\n    if (definition.kind === 'OperationDefinition') {\n      var operation = definition.operation;\n\n      if (operation === 'query' || operation === 'mutation' || operation === 'subscription') {\n        return definition;\n      }\n    }\n\n    if (definition.kind === 'FragmentDefinition' && !fragmentDefinition) {\n      fragmentDefinition = definition;\n    }\n  }\n\n  if (fragmentDefinition) {\n    return fragmentDefinition;\n  }\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}\n\nfunction createFragmentMap(fragments) {\n  if (fragments === void 0) {\n    fragments = [];\n  }\n\n  var symTable = {};\n  fragments.forEach(function (fragment) {\n    symTable[fragment.name.value] = fragment;\n  });\n  return symTable;\n}\n\nfunction getDefaultValues(definition) {\n  if (definition && definition.variableDefinitions && definition.variableDefinitions.length) {\n    var defaultValues = definition.variableDefinitions.filter(function (_a) {\n      var defaultValue = _a.defaultValue;\n      return defaultValue;\n    }).map(function (_a) {\n      var variable = _a.variable,\n          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\n  return {};\n}\n\nfunction variablesInOperation(operation) {\n  var names = new Set();\n\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\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};\n\nfunction isEmpty(op, fragments) {\n  return op.selectionSet.selections.every(function (selection) {\n    return selection.kind === 'FragmentSpread' && isEmpty(fragments[selection.name.value], fragments);\n  });\n}\n\nfunction nullIfDocIsEmpty(doc) {\n  return isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc))) ? null : doc;\n}\n\nfunction getDirectiveMatcher(directives) {\n  return function directiveMatcher(directive) {\n    return directives.some(function (dir) {\n      return dir.name && dir.name === directive.name.value || dir.test && dir.test(directive);\n    });\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 enter(node, _key, parent) {\n        if (parent.kind !== 'VariableDefinition') {\n          variablesInUse[node.name.value] = true;\n        }\n      }\n    },\n    Field: {\n      enter: function enter(node) {\n        if (directives && node.directives) {\n          var shouldRemoveField = directives.some(function (directive) {\n            return directive.remove;\n          });\n\n          if (shouldRemoveField && node.directives && 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\n            if (node.selectionSet) {\n              getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(function (frag) {\n                fragmentSpreadsToRemove.push({\n                  name: frag.name.value\n                });\n              });\n            }\n\n            return null;\n          }\n        }\n      }\n    },\n    FragmentSpread: {\n      enter: function enter(node) {\n        fragmentSpreadsInUse[node.name.value] = true;\n      }\n    },\n    Directive: {\n      enter: function enter(node) {\n        if (getDirectiveMatcher(directives)(node)) {\n          return null;\n        }\n      }\n    }\n  }));\n\n  if (modifiedDoc && filterInPlace(variablesToRemove, function (v) {\n    return !variablesInUse[v.name];\n  }).length) {\n    modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n  }\n\n  if (modifiedDoc && filterInPlace(fragmentSpreadsToRemove, function (fs) {\n    return !fragmentSpreadsInUse[fs.name];\n  }).length) {\n    modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);\n  }\n\n  return modifiedDoc;\n}\n\nfunction addTypenameToDocument(doc) {\n  return visit(checkDocument(doc), {\n    SelectionSet: {\n      enter: function enter(node, _key, parent) {\n        if (parent && parent.kind === 'OperationDefinition') {\n          return;\n        }\n\n        var selections = node.selections;\n\n        if (!selections) {\n          return;\n        }\n\n        var skip = selections.some(function (selection) {\n          return isField(selection) && (selection.name.value === '__typename' || selection.name.value.lastIndexOf('__', 0) === 0);\n        });\n\n        if (skip) {\n          return;\n        }\n\n        var field = parent;\n\n        if (isField(field) && field.directives && field.directives.some(function (d) {\n          return d.name.value === 'export';\n        })) {\n          return;\n        }\n\n        return __assign(__assign({}, node), {\n          selections: __spreadArrays(selections, [TYPENAME_FIELD])\n        });\n      }\n    }\n  });\n}\n\nvar connectionRemoveConfig = {\n  test: function test(directive) {\n    var willRemove = directive.name.value === 'connection';\n\n    if (willRemove) {\n      if (!directive.arguments || !directive.arguments.some(function (arg) {\n        return arg.name.value === 'key';\n      })) {\n        process.env.NODE_ENV === \"production\" || invariant.warn('Removing an @connection directive even though it does not have a key. ' + 'You may want to use the key parameter to specify a store key.');\n      }\n    }\n\n    return willRemove;\n  }\n};\n\nfunction removeConnectionDirectiveFromDocument(doc) {\n  return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\n\nfunction hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {\n  if (nestedCheck === void 0) {\n    nestedCheck = true;\n  }\n\n  return selectionSet && selectionSet.selections && selectionSet.selections.some(function (selection) {\n    return hasDirectivesInSelection(directives, selection, nestedCheck);\n  });\n}\n\nfunction hasDirectivesInSelection(directives, selection, nestedCheck) {\n  if (nestedCheck === void 0) {\n    nestedCheck = true;\n  }\n\n  if (!isField(selection)) {\n    return true;\n  }\n\n  if (!selection.directives) {\n    return false;\n  }\n\n  return selection.directives.some(getDirectiveMatcher(directives)) || nestedCheck && hasDirectivesInSelectionSet(directives, selection.selectionSet, nestedCheck);\n}\n\nfunction getDirectivesFromDocument(directives, doc) {\n  checkDocument(doc);\n  var parentPath;\n  return nullIfDocIsEmpty(visit(doc, {\n    SelectionSet: {\n      enter: function enter(node, _key, _parent, path) {\n        var currentPath = path.join('-');\n\n        if (!parentPath || currentPath === parentPath || !currentPath.startsWith(parentPath)) {\n          if (node.selections) {\n            var selectionsWithDirectives = node.selections.filter(function (selection) {\n              return hasDirectivesInSelection(directives, selection);\n            });\n\n            if (hasDirectivesInSelectionSet(directives, node, false)) {\n              parentPath = currentPath;\n            }\n\n            return __assign(__assign({}, node), {\n              selections: selectionsWithDirectives\n            });\n          } else {\n            return null;\n          }\n        }\n      }\n    }\n  }));\n}\n\nfunction getArgumentMatcher(config) {\n  return function argumentMatcher(argument) {\n    return config.some(function (aConfig) {\n      return argument.value && argument.value.kind === 'Variable' && argument.value.name && (aConfig.name === argument.value.name.value || aConfig.test && aConfig.test(argument));\n    });\n  };\n}\n\nfunction removeArgumentsFromDocument(config, doc) {\n  var argMatcher = getArgumentMatcher(config);\n  return nullIfDocIsEmpty(visit(doc, {\n    OperationDefinition: {\n      enter: function enter(node) {\n        return __assign(__assign({}, node), {\n          variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n            return !config.some(function (arg) {\n              return arg.name === varDef.variable.name.value;\n            });\n          })\n        });\n      }\n    },\n    Field: {\n      enter: function enter(node) {\n        var shouldRemoveField = config.some(function (argConfig) {\n          return argConfig.remove;\n        });\n\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\n          if (argMatchCount_1 === 1) {\n            return null;\n          }\n        }\n      }\n    },\n    Argument: {\n      enter: function enter(node) {\n        if (argMatcher(node)) {\n          return null;\n        }\n      }\n    }\n  }));\n}\n\nfunction removeFragmentSpreadFromDocument(config, doc) {\n  function enter(node) {\n    if (config.some(function (def) {\n      return def.name === node.name.value;\n    })) {\n      return null;\n    }\n  }\n\n  return nullIfDocIsEmpty(visit(doc, {\n    FragmentSpread: {\n      enter: enter\n    },\n    FragmentDefinition: {\n      enter: enter\n    }\n  }));\n}\n\nfunction getAllFragmentSpreadsFromSelectionSet(selectionSet) {\n  var allFragments = [];\n  selectionSet.selections.forEach(function (selection) {\n    if ((isField(selection) || isInlineFragment(selection)) && selection.selectionSet) {\n      getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(function (frag) {\n        return allFragments.push(frag);\n      });\n    } else if (selection.kind === 'FragmentSpread') {\n      allFragments.push(selection);\n    }\n  });\n  return allFragments;\n}\n\nfunction buildQueryFromSelectionSet(document) {\n  var definition = getMainDefinition(document);\n  var definitionOperation = definition.operation;\n\n  if (definitionOperation === 'query') {\n    return document;\n  }\n\n  var modifiedDoc = visit(document, {\n    OperationDefinition: {\n      enter: function enter(node) {\n        return __assign(__assign({}, node), {\n          operation: 'query'\n        });\n      }\n    }\n  });\n  return modifiedDoc;\n}\n\nfunction removeClientSetsFromDocument(document) {\n  checkDocument(document);\n  var modifiedDoc = removeDirectivesFromDocument([{\n    test: function test(directive) {\n      return directive.name.value === 'client';\n    },\n    remove: true\n  }], document);\n\n  if (modifiedDoc) {\n    modifiedDoc = visit(modifiedDoc, {\n      FragmentDefinition: {\n        enter: function enter(node) {\n          if (node.selectionSet) {\n            var isTypenameOnly = node.selectionSet.selections.every(function (selection) {\n              return isField(selection) && selection.name.value === '__typename';\n            });\n\n            if (isTypenameOnly) {\n              return null;\n            }\n          }\n        }\n      }\n    });\n  }\n\n  return modifiedDoc;\n}\n\nvar canUseWeakMap = typeof WeakMap === 'function' && !(typeof navigator === 'object' && navigator.product === 'ReactNative');\nvar toString = Object.prototype.toString;\n\nfunction cloneDeep(value) {\n  return cloneDeepHelper(value, new Map());\n}\n\nfunction cloneDeepHelper(val, seen) {\n  switch (toString.call(val)) {\n    case \"[object Array]\":\n      {\n        if (seen.has(val)) 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\n    case \"[object Object]\":\n      {\n        if (seen.has(val)) 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\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\n  return 'development';\n}\n\nfunction isEnv(env) {\n  return getEnv() === env;\n}\n\nfunction isProduction() {\n  return isEnv('production') === true;\n}\n\nfunction isDevelopment() {\n  return isEnv('development') === true;\n}\n\nfunction isTest() {\n  return isEnv('test') === true;\n}\n\nfunction tryFunctionOrLogError(f) {\n  try {\n    return f();\n  } catch (e) {\n    if (console.error) {\n      console.error(e);\n    }\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 && (typeof o[prop] === 'object' || typeof o[prop] === 'function') && !Object.isFrozen(o[prop])) {\n      deepFreeze(o[prop]);\n    }\n  });\n  return o;\n}\n\nfunction maybeDeepFreeze(obj) {\n  if (isDevelopment() || isTest()) {\n    var symbolIsPolyfilled = typeof Symbol === 'function' && typeof Symbol('') === 'string';\n\n    if (!symbolIsPolyfilled) {\n      return deepFreeze(obj);\n    }\n  }\n\n  return obj;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction mergeDeep() {\n  var sources = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    sources[_i] = arguments[_i];\n  }\n\n  return mergeDeepArray(sources);\n}\n\nfunction mergeDeepArray(sources) {\n  var target = sources[0] || {};\n  var count = sources.length;\n\n  if (count > 1) {\n    var pastCopies = [];\n    target = shallowCopyForMerge(target, pastCopies);\n\n    for (var i = 1; i < count; ++i) {\n      target = mergeHelper(target, sources[i], pastCopies);\n    }\n  }\n\n  return target;\n}\n\nfunction isObject(obj) {\n  return obj !== null && typeof obj === 'object';\n}\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\n    Object.keys(source).forEach(function (sourceKey) {\n      var sourceValue = source[sourceKey];\n\n      if (hasOwnProperty.call(target, sourceKey)) {\n        var targetValue = target[sourceKey];\n\n        if (sourceValue !== targetValue) {\n          target[sourceKey] = mergeHelper(shallowCopyForMerge(targetValue, pastCopies), sourceValue, pastCopies);\n        }\n      } else {\n        target[sourceKey] = sourceValue;\n      }\n    });\n    return target;\n  }\n\n  return source;\n}\n\nfunction shallowCopyForMerge(value, pastCopies) {\n  if (value !== null && typeof value === 'object' && pastCopies.indexOf(value) < 0) {\n    if (Array.isArray(value)) {\n      value = value.slice(0);\n    } else {\n      value = __assign({\n        __proto__: Object.getPrototypeOf(value)\n      }, value);\n    }\n\n    pastCopies.push(value);\n  }\n\n  return value;\n}\n\nvar haveWarned = Object.create({});\n\nfunction warnOnceInDevelopment(msg, type) {\n  if (type === void 0) {\n    type = 'warn';\n  }\n\n  if (!isProduction() && !haveWarned[msg]) {\n    if (!isTest()) {\n      haveWarned[msg] = true;\n    }\n\n    if (type === 'error') {\n      console.error(msg);\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 };","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';\nvar NetworkStatus;\n\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 = {}));\n\nfunction isNetworkRequestInFlight(networkStatus) {\n  return networkStatus < 7;\n}\n\nvar Observable = function (_super) {\n  __extends(Observable, _super);\n\n  function Observable() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  }\n\n  Observable.prototype[$$observable] = function () {\n    return this;\n  };\n\n  Observable.prototype['@@observable'] = function () {\n    return this;\n  };\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}\n\nvar generateErrorMessage = function generateErrorMessage(err) {\n  var message = '';\n\n  if (isNonEmptyArray(err.graphQLErrors)) {\n    err.graphQLErrors.forEach(function (graphQLError) {\n      var errorMessage = graphQLError ? graphQLError.message : 'Error message not found.';\n      message += \"GraphQL error: \" + errorMessage + \"\\n\";\n    });\n  }\n\n  if (err.networkError) {\n    message += 'Network error: ' + err.networkError.message + '\\n';\n  }\n\n  message = message.replace(/\\n$/, '');\n  return message;\n};\n\nvar ApolloError = function (_super) {\n  __extends(ApolloError, _super);\n\n  function ApolloError(_a) {\n    var graphQLErrors = _a.graphQLErrors,\n        networkError = _a.networkError,\n        errorMessage = _a.errorMessage,\n        extraInfo = _a.extraInfo;\n\n    var _this = _super.call(this, errorMessage) || this;\n\n    _this.graphQLErrors = graphQLErrors || [];\n    _this.networkError = networkError || null;\n\n    if (!errorMessage) {\n      _this.message = generateErrorMessage(_this);\n    } else {\n      _this.message = errorMessage;\n    }\n\n    _this.extraInfo = extraInfo;\n    _this.__proto__ = ApolloError.prototype;\n    return _this;\n  }\n\n  return ApolloError;\n}(Error);\n\nvar FetchType;\n\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 hasError(storeValue, policy) {\n  if (policy === void 0) {\n    policy = 'none';\n  }\n\n  return storeValue && (storeValue.networkError || policy === 'none' && isNonEmptyArray(storeValue.graphQLErrors));\n};\n\nvar ObservableQuery = function (_super) {\n  __extends(ObservableQuery, _super);\n\n  function ObservableQuery(_a) {\n    var queryManager = _a.queryManager,\n        options = _a.options,\n        _b = _a.shouldSubscribe,\n        shouldSubscribe = _b === void 0 ? true : _b;\n\n    var _this = _super.call(this, function (observer) {\n      return _this.onSubscribe(observer);\n    }) || this;\n\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\n  ObservableQuery.prototype.result = function () {\n    var _this = this;\n\n    return new Promise(function (resolve, reject) {\n      var observer = {\n        next: function next(result) {\n          resolve(result);\n\n          _this.observers.delete(observer);\n\n          if (!_this.observers.size) {\n            _this.queryManager.removeQuery(_this.queryId);\n          }\n\n          setTimeout(function () {\n            subscription.unsubscribe();\n          }, 0);\n        },\n        error: reject\n      };\n\n      var subscription = _this.subscribe(observer);\n    });\n  };\n\n  ObservableQuery.prototype.currentResult = function () {\n    var result = this.getCurrentResult();\n\n    if (result.data === undefined) {\n      result.data = {};\n    }\n\n    return result;\n  };\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\n    var _a = this.queryManager.getCurrentQueryResult(this),\n        data = _a.data,\n        partial = _a.partial;\n\n    var queryStoreValue = this.queryManager.queryStore.get(this.queryId);\n    var result;\n    var fetchPolicy = this.options.fetchPolicy;\n    var isNetworkFetchPolicy = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';\n\n    if (queryStoreValue) {\n      var networkStatus = queryStoreValue.networkStatus;\n\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\n      if (queryStoreValue.variables) {\n        this.options.variables = __assign(__assign({}, this.options.variables), queryStoreValue.variables);\n        this.variables = this.options.variables;\n      }\n\n      result = {\n        data: data,\n        loading: isNetworkRequestInFlight(networkStatus),\n        networkStatus: networkStatus\n      };\n\n      if (queryStoreValue.graphQLErrors && this.options.errorPolicy === 'all') {\n        result.errors = queryStoreValue.graphQLErrors;\n      }\n    } else {\n      var loading = isNetworkFetchPolicy || partial && fetchPolicy !== 'cache-only';\n      result = {\n        data: data,\n        loading: loading,\n        networkStatus: loading ? NetworkStatus.loading : NetworkStatus.ready\n      };\n    }\n\n    if (!partial) {\n      this.updateLastResult(__assign(__assign({}, result), {\n        stale: false\n      }));\n    }\n\n    return __assign(__assign({}, result), {\n      partial: partial\n    });\n  };\n\n  ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {\n    var snapshot = this.lastResultSnapshot;\n    return !(snapshot && newResult && snapshot.networkStatus === newResult.networkStatus && snapshot.stale === newResult.stale && isEqual(snapshot.data, newResult.data));\n  };\n\n  ObservableQuery.prototype.getLastResult = function () {\n    return this.lastResult;\n  };\n\n  ObservableQuery.prototype.getLastError = function () {\n    return this.lastError;\n  };\n\n  ObservableQuery.prototype.resetLastResults = function () {\n    delete this.lastResult;\n    delete this.lastResultSnapshot;\n    delete this.lastError;\n    this.isTornDown = false;\n  };\n\n  ObservableQuery.prototype.resetQueryStoreErrors = function () {\n    var queryStore = this.queryManager.queryStore.get(this.queryId);\n\n    if (queryStore) {\n      queryStore.networkError = null;\n      queryStore.graphQLErrors = [];\n    }\n  };\n\n  ObservableQuery.prototype.refetch = function (variables) {\n    var fetchPolicy = this.options.fetchPolicy;\n\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\n    if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'cache-and-network') {\n      fetchPolicy = 'network-only';\n    }\n\n    if (!isEqual(this.variables, variables)) {\n      this.variables = __assign(__assign({}, this.variables), variables);\n    }\n\n    if (!isEqual(this.options.variables, this.variables)) {\n      this.options.variables = __assign(__assign({}, this.options.variables), this.variables);\n    }\n\n    return this.queryManager.fetchQuery(this.queryId, __assign(__assign({}, this.options), {\n      fetchPolicy: fetchPolicy\n    }), FetchType.refetch);\n  };\n\n  ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n    var _this = this;\n\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\n    var combinedOptions = __assign(__assign({}, fetchMoreOptions.query ? fetchMoreOptions : __assign(__assign(__assign({}, this.options), fetchMoreOptions), {\n      variables: __assign(__assign({}, this.variables), fetchMoreOptions.variables)\n    })), {\n      fetchPolicy: 'network-only'\n    });\n\n    var qid = this.queryManager.generateQueryId();\n    return this.queryManager.fetchQuery(qid, combinedOptions, FetchType.normal, this.queryId).then(function (fetchMoreResult) {\n      _this.updateQuery(function (previousResult) {\n        return fetchMoreOptions.updateQuery(previousResult, {\n          fetchMoreResult: fetchMoreResult.data,\n          variables: combinedOptions.variables\n        });\n      });\n\n      _this.queryManager.stopQuery(qid);\n\n      return fetchMoreResult;\n    }, function (error) {\n      _this.queryManager.stopQuery(qid);\n\n      throw error;\n    });\n  };\n\n  ObservableQuery.prototype.subscribeToMore = function (options) {\n    var _this = this;\n\n    var subscription = this.queryManager.startGraphQLSubscription({\n      query: options.document,\n      variables: options.variables\n    }).subscribe({\n      next: function next(subscriptionData) {\n        var updateQuery = options.updateQuery;\n\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 error(err) {\n        if (options.onError) {\n          options.onError(err);\n          return;\n        }\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\n  ObservableQuery.prototype.setOptions = function (opts) {\n    var oldFetchPolicy = this.options.fetchPolicy;\n    this.options = __assign(__assign({}, this.options), opts);\n\n    if (opts.pollInterval) {\n      this.startPolling(opts.pollInterval);\n    } else if (opts.pollInterval === 0) {\n      this.stopPolling();\n    }\n\n    var fetchPolicy = opts.fetchPolicy;\n    return this.setVariables(this.options.variables, oldFetchPolicy !== fetchPolicy && (oldFetchPolicy === 'cache-only' || oldFetchPolicy === 'standby' || fetchPolicy === 'network-only'), opts.fetchResults);\n  };\n\n  ObservableQuery.prototype.setVariables = function (variables, tryFetch, fetchResults) {\n    if (tryFetch === void 0) {\n      tryFetch = false;\n    }\n\n    if (fetchResults === void 0) {\n      fetchResults = true;\n    }\n\n    this.isTornDown = false;\n    variables = variables || this.variables;\n\n    if (!tryFetch && isEqual(variables, this.variables)) {\n      return this.observers.size && fetchResults ? this.result() : Promise.resolve();\n    }\n\n    this.variables = this.options.variables = variables;\n\n    if (!this.observers.size) {\n      return Promise.resolve();\n    }\n\n    return this.queryManager.fetchQuery(this.queryId, this.options);\n  };\n\n  ObservableQuery.prototype.updateQuery = function (mapFn) {\n    var queryManager = this.queryManager;\n\n    var _a = queryManager.getQueryWithPreviousResult(this.queryId),\n        previousResult = _a.previousResult,\n        variables = _a.variables,\n        document = _a.document;\n\n    var newResult = tryFunctionOrLogError(function () {\n      return mapFn(previousResult, {\n        variables: variables\n      });\n    });\n\n    if (newResult) {\n      queryManager.dataStore.markUpdateQueryResult(document, variables, newResult);\n      queryManager.broadcastQueries();\n    }\n  };\n\n  ObservableQuery.prototype.stopPolling = function () {\n    this.queryManager.stopPollingQuery(this.queryId);\n    this.options.pollInterval = undefined;\n  };\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\n  ObservableQuery.prototype.updateLastResult = function (newResult) {\n    var previousResult = this.lastResult;\n    this.lastResult = newResult;\n    this.lastResultSnapshot = this.queryManager.assumeImmutableResults ? newResult : cloneDeep(newResult);\n    return previousResult;\n  };\n\n  ObservableQuery.prototype.onSubscribe = function (observer) {\n    var _this = this;\n\n    try {\n      var subObserver = observer._subscription._observer;\n\n      if (subObserver && !subObserver.error) {\n        subObserver.error = defaultSubscriptionObserverErrorCallback;\n      }\n    } catch (_a) {}\n\n    var first = !this.observers.size;\n    this.observers.add(observer);\n    if (observer.next && this.lastResult) observer.next(this.lastResult);\n    if (observer.error && this.lastError) observer.error(this.lastError);\n\n    if (first) {\n      this.setUpQuery();\n    }\n\n    return function () {\n      if (_this.observers.delete(observer) && !_this.observers.size) {\n        _this.tearDownQuery();\n      }\n    };\n  };\n\n  ObservableQuery.prototype.setUpQuery = function () {\n    var _this = this;\n\n    var _a = this,\n        queryManager = _a.queryManager,\n        queryId = _a.queryId;\n\n    if (this.shouldSubscribe) {\n      queryManager.addObservableQuery(queryId, this);\n    }\n\n    if (this.options.pollInterval) {\n      assertNotCacheFirstOrOnly(this);\n      queryManager.startPollingQuery(this.options, queryId);\n    }\n\n    var onError = function onError(error) {\n      _this.updateLastResult(__assign(__assign({}, _this.lastResult), {\n        errors: error.graphQLErrors,\n        networkStatus: NetworkStatus.error,\n        loading: false\n      }));\n\n      iterateObserversSafely(_this.observers, 'error', _this.lastError = error);\n    };\n\n    queryManager.observeQuery(queryId, this.options, {\n      next: function next(result) {\n        if (_this.lastError || _this.isDifferentFromLastResult(result)) {\n          var previousResult_1 = _this.updateLastResult(result);\n\n          var _a = _this.options,\n              query_1 = _a.query,\n              variables = _a.variables,\n              fetchPolicy_1 = _a.fetchPolicy;\n\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\n              if (!result.loading && previousResult_1 && fetchPolicy_1 !== 'cache-only' && queryManager.transform(query_1).serverQuery && !isEqual(previousVariables, variables)) {\n                _this.refetch();\n              } else {\n                iterateObserversSafely(_this.observers, 'next', result);\n              }\n            });\n          } else {\n            iterateObserversSafely(_this.observers, 'next', result);\n          }\n        }\n      },\n      error: onError\n    }).catch(onError);\n  };\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) {\n      return sub.unsubscribe();\n    });\n    this.subscriptions.clear();\n    queryManager.removeObservableQuery(this.queryId);\n    queryManager.stopQuery(this.queryId);\n    this.observers.clear();\n  };\n\n  return ObservableQuery;\n}(Observable);\n\nfunction defaultSubscriptionObserverErrorCallback(error) {\n  process.env.NODE_ENV === \"production\" || invariant.error('Unhandled error', error.message, error.stack);\n}\n\nfunction iterateObserversSafely(observers, method, argument) {\n  var observersWithMethod = [];\n  observers.forEach(function (obs) {\n    return obs[method] && observersWithMethod.push(obs);\n  });\n  observersWithMethod.forEach(function (obs) {\n    return obs[method](argument);\n  });\n}\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\n  MutationStore.prototype.getStore = function () {\n    return this.store;\n  };\n\n  MutationStore.prototype.get = function (mutationId) {\n    return this.store[mutationId];\n  };\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\n  MutationStore.prototype.markMutationError = function (mutationId, error) {\n    var mutation = this.store[mutationId];\n\n    if (mutation) {\n      mutation.loading = false;\n      mutation.error = error;\n    }\n  };\n\n  MutationStore.prototype.markMutationResult = function (mutationId) {\n    var mutation = this.store[mutationId];\n\n    if (mutation) {\n      mutation.loading = false;\n      mutation.error = null;\n    }\n  };\n\n  MutationStore.prototype.reset = function () {\n    this.store = {};\n  };\n\n  return MutationStore;\n}();\n\nvar QueryStore = function () {\n  function QueryStore() {\n    this.store = {};\n  }\n\n  QueryStore.prototype.getStore = function () {\n    return this.store;\n  };\n\n  QueryStore.prototype.get = function (queryId) {\n    return this.store[queryId];\n  };\n\n  QueryStore.prototype.initQuery = function (query) {\n    var previousQuery = this.store[query.queryId];\n    process.env.NODE_ENV === \"production\" ? invariant(!previousQuery || previousQuery.document === query.document || isEqual(previousQuery.document, query.document), 19) : invariant(!previousQuery || previousQuery.document === query.document || isEqual(previousQuery.document, query.document), 'Internal Error: may not update existing query string in store');\n    var isSetVariables = false;\n    var previousVariables = null;\n\n    if (query.storePreviousVariables && previousQuery && previousQuery.networkStatus !== NetworkStatus.loading) {\n      if (!isEqual(previousQuery.variables, query.variables)) {\n        isSetVariables = true;\n        previousVariables = previousQuery.variables;\n      }\n    }\n\n    var networkStatus;\n\n    if (isSetVariables) {\n      networkStatus = NetworkStatus.setVariables;\n    } else if (query.isPoll) {\n      networkStatus = NetworkStatus.poll;\n    } else if (query.isRefetch) {\n      networkStatus = NetworkStatus.refetch;\n    } else {\n      networkStatus = NetworkStatus.loading;\n    }\n\n    var graphQLErrors = [];\n\n    if (previousQuery && previousQuery.graphQLErrors) {\n      graphQLErrors = previousQuery.graphQLErrors;\n    }\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\n    if (typeof query.fetchMoreForQueryId === 'string' && this.store[query.fetchMoreForQueryId]) {\n      this.store[query.fetchMoreForQueryId].networkStatus = NetworkStatus.fetchMore;\n    }\n  };\n\n  QueryStore.prototype.markQueryResult = function (queryId, result, fetchMoreForQueryId) {\n    if (!this.store || !this.store[queryId]) 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\n    if (typeof fetchMoreForQueryId === 'string' && this.store[fetchMoreForQueryId]) {\n      this.store[fetchMoreForQueryId].networkStatus = NetworkStatus.ready;\n    }\n  };\n\n  QueryStore.prototype.markQueryError = function (queryId, error, fetchMoreForQueryId) {\n    if (!this.store || !this.store[queryId]) return;\n    this.store[queryId].networkError = error;\n    this.store[queryId].networkStatus = NetworkStatus.error;\n\n    if (typeof fetchMoreForQueryId === 'string') {\n      this.markQueryResultClient(fetchMoreForQueryId, true);\n    }\n  };\n\n  QueryStore.prototype.markQueryResultClient = function (queryId, complete) {\n    var storeValue = this.store && this.store[queryId];\n\n    if (storeValue) {\n      storeValue.networkError = null;\n      storeValue.previousVariables = null;\n\n      if (complete) {\n        storeValue.networkStatus = NetworkStatus.ready;\n      }\n    }\n  };\n\n  QueryStore.prototype.stopQuery = function (queryId) {\n    delete this.store[queryId];\n  };\n\n  QueryStore.prototype.reset = function (observableQueryIds) {\n    var _this = this;\n\n    Object.keys(this.store).forEach(function (queryId) {\n      if (observableQueryIds.indexOf(queryId) < 0) {\n        _this.stopQuery(queryId);\n      } else {\n        _this.store[queryId].networkStatus = NetworkStatus.loading;\n      }\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,\n        client = _a.client,\n        resolvers = _a.resolvers,\n        fragmentMatcher = _a.fragmentMatcher;\n    this.cache = cache;\n\n    if (client) {\n      this.client = client;\n    }\n\n    if (resolvers) {\n      this.addResolvers(resolvers);\n    }\n\n    if (fragmentMatcher) {\n      this.setFragmentMatcher(fragmentMatcher);\n    }\n  }\n\n  LocalState.prototype.addResolvers = function (resolvers) {\n    var _this = this;\n\n    this.resolvers = this.resolvers || {};\n\n    if (Array.isArray(resolvers)) {\n      resolvers.forEach(function (resolverGroup) {\n        _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);\n      });\n    } else {\n      this.resolvers = mergeDeep(this.resolvers, resolvers);\n    }\n  };\n\n  LocalState.prototype.setResolvers = function (resolvers) {\n    this.resolvers = {};\n    this.addResolvers(resolvers);\n  };\n\n  LocalState.prototype.getResolvers = function () {\n    return this.resolvers || {};\n  };\n\n  LocalState.prototype.runResolvers = function (_a) {\n    var document = _a.document,\n        remoteResult = _a.remoteResult,\n        context = _a.context,\n        variables = _a.variables,\n        _b = _a.onlyRunForcedResolvers,\n        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) {\n            return __assign(__assign({}, remoteResult), {\n              data: localResult.result\n            });\n          })];\n        }\n\n        return [2, remoteResult];\n      });\n    });\n  };\n\n  LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n    this.fragmentMatcher = fragmentMatcher;\n  };\n\n  LocalState.prototype.getFragmentMatcher = function () {\n    return this.fragmentMatcher;\n  };\n\n  LocalState.prototype.clientQuery = function (document) {\n    if (hasDirectives(['client'], document)) {\n      if (this.resolvers) {\n        return document;\n      }\n\n      process.env.NODE_ENV === \"production\" || invariant.warn('Found @client directives in a query but no ApolloClient resolvers ' + 'were specified. This means ApolloClient local resolver handling ' + 'has been disabled, and @client directives will be passed through ' + 'to your link chain.');\n    }\n\n    return null;\n  };\n\n  LocalState.prototype.serverQuery = function (document) {\n    return this.resolvers ? removeClientSetsFromDocument(document) : document;\n  };\n\n  LocalState.prototype.prepareContext = function (context) {\n    if (context === void 0) {\n      context = {};\n    }\n\n    var cache = this.cache;\n\n    var newContext = __assign(__assign({}, context), {\n      cache: cache,\n      getCacheKey: function getCacheKey(obj) {\n        if (cache.config) {\n          return cache.config.dataIdFromObject(obj);\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 ' + 'a configurable dataIdFromObject, like apollo-cache-inmemory.');\n        }\n      }\n    });\n\n    return newContext;\n  };\n\n  LocalState.prototype.addExportedVariables = function (document, variables, context) {\n    if (variables === void 0) {\n      variables = {};\n    }\n\n    if (context === void 0) {\n      context = {};\n    }\n\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) {\n            return __assign(__assign({}, variables), data.exportedVariables);\n          })];\n        }\n\n        return [2, __assign({}, variables)];\n      });\n    });\n  };\n\n  LocalState.prototype.shouldForceResolvers = function (document) {\n    var forceResolvers = false;\n    visit(document, {\n      Directive: {\n        enter: function enter(node) {\n          if (node.name.value === 'client' && node.arguments) {\n            forceResolvers = node.arguments.some(function (arg) {\n              return arg.name.value === 'always' && arg.value.kind === 'BooleanValue' && arg.value.value === true;\n            });\n\n            if (forceResolvers) {\n              return BREAK;\n            }\n          }\n        }\n      }\n    });\n    return forceResolvers;\n  };\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\n  LocalState.prototype.resolveDocument = function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n    if (context === void 0) {\n      context = {};\n    }\n\n    if (variables === void 0) {\n      variables = {};\n    }\n\n    if (fragmentMatcher === void 0) {\n      fragmentMatcher = function fragmentMatcher() {\n        return true;\n      };\n    }\n\n    if (onlyRunForcedResolvers === void 0) {\n      onlyRunForcedResolvers = false;\n    }\n\n    return __awaiter(this, void 0, void 0, function () {\n      var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;\n\n      return __generator(this, function (_b) {\n        mainDefinition = getMainDefinition(document);\n        fragments = getFragmentDefinitions(document);\n        fragmentMap = createFragmentMap(fragments);\n        definitionOperation = mainDefinition.operation;\n        defaultOperationType = definitionOperation ? capitalizeFirstLetter(definitionOperation) : 'Query';\n        _a = this, cache = _a.cache, client = _a.client;\n        execContext = {\n          fragmentMap: fragmentMap,\n          context: __assign(__assign({}, context), {\n            cache: cache,\n            client: client\n          }),\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) {\n          return {\n            result: result,\n            exportedVariables: execContext.exportedVariables\n          };\n        })];\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\n      var _this = this;\n\n      return __generator(this, function (_a) {\n        fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n        resultsToMerge = [rootValue];\n\n        execute = function execute(selection) {\n          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\n              if (isField(selection)) {\n                return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {\n                  var _a;\n\n                  if (typeof fieldResult !== 'undefined') {\n                    resultsToMerge.push((_a = {}, _a[resultKeyNameFromField(selection)] = fieldResult, _a));\n                  }\n                })];\n              }\n\n              if (isInlineFragment(selection)) {\n                fragment = selection;\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\n              if (fragment && fragment.typeCondition) {\n                typeCondition = fragment.typeCondition.name.value;\n\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\n              return [2];\n            });\n          });\n        };\n\n        return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {\n          return mergeDeepArray(resultsToMerge);\n        })];\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\n      var _this = this;\n\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\n        if (!execContext.onlyRunForcedResolvers || this.shouldForceResolvers(field)) {\n          resolverType = rootValue.__typename || execContext.defaultOperationType;\n          resolverMap = this.resolvers && this.resolvers[resolverType];\n\n          if (resolverMap) {\n            resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n\n            if (resolve) {\n              resultPromise = Promise.resolve(resolve(rootValue, argumentsObjectFromField(field, variables), execContext.context, {\n                field: field,\n                fragmentMap: execContext.fragmentMap\n              }));\n            }\n          }\n        }\n\n        return [2, resultPromise.then(function (result) {\n          if (result === void 0) {\n            result = defaultResult;\n          }\n\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\n          if (!field.selectionSet) {\n            return result;\n          }\n\n          if (result == null) {\n            return result;\n          }\n\n          if (Array.isArray(result)) {\n            return _this.resolveSubSelectedArray(field, result, execContext);\n          }\n\n          if (field.selectionSet) {\n            return _this.resolveSelectionSet(field.selectionSet, result, execContext);\n          }\n        })];\n      });\n    });\n  };\n\n  LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {\n    var _this = this;\n\n    return Promise.all(result.map(function (item) {\n      if (item === null) {\n        return null;\n      }\n\n      if (Array.isArray(item)) {\n        return _this.resolveSubSelectedArray(field, item, execContext);\n      }\n\n      if (field.selectionSet) {\n        return _this.resolveSelectionSet(field.selectionSet, item, execContext);\n      }\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 next(value) {\n        observers.forEach(function (obs) {\n          return obs.next && obs.next(value);\n        });\n      },\n      error: function error(_error) {\n        observers.forEach(function (obs) {\n          return obs.error && obs.error(_error);\n        });\n      },\n      complete: function complete() {\n        observers.forEach(function (obs) {\n          return obs.complete && obs.complete();\n        });\n      }\n    });\n    return function () {\n      if (observers.delete(observer) && !observers.size && sub) {\n        sub.unsubscribe();\n        sub = null;\n      }\n    };\n  });\n}\n\nfunction asyncMap(observable, mapFn) {\n  return new Observable(function (observer) {\n    var _next = observer.next,\n        _error2 = observer.error,\n        _complete = observer.complete;\n    var activeNextCount = 0;\n    var completed = false;\n    var handler = {\n      next: function next(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          _error2 && _error2.call(observer, e);\n        });\n      },\n      error: function error(e) {\n        _error2 && _error2.call(observer, e);\n      },\n      complete: function complete() {\n        completed = true;\n\n        if (!activeNextCount) {\n          _complete && _complete.call(observer);\n        }\n      }\n    };\n    var sub = observable.subscribe(handler);\n    return function () {\n      return sub.unsubscribe();\n    };\n  });\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar QueryManager = function () {\n  function QueryManager(_a) {\n    var link = _a.link,\n        _b = _a.queryDeduplication,\n        queryDeduplication = _b === void 0 ? false : _b,\n        store = _a.store,\n        _c = _a.onBroadcast,\n        onBroadcast = _c === void 0 ? function () {\n      return undefined;\n    } : _c,\n        _d = _a.ssrMode,\n        ssrMode = _d === void 0 ? false : _d,\n        _e = _a.clientAwareness,\n        clientAwareness = _e === void 0 ? {} : _e,\n        localState = _a.localState,\n        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({\n      cache: store.getCache()\n    });\n    this.ssrMode = ssrMode;\n    this.assumeImmutableResults = !!assumeImmutableResults;\n  }\n\n  QueryManager.prototype.stop = function () {\n    var _this = this;\n\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\n  QueryManager.prototype.mutate = function (_a) {\n    var mutation = _a.mutation,\n        variables = _a.variables,\n        optimisticResponse = _a.optimisticResponse,\n        updateQueriesByName = _a.updateQueries,\n        _b = _a.refetchQueries,\n        refetchQueries = _b === void 0 ? [] : _b,\n        _c = _a.awaitRefetchQueries,\n        awaitRefetchQueries = _c === void 0 ? false : _c,\n        updateWithProxyFn = _a.update,\n        _d = _a.errorPolicy,\n        errorPolicy = _d === void 0 ? 'none' : _d,\n        fetchPolicy = _a.fetchPolicy,\n        _e = _a.context,\n        context = _e === void 0 ? {} : _e;\n    return __awaiter(this, void 0, void 0, function () {\n      var mutationId, generateUpdateQueriesInfo, self;\n\n      var _this = this;\n\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 () {\n              return {\n                document: mutation\n              };\n            });\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\n          case 1:\n            variables = _f.sent();\n            _f.label = 2;\n\n          case 2:\n            generateUpdateQueriesInfo = function generateUpdateQueriesInfo() {\n              var ret = {};\n\n              if (updateQueriesByName) {\n                _this.queries.forEach(function (_a, queryId) {\n                  var observableQuery = _a.observableQuery;\n\n                  if (observableQuery) {\n                    var queryName = observableQuery.queryName;\n\n                    if (queryName && hasOwnProperty.call(updateQueriesByName, queryName)) {\n                      ret[queryId] = {\n                        updater: updateQueriesByName[queryName],\n                        query: _this.queryStore.get(queryId)\n                      };\n                    }\n                  }\n                });\n              }\n\n              return ret;\n            };\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), {\n                optimisticResponse: optimisticResponse\n              }), variables, false).subscribe({\n                next: function next(result) {\n                  if (graphQLResultHasError(result) && errorPolicy === 'none') {\n                    error = new ApolloError({\n                      graphQLErrors: result.errors\n                    });\n                    return;\n                  }\n\n                  self.mutationStore.markMutationResult(mutationId);\n\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\n                  storeResult = result;\n                },\n                error: function error(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 () {\n                    return {\n                      document: null\n                    };\n                  });\n                  reject(new ApolloError({\n                    networkError: err\n                  }));\n                },\n                complete: function complete() {\n                  if (error) {\n                    self.mutationStore.markMutationError(mutationId, error);\n                  }\n\n                  self.dataStore.markMutationComplete({\n                    mutationId: mutationId,\n                    optimisticResponse: optimisticResponse\n                  });\n                  self.broadcastQueries();\n\n                  if (error) {\n                    reject(error);\n                    return;\n                  }\n\n                  if (typeof refetchQueries === 'function') {\n                    refetchQueries = refetchQueries(storeResult);\n                  }\n\n                  var refetchQueryPromises = [];\n\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\n                          if (observableQuery && observableQuery.queryName === refetchQuery) {\n                            refetchQueryPromises.push(observableQuery.refetch());\n                          }\n                        });\n                      } else {\n                        var queryOptions = {\n                          query: refetchQuery.query,\n                          variables: refetchQuery.variables,\n                          fetchPolicy: 'network-only'\n                        };\n\n                        if (refetchQuery.context) {\n                          queryOptions.context = refetchQuery.context;\n                        }\n\n                        refetchQueryPromises.push(self.query(queryOptions));\n                      }\n                    });\n                  }\n\n                  Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {\n                    self.setQuery(mutationId, function () {\n                      return {\n                        document: null\n                      };\n                    });\n\n                    if (errorPolicy === 'ignore' && storeResult && graphQLResultHasError(storeResult)) {\n                      delete storeResult.errors;\n                    }\n\n                    resolve(storeResult);\n                  });\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\n      var _this = this;\n\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\n          case 1:\n            variables = _e.sent();\n            _e.label = 2;\n\n          case 2:\n            options = __assign(__assign({}, options), {\n              variables: variables\n            });\n            isNetworkOnly = fetchPolicy === 'network-only' || fetchPolicy === 'no-cache';\n            needToFetch = isNetworkOnly;\n\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\n            shouldFetch = needToFetch && fetchPolicy !== 'cache-only' && fetchPolicy !== 'standby';\n            if (hasDirectives(['live'], query)) shouldFetch = true;\n            requestId = this.idCounter++;\n            cancel = fetchPolicy !== 'no-cache' ? this.updateQueryWatch(queryId, query, options) : undefined;\n            this.setQuery(queryId, function () {\n              return {\n                document: query,\n                lastRequestId: requestId,\n                invalidated: true,\n                cancel: cancel\n              };\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\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                } else {\n                  if (requestId >= _this.getQuery(queryId).lastRequestId) {\n                    _this.queryStore.markQueryError(queryId, error, fetchMoreForQueryId);\n\n                    _this.invalidate(queryId);\n\n                    _this.invalidate(fetchMoreForQueryId);\n\n                    _this.broadcastQueries();\n                  }\n\n                  throw new ApolloError({\n                    networkError: error\n                  });\n                }\n              });\n\n              if (fetchPolicy !== 'cache-and-network') {\n                return [2, networkResult];\n              }\n\n              networkResult.catch(function () {});\n            }\n\n            this.queryStore.markQueryResultClient(queryId, !shouldFetch);\n            this.invalidate(queryId);\n            this.invalidate(fetchMoreForQueryId);\n\n            if (this.transform(query).hasForcedResolvers) {\n              return [2, this.localState.runResolvers({\n                document: query,\n                remoteResult: {\n                  data: storeResult\n                },\n                context: context,\n                variables: variables,\n                onlyRunForcedResolvers: true\n              }).then(function (result) {\n                _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n\n                _this.broadcastQueries();\n\n                return result;\n              })];\n            }\n\n            this.broadcastQueries();\n            return [2, {\n              data: storeResult\n            }];\n        }\n      });\n    });\n  };\n\n  QueryManager.prototype.markQueryResult = function (queryId, result, _a, fetchMoreForQueryId) {\n    var fetchPolicy = _a.fetchPolicy,\n        variables = _a.variables,\n        errorPolicy = _a.errorPolicy;\n\n    if (fetchPolicy === 'no-cache') {\n      this.setQuery(queryId, function () {\n        return {\n          newData: {\n            result: result.data,\n            complete: true\n          }\n        };\n      });\n    } else {\n      this.dataStore.markQueryResult(result, this.getQuery(queryId).document, variables, fetchMoreForQueryId, errorPolicy === 'ignore' || errorPolicy === 'all');\n    }\n  };\n\n  QueryManager.prototype.queryListenerForObserver = function (queryId, options, observer) {\n    var _this = this;\n\n    function invoke(method, argument) {\n      if (observer[method]) {\n        try {\n          observer[method](argument);\n        } catch (e) {\n          process.env.NODE_ENV === \"production\" || invariant.error(e);\n        }\n      } else if (method === 'error') {\n        process.env.NODE_ENV === \"production\" || invariant.error(argument);\n      }\n    }\n\n    return function (queryStoreValue, newData) {\n      _this.invalidate(queryId, false);\n\n      if (!queryStoreValue) return;\n\n      var _a = _this.getQuery(queryId),\n          observableQuery = _a.observableQuery,\n          document = _a.document;\n\n      var fetchPolicy = observableQuery ? observableQuery.options.fetchPolicy : options.fetchPolicy;\n      if (fetchPolicy === 'standby') return;\n      var loading = isNetworkRequestInFlight(queryStoreValue.networkStatus);\n      var lastResult = observableQuery && observableQuery.getLastResult();\n      var networkStatusChanged = !!(lastResult && lastResult.networkStatus !== queryStoreValue.networkStatus);\n      var shouldNotifyIfLoading = options.returnPartialData || !newData && queryStoreValue.previousVariables || networkStatusChanged && options.notifyOnNetworkStatusChange || fetchPolicy === 'cache-only' || fetchPolicy === 'cache-and-network';\n\n      if (loading && !shouldNotifyIfLoading) {\n        return;\n      }\n\n      var hasGraphQLErrors = isNonEmptyArray(queryStoreValue.graphQLErrors);\n      var errorPolicy = observableQuery && observableQuery.options.errorPolicy || options.errorPolicy || 'none';\n\n      if (errorPolicy === 'none' && hasGraphQLErrors || queryStoreValue.networkError) {\n        return invoke('error', new ApolloError({\n          graphQLErrors: queryStoreValue.graphQLErrors,\n          networkError: queryStoreValue.networkError\n        }));\n      }\n\n      try {\n        var data = void 0;\n        var isMissing = void 0;\n\n        if (newData) {\n          if (fetchPolicy !== 'no-cache' && fetchPolicy !== 'network-only') {\n            _this.setQuery(queryId, function () {\n              return {\n                newData: null\n              };\n            });\n          }\n\n          data = newData.result;\n          isMissing = !newData.complete;\n        } else {\n          var lastError = observableQuery && observableQuery.getLastError();\n          var errorStatusChanged = errorPolicy !== 'none' && (lastError && lastError.graphQLErrors) !== queryStoreValue.graphQLErrors;\n\n          if (lastResult && lastResult.data && !errorStatusChanged) {\n            data = lastResult.data;\n            isMissing = false;\n          } else {\n            var diffResult = _this.dataStore.getCache().diff({\n              query: document,\n              variables: queryStoreValue.previousVariables || queryStoreValue.variables,\n              returnPartialData: true,\n              optimistic: true\n            });\n\n            data = diffResult.result;\n            isMissing = !diffResult.complete;\n          }\n        }\n\n        var stale = isMissing && !(options.returnPartialData || 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\n        if (errorPolicy === 'all' && hasGraphQLErrors) {\n          resultFromStore.errors = queryStoreValue.graphQLErrors;\n        }\n\n        invoke('next', resultFromStore);\n      } catch (networkError) {\n        invoke('error', new ApolloError({\n          networkError: networkError\n        }));\n      }\n    };\n  };\n\n  QueryManager.prototype.transform = function (document) {\n    var transformCache = this.transformCache;\n\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\n      var add = function add(doc) {\n        if (doc && !transformCache.has(doc)) {\n          transformCache.set(doc, cacheEntry_1);\n        }\n      };\n\n      add(document);\n      add(transformed);\n      add(clientQuery);\n      add(serverQuery);\n    }\n\n    return transformCache.get(document);\n  };\n\n  QueryManager.prototype.getVariables = function (document, variables) {\n    return __assign(__assign({}, this.transform(document).defaultVars), variables);\n  };\n\n  QueryManager.prototype.watchQuery = function (options, shouldSubscribe) {\n    if (shouldSubscribe === void 0) {\n      shouldSubscribe = true;\n    }\n\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\n    if (typeof options.notifyOnNetworkStatusChange === 'undefined') {\n      options.notifyOnNetworkStatusChange = false;\n    }\n\n    var transformedOptions = __assign({}, options);\n\n    return new ObservableQuery({\n      queryManager: this,\n      options: transformedOptions,\n      shouldSubscribe: shouldSubscribe\n    });\n  };\n\n  QueryManager.prototype.query = function (options) {\n    var _this = this;\n\n    process.env.NODE_ENV === \"production\" ? invariant(options.query, 12) : invariant(options.query, 'query option is required. You must specify your GraphQL document ' + '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\n      _this.fetchQueryRejectFns.set(\"query:\" + watchedQuery.queryId, reject);\n\n      watchedQuery.result().then(resolve, reject).then(function () {\n        return _this.fetchQueryRejectFns.delete(\"query:\" + watchedQuery.queryId);\n      });\n    });\n  };\n\n  QueryManager.prototype.generateQueryId = function () {\n    return String(this.idCounter++);\n  };\n\n  QueryManager.prototype.stopQueryInStore = function (queryId) {\n    this.stopQueryInStoreNoBroadcast(queryId);\n    this.broadcastQueries();\n  };\n\n  QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n    this.stopPollingQuery(queryId);\n    this.queryStore.stopQuery(queryId);\n    this.invalidate(queryId);\n  };\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 {\n        invalidated: false\n      };\n    });\n  };\n\n  QueryManager.prototype.updateQueryWatch = function (queryId, document, options) {\n    var _this = this;\n\n    var cancel = this.getQuery(queryId).cancel;\n    if (cancel) cancel();\n\n    var previousResult = function previousResult() {\n      var previousResult = null;\n\n      var observableQuery = _this.getQuery(queryId).observableQuery;\n\n      if (observableQuery) {\n        var lastResult = observableQuery.getLastResult();\n\n        if (lastResult) {\n          previousResult = lastResult.data;\n        }\n      }\n\n      return previousResult;\n    };\n\n    return this.dataStore.getCache().watch({\n      query: document,\n      variables: options.variables,\n      optimistic: true,\n      previousResult: previousResult,\n      callback: function callback(newData) {\n        _this.setQuery(queryId, function () {\n          return {\n            invalidated: true,\n            newData: newData\n          };\n        });\n      }\n    });\n  };\n\n  QueryManager.prototype.addObservableQuery = function (queryId, observableQuery) {\n    this.setQuery(queryId, function () {\n      return {\n        observableQuery: observableQuery\n      };\n    });\n  };\n\n  QueryManager.prototype.removeObservableQuery = function (queryId) {\n    var cancel = this.getQuery(queryId).cancel;\n    this.setQuery(queryId, function () {\n      return {\n        observableQuery: null\n      };\n    });\n    if (cancel) cancel();\n  };\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) resetIds.push(queryId);\n    });\n    this.queryStore.reset(resetIds);\n    this.mutationStore.reset();\n    return this.dataStore.reset();\n  };\n\n  QueryManager.prototype.resetStore = function () {\n    var _this = this;\n\n    return this.clearStore().then(function () {\n      return _this.reFetchObservableQueries();\n    });\n  };\n\n  QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n    var _this = this;\n\n    if (includeStandby === void 0) {\n      includeStandby = false;\n    }\n\n    var observableQueryPromises = [];\n    this.queries.forEach(function (_a, queryId) {\n      var observableQuery = _a.observableQuery;\n\n      if (observableQuery) {\n        var fetchPolicy = observableQuery.options.fetchPolicy;\n        observableQuery.resetLastResults();\n\n        if (fetchPolicy !== 'cache-only' && (includeStandby || fetchPolicy !== 'standby')) {\n          observableQueryPromises.push(observableQuery.refetch());\n        }\n\n        _this.setQuery(queryId, function () {\n          return {\n            newData: null\n          };\n        });\n\n        _this.invalidate(queryId);\n      }\n    });\n    this.broadcastQueries();\n    return Promise.all(observableQueryPromises);\n  };\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\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).catch(function () {\n      return undefined;\n    });\n    return queryId;\n  };\n\n  QueryManager.prototype.startGraphQLSubscription = function (_a) {\n    var _this = this;\n\n    var query = _a.query,\n        fetchPolicy = _a.fetchPolicy,\n        variables = _a.variables;\n    query = this.transform(query).document;\n    variables = this.getVariables(query, variables);\n\n    var makeObservable = function makeObservable(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\n          _this.broadcastQueries();\n        }\n\n        if (graphQLResultHasError(result)) {\n          throw new ApolloError({\n            graphQLErrors: result.errors\n          });\n        }\n\n        return result;\n      });\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) {\n          return sub = observable.subscribe(observer);\n        }, observer.error);\n        return function () {\n          return sub && sub.unsubscribe();\n        };\n      });\n    }\n\n    return makeObservable(variables);\n  };\n\n  QueryManager.prototype.stopQuery = function (queryId) {\n    this.stopQueryNoBroadcast(queryId);\n    this.broadcastQueries();\n  };\n\n  QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n    this.stopQueryInStoreNoBroadcast(queryId);\n    this.removeQuery(queryId);\n  };\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) {\n      return x.unsubscribe();\n    });\n    this.queries.delete(queryId);\n  };\n\n  QueryManager.prototype.getCurrentQueryResult = function (observableQuery, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = true;\n    }\n\n    var _a = observableQuery.options,\n        variables = _a.variables,\n        query = _a.query,\n        fetchPolicy = _a.fetchPolicy,\n        returnPartialData = _a.returnPartialData;\n    var lastResult = observableQuery.getLastResult();\n    var newData = this.getQuery(observableQuery.queryId).newData;\n\n    if (newData && newData.complete) {\n      return {\n        data: newData.result,\n        partial: false\n      };\n    }\n\n    if (fetchPolicy === 'no-cache' || fetchPolicy === 'network-only') {\n      return {\n        data: undefined,\n        partial: false\n      };\n    }\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    }),\n        result = _b.result,\n        complete = _b.complete;\n\n    return {\n      data: complete || returnPartialData ? result : void 0,\n      partial: !complete\n    };\n  };\n\n  QueryManager.prototype.getQueryWithPreviousResult = function (queryIdOrObservable) {\n    var observableQuery;\n\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    } else {\n      observableQuery = queryIdOrObservable;\n    }\n\n    var _a = observableQuery.options,\n        variables = _a.variables,\n        query = _a.query;\n    return {\n      previousResult: this.getCurrentQueryResult(observableQuery, false).data,\n      variables: variables,\n      document: query\n    };\n  };\n\n  QueryManager.prototype.broadcastQueries = function () {\n    var _this = this;\n\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\n  QueryManager.prototype.getLocalState = function () {\n    return this.localState;\n  };\n\n  QueryManager.prototype.getObservableFromLink = function (query, context, variables, deduplication) {\n    var _this = this;\n\n    if (deduplication === void 0) {\n      deduplication = this.queryDeduplication;\n    }\n\n    var observable;\n    var serverQuery = this.transform(query).serverQuery;\n\n    if (serverQuery) {\n      var _a = this,\n          inFlightLinkObservables_1 = _a.inFlightLinkObservables,\n          link = _a.link;\n\n      var operation = {\n        query: serverQuery,\n        variables: variables,\n        operationName: getOperationName(serverQuery) || void 0,\n        context: this.prepareContext(__assign(__assign({}, context), {\n          forceFetch: !deduplication\n        }))\n      };\n      context = operation.context;\n\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\n        if (!observable) {\n          byVariables_1.set(varJson_1, observable = multiplex(execute(link, operation)));\n\n          var cleanup = function cleanup() {\n            byVariables_1.delete(varJson_1);\n            if (!byVariables_1.size) inFlightLinkObservables_1.delete(serverQuery);\n            cleanupSub_1.unsubscribe();\n          };\n\n          var cleanupSub_1 = observable.subscribe({\n            next: cleanup,\n            error: cleanup,\n            complete: cleanup\n          });\n        }\n      } else {\n        observable = multiplex(execute(link, operation));\n      }\n    } else {\n      observable = Observable.of({\n        data: {}\n      });\n      context = this.prepareContext(context);\n    }\n\n    var clientQuery = this.transform(query).clientQuery;\n\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\n    return observable;\n  };\n\n  QueryManager.prototype.fetchRequest = function (_a) {\n    var _this = this;\n\n    var requestId = _a.requestId,\n        queryId = _a.queryId,\n        document = _a.document,\n        options = _a.options,\n        fetchMoreForQueryId = _a.fetchMoreForQueryId;\n    var variables = options.variables,\n        _b = options.errorPolicy,\n        errorPolicy = _b === void 0 ? 'none' : _b,\n        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\n      var fqrfId = \"fetchRequest:\" + queryId;\n\n      _this.fetchQueryRejectFns.set(fqrfId, reject);\n\n      var cleanup = function cleanup() {\n        _this.fetchQueryRejectFns.delete(fqrfId);\n\n        _this.setQuery(queryId, function (_a) {\n          var subscriptions = _a.subscriptions;\n          subscriptions.delete(subscription);\n        });\n      };\n\n      var subscription = observable.map(function (result) {\n        if (requestId >= _this.getQuery(queryId).lastRequestId) {\n          _this.markQueryResult(queryId, result, options, fetchMoreForQueryId);\n\n          _this.queryStore.markQueryResult(queryId, result, fetchMoreForQueryId);\n\n          _this.invalidate(queryId);\n\n          _this.invalidate(fetchMoreForQueryId);\n\n          _this.broadcastQueries();\n        }\n\n        if (errorPolicy === 'none' && isNonEmptyArray(result.errors)) {\n          return reject(new ApolloError({\n            graphQLErrors: result.errors\n          }));\n        }\n\n        if (errorPolicy === 'all') {\n          errorsFromStore = result.errors;\n        }\n\n        if (fetchMoreForQueryId || fetchPolicy === 'no-cache') {\n          resultFromStore = result.data;\n        } else {\n          var _a = _this.dataStore.getCache().diff({\n            variables: variables,\n            query: document,\n            optimistic: false,\n            returnPartialData: true\n          }),\n              result_1 = _a.result,\n              complete = _a.complete;\n\n          if (complete || options.returnPartialData) {\n            resultFromStore = result_1;\n          }\n        }\n      }).subscribe({\n        error: function error(_error3) {\n          cleanup();\n          reject(_error3);\n        },\n        complete: function complete() {\n          cleanup();\n          resolve({\n            data: resultFromStore,\n            errors: errorsFromStore,\n            loading: false,\n            networkStatus: NetworkStatus.ready,\n            stale: false\n          });\n        }\n      });\n\n      _this.setQuery(queryId, function (_a) {\n        var subscriptions = _a.subscriptions;\n        subscriptions.add(subscription);\n      });\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\n  QueryManager.prototype.setQuery = function (queryId, updater) {\n    var prev = this.getQuery(queryId);\n\n    var newInfo = __assign(__assign({}, prev), updater(prev));\n\n    this.queries.set(queryId, newInfo);\n  };\n\n  QueryManager.prototype.invalidate = function (queryId, invalidated) {\n    if (invalidated === void 0) {\n      invalidated = true;\n    }\n\n    if (queryId) {\n      this.setQuery(queryId, function () {\n        return {\n          invalidated: invalidated\n        };\n      });\n    }\n  };\n\n  QueryManager.prototype.prepareContext = function (context) {\n    if (context === void 0) {\n      context = {};\n    }\n\n    var newContext = this.localState.prepareContext(context);\n    return __assign(__assign({}, newContext), {\n      clientAwareness: this.clientAwareness\n    });\n  };\n\n  QueryManager.prototype.checkInFlight = function (queryId) {\n    var query = this.queryStore.get(queryId);\n    return query && query.networkStatus !== NetworkStatus.ready && query.networkStatus !== NetworkStatus.error;\n  };\n\n  QueryManager.prototype.startPollingQuery = function (options, queryId, listener) {\n    var _this = this;\n\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\n    if (!this.ssrMode) {\n      var info = this.pollingInfoByQueryId.get(queryId);\n\n      if (!info) {\n        this.pollingInfoByQueryId.set(queryId, info = {});\n      }\n\n      info.interval = pollInterval;\n      info.options = __assign(__assign({}, options), {\n        fetchPolicy: 'network-only'\n      });\n\n      var maybeFetch_1 = function maybeFetch_1() {\n        var info = _this.pollingInfoByQueryId.get(queryId);\n\n        if (info) {\n          if (_this.checkInFlight(queryId)) {\n            poll_1();\n          } else {\n            _this.fetchQuery(queryId, info.options, FetchType.poll).then(poll_1, poll_1);\n          }\n        }\n      };\n\n      var poll_1 = function poll_1() {\n        var info = _this.pollingInfoByQueryId.get(queryId);\n\n        if (info) {\n          clearTimeout(info.timeout);\n          info.timeout = setTimeout(maybeFetch_1, info.interval);\n        }\n      };\n\n      if (listener) {\n        this.addQueryListener(queryId, listener);\n      }\n\n      poll_1();\n    }\n\n    return queryId;\n  };\n\n  QueryManager.prototype.stopPollingQuery = function (queryId) {\n    this.pollingInfoByQueryId.delete(queryId);\n  };\n\n  return QueryManager;\n}();\n\nvar DataStore = function () {\n  function DataStore(initialCache) {\n    this.cache = initialCache;\n  }\n\n  DataStore.prototype.getCache = function () {\n    return this.cache;\n  };\n\n  DataStore.prototype.markQueryResult = function (result, document, variables, fetchMoreForQueryId, ignoreErrors) {\n    if (ignoreErrors === void 0) {\n      ignoreErrors = false;\n    }\n\n    var writeWithErrors = !graphQLResultHasError(result);\n\n    if (ignoreErrors && graphQLResultHasError(result) && result.data) {\n      writeWithErrors = true;\n    }\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\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\n  DataStore.prototype.markMutationInit = function (mutation) {\n    var _this = this;\n\n    if (mutation.optimisticResponse) {\n      var optimistic_1;\n\n      if (typeof mutation.optimisticResponse === 'function') {\n        optimistic_1 = mutation.optimisticResponse(mutation.variables);\n      } else {\n        optimistic_1 = mutation.optimisticResponse;\n      }\n\n      this.cache.recordOptimisticTransaction(function (c) {\n        var orig = _this.cache;\n        _this.cache = c;\n\n        try {\n          _this.markMutationResult({\n            mutationId: mutation.mutationId,\n            result: {\n              data: optimistic_1\n            },\n            document: mutation.document,\n            variables: mutation.variables,\n            updateQueries: mutation.updateQueries,\n            update: mutation.update\n          });\n        } finally {\n          _this.cache = orig;\n        }\n      }, mutation.mutationId);\n    }\n  };\n\n  DataStore.prototype.markMutationResult = function (mutation) {\n    var _this = this;\n\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\n      if (updateQueries_1) {\n        Object.keys(updateQueries_1).forEach(function (id) {\n          var _a = updateQueries_1[id],\n              query = _a.query,\n              updater = _a.updater;\n\n          var _b = _this.cache.diff({\n            query: query.document,\n            variables: query.variables,\n            returnPartialData: true,\n            optimistic: false\n          }),\n              currentQueryResult = _b.result,\n              complete = _b.complete;\n\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\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\n      this.cache.performTransaction(function (c) {\n        cacheWrites_1.forEach(function (write) {\n          return c.write(write);\n        });\n        var update = mutation.update;\n\n        if (update) {\n          tryFunctionOrLogError(function () {\n            return update(c, mutation.result);\n          });\n        }\n      });\n    }\n  };\n\n  DataStore.prototype.markMutationComplete = function (_a) {\n    var mutationId = _a.mutationId,\n        optimisticResponse = _a.optimisticResponse;\n\n    if (optimisticResponse) {\n      this.cache.removeOptimistic(mutationId);\n    }\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\n  DataStore.prototype.reset = function () {\n    return this.cache.reset();\n  };\n\n  return DataStore;\n}();\n\nvar version = \"2.6.10\";\nvar hasSuggestedDevtools = false;\n\nvar ApolloClient = function () {\n  function ApolloClient(options) {\n    var _this = this;\n\n    this.defaultOptions = {};\n    this.resetStoreCallbacks = [];\n    this.clearStoreCallbacks = [];\n    var cache = options.cache,\n        _a = options.ssrMode,\n        ssrMode = _a === void 0 ? false : _a,\n        _b = options.ssrForceFetchDelay,\n        ssrForceFetchDelay = _b === void 0 ? 0 : _b,\n        connectToDevTools = options.connectToDevTools,\n        _c = options.queryDeduplication,\n        queryDeduplication = _c === void 0 ? true : _c,\n        defaultOptions = options.defaultOptions,\n        _d = options.assumeImmutableResults,\n        assumeImmutableResults = _d === void 0 ? false : _d,\n        resolvers = options.resolvers,\n        typeDefs = options.typeDefs,\n        fragmentMatcher = options.fragmentMatcher,\n        clientAwarenessName = options.name,\n        clientAwarenessVersion = options.version;\n    var link = options.link;\n\n    if (!link && resolvers) {\n      link = ApolloLink.empty();\n    }\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\" + \"These options are part of the upgrade requirements when migrating from Apollo Client 1.x to Apollo Client 2.x.\\n\" + \"For more information, please visit: https://www.apollographql.com/docs/tutorial/client.html#apollo-client-setup\");\n    }\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\n    if (ssrForceFetchDelay) {\n      setTimeout(function () {\n        return _this.disableNetworkFetches = false;\n      }, ssrForceFetchDelay);\n    }\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' && typeof window !== 'undefined' && !window.__APOLLO_CLIENT__;\n\n    if (typeof connectToDevTools === 'undefined' ? defaultConnectToDevTools : connectToDevTools && typeof window !== 'undefined') {\n      window.__APOLLO_CLIENT__ = this;\n    }\n\n    if (!hasSuggestedDevtools && process.env.NODE_ENV !== 'production') {\n      hasSuggestedDevtools = true;\n\n      if (typeof window !== 'undefined' && window.document && window.top === window.self) {\n        if (typeof window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n          if (window.navigator && window.navigator.userAgent && window.navigator.userAgent.indexOf('Chrome') > -1) {\n            console.debug('Download the Apollo DevTools ' + 'for a better development experience: ' + 'https://chrome.google.com/webstore/detail/apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm');\n          }\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 onBroadcast() {\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\n  ApolloClient.prototype.stop = function () {\n    this.queryManager.stop();\n  };\n\n  ApolloClient.prototype.watchQuery = function (options) {\n    if (this.defaultOptions.watchQuery) {\n      options = __assign(__assign({}, this.defaultOptions.watchQuery), options);\n    }\n\n    if (this.disableNetworkFetches && (options.fetchPolicy === 'network-only' || options.fetchPolicy === 'cache-and-network')) {\n      options = __assign(__assign({}, options), {\n        fetchPolicy: 'cache-first'\n      });\n    }\n\n    return this.queryManager.watchQuery(options);\n  };\n\n  ApolloClient.prototype.query = function (options) {\n    if (this.defaultOptions.query) {\n      options = __assign(__assign({}, this.defaultOptions.query), options);\n    }\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 ' + 'client.query can only return a single result. Please use client.watchQuery ' + 'to receive multiple results from the cache and the network, or consider ' + 'using a different fetchPolicy, such as cache-first or network-only.');\n\n    if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {\n      options = __assign(__assign({}, options), {\n        fetchPolicy: 'cache-first'\n      });\n    }\n\n    return this.queryManager.query(options);\n  };\n\n  ApolloClient.prototype.mutate = function (options) {\n    if (this.defaultOptions.mutate) {\n      options = __assign(__assign({}, this.defaultOptions.mutate), options);\n    }\n\n    return this.queryManager.mutate(options);\n  };\n\n  ApolloClient.prototype.subscribe = function (options) {\n    return this.queryManager.startGraphQLSubscription(options);\n  };\n\n  ApolloClient.prototype.readQuery = function (options, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return this.cache.readQuery(options, optimistic);\n  };\n\n  ApolloClient.prototype.readFragment = function (options, optimistic) {\n    if (optimistic === void 0) {\n      optimistic = false;\n    }\n\n    return this.cache.readFragment(options, optimistic);\n  };\n\n  ApolloClient.prototype.writeQuery = function (options) {\n    var result = this.cache.writeQuery(options);\n    this.queryManager.broadcastQueries();\n    return result;\n  };\n\n  ApolloClient.prototype.writeFragment = function (options) {\n    var result = this.cache.writeFragment(options);\n    this.queryManager.broadcastQueries();\n    return result;\n  };\n\n  ApolloClient.prototype.writeData = function (options) {\n    var result = this.cache.writeData(options);\n    this.queryManager.broadcastQueries();\n    return result;\n  };\n\n  ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n    this.devToolsHookCb = cb;\n  };\n\n  ApolloClient.prototype.__requestRaw = function (payload) {\n    return execute(this.link, payload);\n  };\n\n  ApolloClient.prototype.initQueryManager = function () {\n    process.env.NODE_ENV === \"production\" || invariant.warn('Calling the initQueryManager method is no longer necessary, ' + 'and it will be removed from ApolloClient in version 3.0.');\n    return this.queryManager;\n  };\n\n  ApolloClient.prototype.resetStore = function () {\n    var _this = this;\n\n    return Promise.resolve().then(function () {\n      return _this.queryManager.clearStore();\n    }).then(function () {\n      return Promise.all(_this.resetStoreCallbacks.map(function (fn) {\n        return fn();\n      }));\n    }).then(function () {\n      return _this.reFetchObservableQueries();\n    });\n  };\n\n  ApolloClient.prototype.clearStore = function () {\n    var _this = this;\n\n    return Promise.resolve().then(function () {\n      return _this.queryManager.clearStore();\n    }).then(function () {\n      return Promise.all(_this.clearStoreCallbacks.map(function (fn) {\n        return fn();\n      }));\n    });\n  };\n\n  ApolloClient.prototype.onResetStore = function (cb) {\n    var _this = this;\n\n    this.resetStoreCallbacks.push(cb);\n    return function () {\n      _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) {\n        return c !== cb;\n      });\n    };\n  };\n\n  ApolloClient.prototype.onClearStore = function (cb) {\n    var _this = this;\n\n    this.clearStoreCallbacks.push(cb);\n    return function () {\n      _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) {\n        return c !== cb;\n      });\n    };\n  };\n\n  ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n    return this.queryManager.reFetchObservableQueries(includeStandby);\n  };\n\n  ApolloClient.prototype.extract = function (optimistic) {\n    return this.cache.extract(optimistic);\n  };\n\n  ApolloClient.prototype.restore = function (serializedState) {\n    return this.cache.restore(serializedState);\n  };\n\n  ApolloClient.prototype.addResolvers = function (resolvers) {\n    this.localState.addResolvers(resolvers);\n  };\n\n  ApolloClient.prototype.setResolvers = function (resolvers) {\n    this.localState.setResolvers(resolvers);\n  };\n\n  ApolloClient.prototype.getResolvers = function () {\n    return this.localState.getResolvers();\n  };\n\n  ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n    this.localState.setFragmentMatcher(fragmentMatcher);\n  };\n\n  return ApolloClient;\n}();\n\nexport default ApolloClient;\nexport { ApolloClient, ApolloError, FetchType, NetworkStatus, ObservableQuery, isApolloError };","/*!\n  Copyright (c) 2017 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n\n/* global define */\n(function () {\n  'use strict';\n\n  var hasOwn = {}.hasOwnProperty;\n\n  function classNames() {\n    var classes = [];\n\n    for (var i = 0; i < arguments.length; i++) {\n      var arg = arguments[i];\n      if (!arg) continue;\n      var argType = typeof arg;\n\n      if (argType === 'string' || argType === 'number') {\n        classes.push(arg);\n      } else if (Array.isArray(arg) && arg.length) {\n        var inner = classNames.apply(null, arg);\n\n        if (inner) {\n          classes.push(inner);\n        }\n      } else if (argType === 'object') {\n        for (var key in arg) {\n          if (hasOwn.call(arg, key) && arg[key]) {\n            classes.push(key);\n          }\n        }\n      }\n    }\n\n    return classes.join(' ');\n  }\n\n  if (typeof module !== 'undefined' && module.exports) {\n    classNames.default = classNames;\n    module.exports = classNames;\n  } else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n    // register as 'classnames', consistent with npm package name\n    define('classnames', [], function () {\n      return classNames;\n    });\n  } else {\n    window.classNames = classNames;\n  }\n})();"],"sourceRoot":""}