{"version":3,"sources":["webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useEntryPointLoader.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/usePreloadedQuery.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useIsMountedRef.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/loadEntryPoint.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/ReactRelayContext.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useLazyLoadQueryNode.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/ReactRelayPaginationContainer.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useLazyLoadQuery.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/assertFragmentMap.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useRefetchableFragment.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useFetchTrackingRef.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/ReactRelayQueryFetcher.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/LRUCache.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useMutation.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/getRootVariablesForFragments.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/ProfilerContext.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/ReactRelayRefetchContainer.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/ReactRelayFragmentContainer.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/isRelayEnvironment.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/QueryResource.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/getPaginationMetadata.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useRefetchableFragmentNode.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/RelayEnvironmentProvider.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/ReactRelayQueryRendererContext.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/getValueAtPath.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/getRefetchMetadata.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/getPaginationVariables.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/readContext.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useIsOperationNodeActive.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useRelayEnvironment.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useStaticFragmentNodeWarning.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useFragmentNode.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/ReactRelayQueryRenderer.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/FragmentResource.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/index.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/loadQuery.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useLoadMoreFunction.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useQueryLoader.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/ReactRelayContainerUtils.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useSubscribeToInvalidationState.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useFragment.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useMemoVariables.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/ReactRelayContext.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/usePaginationFragment.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/index.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/ReactRelayLocalQueryRenderer.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/buildReactRelayContainer.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/RelayContext.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useSubscription.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/useMemoOperationDescriptor.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/react-relay/lib/relay-hooks/EntryPointContainer.react.js"],"names":["_createForOfIteratorHelper2","_interopRequireDefault","loadEntryPoint","useIsMountedRef","useTrackLoadQueryInRender","_require2","useCallback","useEffect","useRef","useState","initialNullEntryPointReferenceState","kind","module","exports","environmentProvider","entryPoint","options","_options$TEST_ONLY__i","_options$TEST_ONLY__i2","_options$TEST_ONLY__i3","_options$TEST_ONLY__i4","initialEntryPointReferenceInternal","TEST_ONLY__initialEntryPointData","entryPointReference","initialEntryPointParamsInternal","entryPointParams","isMountedRef","undisposedEntryPointReferencesRef","Set","_useState","setEntryPointReference","_useState2","setEntryPointParams","disposeEntryPoint","current","nullEntryPointReference","add","entryPointLoaderCallback","params","updatedEntryPointReference","maybeHiddenOrFastRefresh","undisposedEntryPointReferences","_step","_iterator","s","n","done","undisposedEntryPointReference","value","dispose","err","e","f","_step2","_iterator2","unhandledStateChange","invariant","useLazyLoadQueryNode","useMemoOperationDescriptor","useRelayEnvironment","_require3$__internal","useDebugValue","__internal","fetchQueryDeduped","fetchQuery","gqlQuery","preloadedQuery","useLazyLoadQueryNodeParams","environment","fetchKey","fetchPolicy","source","variables","networkCacheConfig","operation","request","node","name","componentDisplayName","fetchObservable","identifier","executeWithSource","execute","query","renderPolicy","UNSTABLE_renderPolicy","fallbackFetchObservable","ifEmpty","_require","loadQuery","loadingPromise","root","getModuleIfRequired","load","preloadProps","getPreloadProps","queries","entryPoints","extraProps","preloadedQueries","preloadedEntryPoints","Object","keys","forEach","queryPropName","_queries$queryPropNam","environmentProviderOptions","parameters","getEnvironment","__nameForWarning","entryPointPropName","entryPointDescription","nestedEntryPoint","nestedParams","isDisposed","values","_ref","innerDispose","_ref2","getComponent","_loadingPromise","component","rootModuleID","getModuleId","React","createRelayContext","ProfilerContext","useFetchTrackingRef","useFragmentNode","getQueryResourceForEnvironment","getQueryCacheIdentifier","useContext","profilerContext","QueryResource","forceUpdateKey","forceUpdate","_useFetchTrackingRef","startFetch","completeFetch","cacheBreaker","concat","cacheIdentifier","preparedQueryResult","wrapPrepareQueryResource","prepareWithIdentifier","start","complete","error","disposable","retain","fragmentNode","fragmentRef","data","_extends2","_objectWithoutPropertiesLoose2","_assertThisInitialized2","_inheritsLoose2","_defineProperty2","_objectSpread3","ReactRelayContext","ReactRelayQueryFetcher","areEqual","buildReactRelayContainer","getRootVariablesForFragments","getComponentName","getContainerName","assertRelayContext","_require3","ConnectionInterface","Observable","createFragmentSpecResolver","createOperationDescriptor","getDataIDsFromObject","getRequest","getVariablesFromObject","getSelector","isScalarAndEqual","FORWARD","toObserver","observerOrCallback","unsubscribe","subscription","createContainerWithFragments","Component","fragments","connectionConfig","_class","_temp","containerName","metadata","foundConnectionMetadata","isRelayModern","fragmentName","fragment","connectionMetadata","connection","undefined","length","findConnectionMetadata","getConnectionFromProps","path","props","i","createGetConnectionFromProps","direction","getFragmentVariables","countVariable","count","prevVars","totalCount","createGetFragmentVariables","_React$Component","_props$__rootIsQueryR","_this","call","this","setState","_resolver","resolve","connectionData","_getConnectionData","hasMore","cursor","_refetchSubscription","refetchVariables","_canFetchPage","_refetchVariables","paginatingVariables","_fetchPage","force","pageSize","observer","create","sink","subscribe","edgeCount","_refetchConnection","_ConnectionInterface$","get","END_CURSOR","START_CURSOR","relayContext","__relayContext","rootIsQueryRenderer","__rootIsQueryRenderer","_isARequestInFlight","_handleFragmentDataUpdate","state","prevContext","contextForChildren","relayProp","_buildRelayProp","_isUnmounted","_hasFetched","_proto","prototype","componentDidMount","UNSAFE_componentWillReceiveProps","nextProps","_nextProps$__rootIsQu","prevIDs","nextIDs","prevRootVariables","nextRootVariables","setProps","_cleanup","componentWillUnmount","shouldComponentUpdate","nextState","ii","_key","hasOwnProperty","_hasMore","isLoading","_isLoading","loadMore","_loadMore","refetchConnection","_this$props","restProps","componentRef","_ConnectionInterface$2","EDGES","PAGE_INFO","HAS_NEXT_PAGE","HAS_PREV_PAGE","edges","pageInfo","Array","isArray","_getQueryFetcher","_queryFetcher","method","fragmentVariables","_this2","_this$props2","rootVariables","fetchVariables","getVariables","cacheConfig","refetchSubscription","cleanup","preservePreviousReferences","mergeMap","payload","prevData","setVariables","nextData","onNext","next","render","_this$props3","createElement","Provider","ref","relay","createContainer","fragmentSpec","ComponentClass","componentName","key","useRefetchableFragmentNode","useStaticFragmentNodeWarning","getFragment","fragmentInput","_useRefetchableFragme","fragmentData","refetch","subscriptionRef","isFetchingRef","disposeFetch","isRelayModernEnvironment","args","_cacheSelectionReference","cacheSelectionReference","_selectionReferences","selectionReferences","getSelectionReferences","lookupInStore","check","status","_retainCachedOperation","lookup","_ref$preservePrevious","reference","disposeSelectionReferences","setOnDataChange","onDataChange","_fetchOptions","onDataChangeCallbacks","push","_callOnDataChangeWhenSet","_error","_snapshot","snapshot","fetch","fetchOptions","cacheConfigOverride","fetchHasReturned","disposeRequest","oldOnDataChangeCallbacks","indexOf","operationOverride","_pendingRequest","_onQueryDataAvailable","notifyFirstResult","retry","_rootSubscription","_disposeCacheSelectionReference","r","_this3","_this$_fetchOptions","maybeNewOnDataChangeCallbacks","LRUCache","capacity","_capacity","_map","Map","set","size","firstKey","has","clear","_objectSpread2","defaultCommitMutation","commitMutation","mutation","commitMutationFn","arguments","environmentRef","mutationRef","inFlightMutationsRef","isMutationInFlight","setMutationInFlight","commit","config","onCompleted","response","errors","onError","onUnsubscribe","_selector$selectors$","_selector$selectors$2","_selector$owner$varia","selector","fragmentOwnerVariables","selectors","owner","createContext","cb","getRelayProp","taggedNode","resolverFromThisUpdate","resolver","updatedState","renderVariables","_getFragmentVariables","localVariables","latestState","prevProps","prevPropsContext","_refetch","_subscribeToNewResolver","componentDidUpdate","prevState","getDerivedStateFromProps","_this$state","setCallback","maybeNewData","_this$state2","_rerenderIfStoreHasChanged","isPromise","DEFAULT_FETCH_POLICY","WEAKMAP_SUPPORTED","WeakMap","maybeFetchPolicy","maybeRenderPolicy","UNSTABLE_getDefaultRenderPolicy","getQueryResult","rootFragmentRef","__id","dataID","__fragments","__fragmentOwner","nextID","createCacheEntry","networkSubscription","onDispose","currentValue","retainCount","retainDisposable","releaseTemporaryRetain","currentNetworkSubscription","Math","max","cacheEntry","id","getValue","setValue","val","getRetainCount","getNetworkSubscription","setNetworkSubscription","temporaryRetain","isServer","releaseQueryTimeout","localReleaseTemporaryRetain","clearTimeout","setTimeout","permanentRetain","QueryResourceImpl","_cache","_environment","prepare","temporaryRetainDisposable","_fetchAndSaveQuery","observerUnsubscribe","cachedValue","Error","queryResult","_getOrCreateCacheEntry","__log","resourceID","TESTS_ONLY__getCacheEntry","_clearCacheEntry","shouldFetch","shouldAllowRender","queryAvailability","queryStatus","hasFullQuery","canPartialRender","resolveNetworkPromise","_cacheEntry","_queryResult","observerStart","observerNext","observerError","observerComplete","_cacheEntry2","networkPromise","Promise","displayName","createQueryResource","dataResources","cached","newDataResource","getRefetchMetadata","_fragmentNode$metadat","_fragmentNode$metadat2","_getRefetchMetadata","paginationRequest","refetchableRequest","refetchMetadata","paginationMetadata","connectionPathInFragmentData","identifierField","stream","getValueAtPath","useQueryLoader","getFragmentResourceForEnvironment","useReducer","_require4","getFragmentIdentifier","reducer","action","type","_action$refetchEnviro","mirroredEnvironment","refetchEnvironment","onComplete","refetchQuery","mirroredFragmentIdentifier","fragmentIdentifier","parentFragmentRef","parentEnvironment","fragmentRefPathInResponse","_useReducer","refetchState","dispatch","FragmentResource","shouldReset","_useQueryLoader","queryRef","disposeQuery","handleQueryCompleted","maybeError","queryData","read","_useFragmentNode","disableStoreUpdates","enableStoreUpdates","identifierValue","providedRefetchVariables","parentVariables","__environment","fragmentSelector","_fragmentSelector$sel","_fragmentSelector$sel2","_fragmentSelector$sel3","_fragmentSelector$sel4","useRefetchFunction","useMemo","children","context","result","plural","fragmentPathInResult","_objectSpread4","baseVariables","extraVariables","backwardMetadata","backward","forwardMetadata","forward","_paginationVariables","paginationVariables","_React$__SECRET_INTER","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentDispatcher","ReactCurrentOwner","Context","currentDispatcher","readContext","getObservableForActiveRequest","observable","isActive","setIsActive","onCompleteOrError","warningContext","fragmentResult","readWithIdentifier","isListeningForUpdatesRef","handleDataUpdate","checkMissedUpdates","ReactRelayQueryRendererContext","deepFreeze","requestCache","queryRendererContext","ReactRelayQueryRenderer","queryFetcher","requestCacheKey","retryCallbacks","handleDataChange","handleRetryAfterError","getRequestCacheKey","prevPropsEnvironment","prevPropsVariables","prevQuery","fetchQueryAndComputeStateFromProps","prevSelectionReferences","prevRequestCacheKey","renderProps","getRenderProps","syncSnapshot","JSON","stringify","cacheID","genericEnvironment","storeSnapshot","_toConsumableArray2","getPromiseForActiveRequest","recycleNodesInto","reportMissingRequiredFields","CONSTANT_READONLY_EMPTY_ARRAY","freeze","getFragmentResult","cacheKey","map","FragmentResourceImpl","fragmentKey","_reportMissingRequiredFieldsInSnapshot","fragmentOwner","some","isMissingData","_getAndSavePromiseForFragmentRequestInFlight","missingRequiredFields","readSpec","fragmentNodes","fragmentRefs","callback","renderedSnapshot","_this$checkMissedUpda","didMissUpdates","currentSnapshot","dataSubscriptions","idx","latestSnapshot","_updatePluralSnapshot","subscribeSpec","fragmentResults","disposables","currentSnapshots","renderData","currentData","updatedData","seenRecords","checkMissedUpdatesSpec","_this4","_getPromiseForActiveR","_this5","getOperationTracker","getPromiseForPendingOperationsAffectingOwner","getPromiseForPendingOperationAffectingOwner","promise","then","queryName","promiseDisplayName","baseSnapshots","currentFragmentResult","reportInvalidCachedData","nextSnapshots","nodeName","createFragmentResource","EntryPointContainer","ReactRelayFragmentContainer","ReactRelayLocalQueryRenderer","ReactRelayPaginationContainer","ReactRelayRefetchContainer","RelayEnvironmentProvider","RelayRuntime","useEntryPointLoader","useFragment","useLazyLoadQuery","useMutation","usePaginationFragment","usePreloadedQuery","useRefetchableFragment","useSubscribeToInvalidationState","useSubscription","ConnectionHandler","QueryRenderer","LocalQueryRenderer","MutationTypes","RangeOperations","applyOptimisticMutation","commitLocalUpdate","createFragmentContainer","createPaginationContainer","createRefetchContainer","fetchQuery_DEPRECATED","graphql","readInlineData","requestSubscription","PreloadableQueryRegistry","ReplaySubject","getRequestIdentifier","RelayFeatureFlags","RenderDispatcher","preloadableRequest","_React$__SECRET_INTER3","_React$__SECRET_INTER4","_options$fetchPolicy","retainReference","unsubscribeFromNetworkRequest","unsubscribeFromExecution","cancelOnLoadCallback","queryId","didExecuteNetworkSource","executeWithNetworkSource","networkObservable","executionSubject","returnedObservable","networkError","didMakeNetworkRequest","makeNetworkRequest","subject","ENABLE_LOAD_QUERY_REQUEST_DEDUPING","getNetwork","subjectSubscription","executeDeduped","fetchFn","_fetchQueryDeduped$su","checkAvailabilityAndExecute","concreteRequest","_module","_PreloadableQueryRegi","onLoad","preloadedModule","_React$__SECRET_INTER2","getPaginationVariables","useIsOperationNodeActive","onReset","setMirroredEnvironment","setMirroredFragmentIdentifier","isParentQueryActive","_getConnectionState","_pageInfo$END_CURSOR","_pageInfo$START_CURSO","getConnectionState","UNSTABLE_extraVariables","paginationQuery","initialNullQueryReferenceState","initialQueryReference","initialQueryReferenceInternal","undisposedQueryReferencesRef","queryReference","setQueryReference","previousInitialQueryReference","setPreviousInitialQueryReference","queryLoaderCallback","mergedOptions","_options$__environmen","updatedQueryReference","undisposedQueryReferences","undisposedQueryReference","dataIDs","disposableRef","stableDataIDs","from","sort","join","store","getStore","invalidationState","lookupInvalidationState","subscribeToInvalidationState","_variablesChangedGene2","_variablesChangedGene","variablesChangedGenerationRef","mirroredVariables","setMirroredVariables","getPaginationMetadata","useLoadMoreFunction","useLoadMore","isLoadingMore","setIsLoadingMore","_useLoadMoreFunction","_getPaginationMetadat","_useLoadMore","loadPrevious","hasPrevious","isLoadingPrevious","disposeFetchPrevious","_useLoadMore2","loadNext","hasNext","isLoadingNext","disposeFetchNext","useLayoutEffect","latestVariables","latestValue","useDeepCompare","dataRef","cleanupFnRef","res","subscribeDisposable","newSnapshot","disposed","cleanupFn","assertFragmentMap","Container","forwardRef","_queryRendererContext","isRelayEnvironment","isRelayContext","requestSubscriptionFn","actualRequestSubscription","useMemoVariables","memoVariables","memoCacheConfig"],"mappings":"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","file":"static/chunks/2f6017f8d425c29771aaea2d950aad6594aef757.3cf8cbf6e3ff0032ee36.js","sourcesContent":["/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar loadEntryPoint = require('./loadEntryPoint');\n\nvar useIsMountedRef = require('./useIsMountedRef');\n\nvar _require = require('./loadQuery'),\n    useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;\n\nvar _require2 = require('react'),\n    useCallback = _require2.useCallback,\n    useEffect = _require2.useEffect,\n    useRef = _require2.useRef,\n    useState = _require2.useState;\n\nvar initialNullEntryPointReferenceState = {\n  kind: 'NullEntryPointReference'\n};\n\nfunction useLoadEntryPoint(environmentProvider, entryPoint, options) {\n  var _options$TEST_ONLY__i, _options$TEST_ONLY__i2, _options$TEST_ONLY__i3, _options$TEST_ONLY__i4;\n\n  /**\n   * We want to always call `entryPointReference.dispose()` for every call to\n   * `setEntryPointReference(loadEntryPoint(...))` so that no leaks of data in Relay\n   * stores will occur.\n   *\n   * However, a call to `setState(newState)` is not always followed by a commit where\n   * this value is reflected in the state. Thus, we cannot reliably clean up each ref\n   * with `useEffect(() => () => entryPointReference.dispose(), [entryPointReference])`.\n   *\n   * Instead, we keep track of each call to `loadEntryPoint` in a ref.\n   * Relying on the fact that if a state change commits, no state changes that were\n   * initiated prior to the currently committing state change will ever subsequently\n   * commit, we can safely dispose of all preloaded entry point references\n   * associated with state changes initiated prior to the currently committing state\n   * change.\n   *\n   * Finally, when the hook unmounts, we also dispose of all remaining uncommitted\n   * entry point references.\n   */\n  useTrackLoadQueryInRender();\n  var initialEntryPointReferenceInternal = (_options$TEST_ONLY__i = options === null || options === void 0 ? void 0 : (_options$TEST_ONLY__i2 = options.TEST_ONLY__initialEntryPointData) === null || _options$TEST_ONLY__i2 === void 0 ? void 0 : _options$TEST_ONLY__i2.entryPointReference) !== null && _options$TEST_ONLY__i !== void 0 ? _options$TEST_ONLY__i : initialNullEntryPointReferenceState;\n  var initialEntryPointParamsInternal = (_options$TEST_ONLY__i3 = options === null || options === void 0 ? void 0 : (_options$TEST_ONLY__i4 = options.TEST_ONLY__initialEntryPointData) === null || _options$TEST_ONLY__i4 === void 0 ? void 0 : _options$TEST_ONLY__i4.entryPointParams) !== null && _options$TEST_ONLY__i3 !== void 0 ? _options$TEST_ONLY__i3 : null;\n  var isMountedRef = useIsMountedRef();\n  var undisposedEntryPointReferencesRef = useRef(new Set([initialEntryPointReferenceInternal]));\n\n  var _useState = useState(initialEntryPointReferenceInternal),\n      entryPointReference = _useState[0],\n      setEntryPointReference = _useState[1];\n\n  var _useState2 = useState(initialEntryPointParamsInternal),\n      entryPointParams = _useState2[0],\n      setEntryPointParams = _useState2[1];\n\n  var disposeEntryPoint = useCallback(function () {\n    if (isMountedRef.current) {\n      var nullEntryPointReference = {\n        kind: 'NullEntryPointReference'\n      };\n      undisposedEntryPointReferencesRef.current.add(nullEntryPointReference);\n      setEntryPointReference(nullEntryPointReference);\n    }\n  }, [setEntryPointReference, isMountedRef]);\n  var entryPointLoaderCallback = useCallback(function (params) {\n    if (isMountedRef.current) {\n      var updatedEntryPointReference = loadEntryPoint(environmentProvider, entryPoint, params);\n      undisposedEntryPointReferencesRef.current.add(updatedEntryPointReference);\n      setEntryPointReference(updatedEntryPointReference);\n      setEntryPointParams(params);\n    }\n  }, [environmentProvider, entryPoint, setEntryPointReference, isMountedRef]);\n  var maybeHiddenOrFastRefresh = useRef(false);\n  useEffect(function () {\n    return function () {\n      // Attempt to detect if the component was\n      // hidden (by Offscreen API), or fast refresh occured;\n      // Only in these situations would the effect cleanup\n      // for \"unmounting\" run multiple times, so if\n      // we are ever able to read this ref with a value\n      // of true, it means that one of these cases\n      // has happened.\n      maybeHiddenOrFastRefresh.current = true;\n    };\n  }, []);\n  useEffect(function () {\n    if (maybeHiddenOrFastRefresh.current === true) {\n      // This block only runs if the component has previously \"unmounted\"\n      // due to it being hidden by the Offscreen API, or during fast refresh.\n      // At this point, the current entryPointReference will have been disposed\n      // by the previous cleanup, so instead of attempting to\n      // do our regular commit setup, which would incorrectly leave our\n      // current entryPointReference disposed, we need to load the entryPoint again\n      // and force a re-render by calling entryPointLoaderCallback again,\n      // so that the entryPointReference's queries are correctly re-retained, and\n      // potentially refetched if necessary.\n      maybeHiddenOrFastRefresh.current = false;\n\n      if (entryPointReference.kind !== 'NullEntryPointReference' && entryPointParams != null) {\n        entryPointLoaderCallback(entryPointParams);\n      }\n\n      return;\n    } // When a new entryPointReference is committed, we iterate over all\n    // entrypoint refs in undisposedEntryPointReferences and dispose all of\n    // the refs that aren't the currently committed one. This ensures\n    // that we don't leave any dangling entrypoint references for the\n    // case that loadEntryPoint is called multiple times before commit; when\n    // this happens, multiple state updates will be scheduled, but only one\n    // will commit, meaning that we need to keep track of and dispose any\n    // query references that don't end up committing.\n    // - We are relying on the fact that sets iterate in insertion order, and we\n    // can remove items from a set as we iterate over it (i.e. no iterator\n    // invalidation issues.) Thus, it is safe to loop through\n    // undisposedEntryPointReferences until we find entryPointReference, and\n    // remove and dispose all previous references.\n    // - We are guaranteed to find entryPointReference in the set, because if a\n    // state change results in a commit, no state changes initiated prior to that\n    // one will be committed, and we are disposing and removing references\n    // associated with commits that were initiated prior to the currently\n    // committing state change. (A useEffect callback is called during the commit\n    // phase.)\n\n\n    var undisposedEntryPointReferences = undisposedEntryPointReferencesRef.current;\n\n    if (isMountedRef.current) {\n      var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(undisposedEntryPointReferences),\n          _step;\n\n      try {\n        for (_iterator.s(); !(_step = _iterator.n()).done;) {\n          var undisposedEntryPointReference = _step.value;\n\n          if (undisposedEntryPointReference === entryPointReference) {\n            break;\n          }\n\n          undisposedEntryPointReferences[\"delete\"](undisposedEntryPointReference);\n\n          if (undisposedEntryPointReference.kind !== 'NullEntryPointReference') {\n            undisposedEntryPointReference.dispose();\n          }\n        }\n      } catch (err) {\n        _iterator.e(err);\n      } finally {\n        _iterator.f();\n      }\n    }\n  }, [entryPointReference, entryPointParams, entryPointLoaderCallback, isMountedRef]);\n  useEffect(function () {\n    return function disposeAllRemainingEntryPointReferences() {\n      // undisposedEntryPointReferences.current is never reassigned\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      var _iterator2 = (0, _createForOfIteratorHelper2[\"default\"])(undisposedEntryPointReferencesRef.current),\n          _step2;\n\n      try {\n        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n          var unhandledStateChange = _step2.value;\n\n          if (unhandledStateChange.kind !== 'NullEntryPointReference') {\n            unhandledStateChange.dispose();\n          }\n        }\n      } catch (err) {\n        _iterator2.e(err);\n      } finally {\n        _iterator2.f();\n      }\n    };\n  }, []);\n  return [entryPointReference.kind === 'NullEntryPointReference' ? null : entryPointReference, entryPointLoaderCallback, disposeEntryPoint];\n}\n\nmodule.exports = useLoadEntryPoint;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar invariant = require('invariant');\n\nvar useLazyLoadQueryNode = require('./useLazyLoadQueryNode');\n\nvar useMemoOperationDescriptor = require('./useMemoOperationDescriptor');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('./loadQuery'),\n    useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;\n\nvar _require2 = require('react'),\n    useDebugValue = _require2.useDebugValue;\n\nvar _require3 = require('relay-runtime'),\n    _require3$__internal = _require3.__internal,\n    fetchQueryDeduped = _require3$__internal.fetchQueryDeduped,\n    fetchQuery = _require3$__internal.fetchQuery;\n\nfunction usePreloadedQuery(gqlQuery, preloadedQuery, options) {\n  // We need to use this hook in order to be able to track if\n  // loadQuery was called during render\n  useTrackLoadQueryInRender();\n  var environment = useRelayEnvironment();\n  var fetchKey = preloadedQuery.fetchKey,\n      fetchPolicy = preloadedQuery.fetchPolicy,\n      source = preloadedQuery.source,\n      variables = preloadedQuery.variables,\n      networkCacheConfig = preloadedQuery.networkCacheConfig;\n  var operation = useMemoOperationDescriptor(gqlQuery, variables, networkCacheConfig);\n  var useLazyLoadQueryNodeParams;\n\n  if (preloadedQuery.kind === 'PreloadedQuery_DEPRECATED') {\n    !(operation.request.node.params.name === preloadedQuery.name) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'usePreloadedQuery(): Expected data to be prefetched for query `%s`, ' + 'got prefetch results for query `%s`.', operation.request.node.params.name, preloadedQuery.name) : invariant(false) : void 0;\n    useLazyLoadQueryNodeParams = {\n      componentDisplayName: 'usePreloadedQuery()',\n      fetchKey: fetchKey,\n      fetchObservable: fetchQueryDeduped(environment, operation.request.identifier, function () {\n        if (environment === preloadedQuery.environment && source != null) {\n          return environment.executeWithSource({\n            operation: operation,\n            source: source\n          });\n        } else {\n          return environment.execute({\n            operation: operation\n          });\n        }\n      }),\n      fetchPolicy: fetchPolicy,\n      query: operation,\n      renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy\n    };\n  } else {\n    process.env.NODE_ENV !== \"production\" ? warning(preloadedQuery.isDisposed === false, 'usePreloadedQuery(): Expected preloadedQuery to not be disposed yet. ' + 'This is because disposing the query marks it for future garbage ' + 'collection, and as such query results may no longer be present in the Relay ' + 'store. In the future, this will become a hard error.') : void 0;\n    var fallbackFetchObservable = fetchQuery(environment, operation);\n    var fetchObservable;\n\n    if (source != null && environment === preloadedQuery.environment) {\n      // If the source observable exists and the environments match, reuse\n      // the source observable.\n      // If the source observable happens to be empty, we need to fall back\n      // and re-execute and de-dupe the query (at render time).\n      fetchObservable = source.ifEmpty(fallbackFetchObservable);\n    } else if (environment !== preloadedQuery.environment) {\n      // If a call to loadQuery is made with a particular environment, and that\n      // preloaded query is passed to usePreloadedQuery in a different environment\n      // context, we cannot re-use the existing preloaded query.\n      // Instead, we need to fall back and re-execute and de-dupe the query with\n      // the new environment (at render time).\n      // TODO T68036756 track occurences of this warning and turn it into a hard error\n      process.env.NODE_ENV !== \"production\" ? warning(false, 'usePreloadedQuery(): usePreloadedQuery was passed a preloaded query ' + 'that was created with a different environment than the one that is currently ' + 'in context. In the future, this will become a hard error.') : void 0;\n      fetchObservable = fallbackFetchObservable;\n    } else {\n      // if (source == null)\n      // If the source observable does not exist, we need to\n      // fall back and re-execute and de-dupe the query (at render time).\n      fetchObservable = fallbackFetchObservable;\n    }\n\n    useLazyLoadQueryNodeParams = {\n      componentDisplayName: 'usePreloadedQuery()',\n      fetchObservable: fetchObservable,\n      fetchKey: fetchKey,\n      fetchPolicy: fetchPolicy,\n      query: operation,\n      renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy\n    };\n  }\n\n  var data = useLazyLoadQueryNode(useLazyLoadQueryNodeParams);\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useDebugValue({\n      query: preloadedQuery.name,\n      variables: preloadedQuery.variables,\n      data: data,\n      fetchKey: fetchKey,\n      fetchPolicy: fetchPolicy,\n      renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy\n    });\n  }\n\n  return data;\n}\n\nmodule.exports = usePreloadedQuery;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _require = require('react'),\n    useEffect = _require.useEffect,\n    useRef = _require.useRef;\n\nfunction useIsMountedRef() {\n  var isMountedRef = useRef(true);\n  useEffect(function () {\n    isMountedRef.current = true;\n    return function () {\n      isMountedRef.current = false;\n    };\n  }, []);\n  return isMountedRef;\n}\n\nmodule.exports = useIsMountedRef;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @emails oncall+relay\n */\n'use strict';\n\nvar _require = require('./loadQuery'),\n    loadQuery = _require.loadQuery;\n\nfunction loadEntryPoint(environmentProvider, entryPoint, entryPointParams) {\n  // Start loading the code for the entrypoint\n  var loadingPromise = null;\n\n  if (entryPoint.root.getModuleIfRequired() == null) {\n    loadingPromise = entryPoint.root.load();\n  }\n\n  var preloadProps = entryPoint.getPreloadProps(entryPointParams);\n  var queries = preloadProps.queries,\n      entryPoints = preloadProps.entryPoints,\n      extraProps = preloadProps.extraProps;\n  var preloadedQueries = {};\n  var preloadedEntryPoints = {};\n\n  if (queries != null) {\n    var queriesPropNames = Object.keys(queries);\n    queriesPropNames.forEach(function (queryPropName) {\n      var _queries$queryPropNam = queries[queryPropName],\n          environmentProviderOptions = _queries$queryPropNam.environmentProviderOptions,\n          options = _queries$queryPropNam.options,\n          parameters = _queries$queryPropNam.parameters,\n          variables = _queries$queryPropNam.variables;\n      var environment = environmentProvider.getEnvironment(environmentProviderOptions);\n      preloadedQueries[queryPropName] = loadQuery(environment, parameters, variables, {\n        fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,\n        networkCacheConfig: options === null || options === void 0 ? void 0 : options.networkCacheConfig,\n        __nameForWarning: 'loadEntryPoint'\n      }, environmentProviderOptions);\n    });\n  }\n\n  if (entryPoints != null) {\n    var entryPointPropNames = Object.keys(entryPoints);\n    entryPointPropNames.forEach(function (entryPointPropName) {\n      var entryPointDescription = entryPoints[entryPointPropName];\n\n      if (entryPointDescription == null) {\n        return;\n      }\n\n      var nestedEntryPoint = entryPointDescription.entryPoint,\n          nestedParams = entryPointDescription.entryPointParams;\n      preloadedEntryPoints[entryPointPropName] = loadEntryPoint(environmentProvider, nestedEntryPoint, nestedParams);\n    });\n  }\n\n  var isDisposed = false;\n  return {\n    dispose: function dispose() {\n      if (isDisposed) {\n        return;\n      }\n\n      if (preloadedQueries != null) {\n        Object.values(preloadedQueries).forEach(function (_ref) {\n          var innerDispose = _ref.dispose;\n          innerDispose();\n        });\n      }\n\n      if (preloadedEntryPoints != null) {\n        Object.values(preloadedEntryPoints).forEach(function (_ref2) {\n          var innerDispose = _ref2.dispose;\n          innerDispose();\n        });\n      }\n\n      isDisposed = true;\n    },\n    entryPoints: preloadedEntryPoints,\n    extraProps: extraProps !== null && extraProps !== void 0 ? extraProps : null,\n    getComponent: function getComponent() {\n      var component = entryPoint.root.getModuleIfRequired();\n\n      if (component == null) {\n        var _loadingPromise;\n\n        loadingPromise = (_loadingPromise = loadingPromise) !== null && _loadingPromise !== void 0 ? _loadingPromise : entryPoint.root.load();\n        throw loadingPromise;\n      } // $FlowFixMe[incompatible-cast] - trust me Flow, its entryPoint component\n\n\n      return component;\n    },\n\n    // $FlowFixMe[unsafe-getters-setters] - this has no side effects\n    get isDisposed() {\n      return isDisposed;\n    },\n\n    queries: preloadedQueries,\n    rootModuleID: entryPoint.root.getModuleId()\n  };\n}\n\nmodule.exports = loadEntryPoint;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar React = require('react');\n\nvar _require = require('relay-runtime'),\n    createRelayContext = _require.__internal.createRelayContext;\n\nmodule.exports = createRelayContext(React);","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar ProfilerContext = require('./ProfilerContext');\n\nvar React = require('react');\n\nvar useFetchTrackingRef = require('./useFetchTrackingRef');\n\nvar useFragmentNode = require('./useFragmentNode');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar _require = require('./QueryResource'),\n    getQueryResourceForEnvironment = _require.getQueryResourceForEnvironment,\n    getQueryCacheIdentifier = _require.getQueryCacheIdentifier;\n\nvar useContext = React.useContext,\n    useEffect = React.useEffect,\n    useState = React.useState,\n    useRef = React.useRef;\n\nfunction useLazyLoadQueryNode(_ref) {\n  var query = _ref.query,\n      componentDisplayName = _ref.componentDisplayName,\n      fetchObservable = _ref.fetchObservable,\n      fetchPolicy = _ref.fetchPolicy,\n      fetchKey = _ref.fetchKey,\n      renderPolicy = _ref.renderPolicy;\n  var environment = useRelayEnvironment();\n  var profilerContext = useContext(ProfilerContext);\n  var QueryResource = getQueryResourceForEnvironment(environment);\n\n  var _useState = useState(0),\n      forceUpdateKey = _useState[0],\n      forceUpdate = _useState[1];\n\n  var _useFetchTrackingRef = useFetchTrackingRef(),\n      startFetch = _useFetchTrackingRef.startFetch,\n      completeFetch = _useFetchTrackingRef.completeFetch;\n\n  var cacheBreaker = \"\".concat(forceUpdateKey, \"-\").concat(fetchKey !== null && fetchKey !== void 0 ? fetchKey : '');\n  var cacheIdentifier = getQueryCacheIdentifier(environment, query, fetchPolicy, renderPolicy, cacheBreaker);\n  var preparedQueryResult = profilerContext.wrapPrepareQueryResource(function () {\n    return QueryResource.prepareWithIdentifier(cacheIdentifier, query, fetchObservable, fetchPolicy, renderPolicy, {\n      start: startFetch,\n      complete: completeFetch,\n      error: completeFetch\n    }, profilerContext);\n  });\n  var maybeHiddenOrFastRefresh = useRef(false);\n  useEffect(function () {\n    return function () {\n      // Attempt to detect if the component was\n      // hidden (by Offscreen API), or fast refresh occured;\n      // Only in these situations would the effect cleanup\n      // for \"unmounting\" run multiple times, so if\n      // we are ever able to read this ref with a value\n      // of true, it means that one of these cases\n      // has happened.\n      maybeHiddenOrFastRefresh.current = true;\n    };\n  }, []);\n  useEffect(function () {\n    if (maybeHiddenOrFastRefresh.current === true) {\n      // This block only runs if the component has previously \"unmounted\"\n      // due to it being hidden by the Offscreen API, or during fast refresh.\n      // At this point, the current cached resource will have been disposed\n      // by the previous cleanup, so instead of attempting to\n      // do our regular commit setup, which would incorrectly attempt to\n      // retain a cached query resource that was disposed, we need to force\n      // a re-render so that the cache entry for this query is re-intiliazed and\n      // and re-evaluated (and potentially cause a refetch).\n      maybeHiddenOrFastRefresh.current = false;\n      forceUpdate(function (n) {\n        return n + 1;\n      });\n      return;\n    }\n\n    var disposable = QueryResource.retain(preparedQueryResult, profilerContext);\n    return function () {\n      disposable.dispose();\n    }; // NOTE: We disable react-hooks-deps warning because the `environment`\n    // and `cacheIdentifier` identities are capturing all information about whether\n    // the effect should be re-executed and the query re-retained.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [environment, cacheIdentifier]);\n  var fragmentNode = preparedQueryResult.fragmentNode,\n      fragmentRef = preparedQueryResult.fragmentRef;\n\n  var _useFragmentNode = useFragmentNode(fragmentNode, fragmentRef, componentDisplayName),\n      data = _useFragmentNode.data;\n\n  return data;\n}\n\nmodule.exports = useLazyLoadQueryNode;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar _objectWithoutPropertiesLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectWithoutPropertiesLoose\"));\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inheritsLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inheritsLoose\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar _objectSpread3 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar React = require('react');\n\nvar ReactRelayContext = require('./ReactRelayContext');\n\nvar ReactRelayQueryFetcher = require('./ReactRelayQueryFetcher');\n\nvar areEqual = require(\"fbjs/lib/areEqual\");\n\nvar buildReactRelayContainer = require('./buildReactRelayContainer');\n\nvar getRootVariablesForFragments = require('./getRootVariablesForFragments');\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('./ReactRelayContainerUtils'),\n    getComponentName = _require.getComponentName,\n    getContainerName = _require.getContainerName;\n\nvar _require2 = require('./RelayContext'),\n    assertRelayContext = _require2.assertRelayContext;\n\nvar _require3 = require('relay-runtime'),\n    ConnectionInterface = _require3.ConnectionInterface,\n    Observable = _require3.Observable,\n    createFragmentSpecResolver = _require3.createFragmentSpecResolver,\n    createOperationDescriptor = _require3.createOperationDescriptor,\n    getDataIDsFromObject = _require3.getDataIDsFromObject,\n    getRequest = _require3.getRequest,\n    getSelector = _require3.getSelector,\n    getVariablesFromObject = _require3.getVariablesFromObject,\n    isScalarAndEqual = _require3.isScalarAndEqual;\n\nvar FORWARD = 'forward';\n\n/**\n * Extends the functionality of RelayFragmentContainer by providing a mechanism\n * to load more data from a connection.\n *\n * # Configuring a PaginationContainer\n *\n * PaginationContainer accepts the standard FragmentContainer arguments and an\n * additional `connectionConfig` argument:\n *\n * - `Component`: the component to be wrapped/rendered.\n * - `fragments`: an object whose values are `graphql` fragments. The object\n *   keys determine the prop names by which fragment data is available.\n * - `connectionConfig`: an object that determines how to load more connection\n *   data. Details below.\n *\n * # Loading More Data\n *\n * Use `props.relay.hasMore()` to determine if there are more items to load.\n *\n * ```\n * hasMore(): boolean\n * ```\n *\n * Use `props.relay.isLoading()` to determine if a previous call to `loadMore()`\n * is still pending. This is convenient for avoiding duplicate load calls.\n *\n * ```\n * isLoading(): boolean\n * ```\n *\n * Use `props.relay.loadMore()` to load more items. This will return null if\n * there are no more items to fetch, otherwise it will fetch more items and\n * return a Disposable that can be used to cancel the fetch.\n *\n * `pageSize` should be the number of *additional* items to fetch (not the\n * total).\n *\n * ```\n * loadMore(pageSize: number, callback: ?(error: ?Error) => void): ?Disposable\n * ```\n *\n * A complete example:\n *\n * ```\n * class Foo extends React.Component {\n *   ...\n *   _onEndReached() {\n *     if (!this.props.relay.hasMore() || this.props.relay.isLoading()) {\n *       return;\n *     }\n *     this.props.relay.loadMore(10);\n *   }\n *   ...\n * }\n * ```\n *\n * # Connection Config\n *\n * Here's an example, followed by details of each config property:\n *\n * ```\n * ReactRelayPaginationContainer.createContainer(\n *   Component,\n *   {\n *     user: graphql`fragment FriendsFragment on User {\n *       friends(after: $afterCursor first: $count) @connection {\n *         edges { ... }\n *         pageInfo {\n *           startCursor\n *           endCursor\n *           hasNextPage\n *           hasPreviousPage\n *         }\n *       }\n *     }`,\n *   },\n *   {\n *     direction: 'forward',\n *     getConnectionFromProps(props) {\n *       return props.user && props.user.friends;\n *     },\n *     getFragmentVariables(vars, totalCount) {\n *       // The component presumably wants *all* edges, not just those after\n *       // the cursor, so notice that we don't set $afterCursor here.\n *       return {\n *         ...vars,\n *         count: totalCount,\n *       };\n *     },\n *     getVariables(props, {count, cursor}, fragmentVariables) {\n *       return {\n *         id: props.user.id,\n *         afterCursor: cursor,\n *         count,\n *       },\n *     },\n *     query: graphql`\n *       query FriendsQuery($id: ID!, $afterCursor: ID, $count: Int!) {\n *         node(id: $id) {\n *           ...FriendsFragment\n *         }\n *       }\n *     `,\n *   }\n * );\n * ```\n *\n * ## Config Properties\n *\n * - `direction`: Either \"forward\" to indicate forward pagination using\n *   after/first, or \"backward\" to indicate backward pagination using\n *   before/last.\n * - `getConnectionFromProps(props)`: PaginationContainer doesn't magically know\n *   which connection data you mean to fetch more of (a container might fetch\n *   multiple connections, but can only paginate one of them). This function is\n *   given the fragment props only (not full props), and should return the\n *   connection data. See the above example that returns the friends data via\n *   `props.user.friends`.\n * - `getFragmentVariables(previousVars, totalCount)`: Given the previous variables\n *   and the new total number of items, get the variables to use when reading\n *   your fragments. Typically this means setting whatever your local \"count\"\n *   variable is to the value of `totalCount`. See the example.\n * - `getVariables(props, {count, cursor})`: Get the variables to use when\n *   fetching the pagination `query`. You may determine the root object id from\n *   props (see the example that uses `props.user.id`) and may also set whatever\n *   variables you use for the after/first/before/last calls based on the count\n *   and cursor.\n * - `query`: A query to use when fetching more connection data. This should\n *   typically reference one of the container's fragment (as in the example)\n *   to ensure that all the necessary fields for sub-components are fetched.\n */\nfunction createGetConnectionFromProps(metadata) {\n  var path = metadata.path;\n  !path ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: Unable to synthesize a ' + 'getConnectionFromProps function.') : invariant(false) : void 0;\n  return function (props) {\n    var data = props[metadata.fragmentName];\n\n    for (var i = 0; i < path.length; i++) {\n      if (!data || typeof data !== 'object') {\n        return null;\n      }\n\n      data = data[path[i]];\n    }\n\n    return data;\n  };\n}\n\nfunction createGetFragmentVariables(metadata) {\n  var countVariable = metadata.count;\n  !countVariable ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: Unable to synthesize a ' + 'getFragmentVariables function.') : invariant(false) : void 0; // $FlowFixMe[cannot-spread-interface]\n\n  return function (prevVars, totalCount) {\n    return (0, _objectSpread3[\"default\"])((0, _objectSpread3[\"default\"])({}, prevVars), {}, (0, _defineProperty2[\"default\"])({}, countVariable, totalCount));\n  };\n}\n\nfunction findConnectionMetadata(fragments) {\n  var foundConnectionMetadata = null;\n  var isRelayModern = false;\n\n  for (var fragmentName in fragments) {\n    var fragment = fragments[fragmentName];\n    var connectionMetadata = fragment.metadata && fragment.metadata.connection; // HACK: metadata is always set to `undefined` in classic. In modern, even\n    // if empty, it is set to null (never undefined). We use that knowlege to\n    // check if we're dealing with classic or modern\n\n    if (fragment.metadata !== undefined) {\n      isRelayModern = true;\n    }\n\n    if (connectionMetadata) {\n      !(connectionMetadata.length === 1) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: Only a single @connection is ' + 'supported, `%s` has %s.', fragmentName, connectionMetadata.length) : invariant(false) : void 0;\n      !!foundConnectionMetadata ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: Only a single fragment with ' + '@connection is supported.') : invariant(false) : void 0;\n      foundConnectionMetadata = (0, _objectSpread3[\"default\"])((0, _objectSpread3[\"default\"])({}, connectionMetadata[0]), {}, {\n        fragmentName: fragmentName\n      });\n    }\n  }\n\n  !(!isRelayModern || foundConnectionMetadata !== null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: A @connection directive must be present.') : invariant(false) : void 0;\n  return foundConnectionMetadata || {};\n}\n\nfunction toObserver(observerOrCallback) {\n  return typeof observerOrCallback === 'function' ? {\n    error: observerOrCallback,\n    complete: observerOrCallback,\n    unsubscribe: function unsubscribe(subscription) {\n      typeof observerOrCallback === 'function' && observerOrCallback();\n    }\n  } : observerOrCallback || {};\n}\n\nfunction createContainerWithFragments(Component, fragments, connectionConfig) {\n  var _class, _temp;\n\n  var componentName = getComponentName(Component);\n  var containerName = getContainerName(Component);\n  var metadata = findConnectionMetadata(fragments);\n  var getConnectionFromProps = connectionConfig.getConnectionFromProps || createGetConnectionFromProps(metadata);\n  var direction = connectionConfig.direction || metadata.direction;\n  !direction ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: Unable to infer direction of the ' + 'connection, possibly because both first and last are provided.') : invariant(false) : void 0;\n  var getFragmentVariables = connectionConfig.getFragmentVariables || createGetFragmentVariables(metadata);\n  return _temp = _class = /*#__PURE__*/function (_React$Component) {\n    (0, _inheritsLoose2[\"default\"])(_class, _React$Component);\n\n    function _class(props) {\n      var _props$__rootIsQueryR, _this;\n\n      _this = _React$Component.call(this, props) || this;\n      (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_handleFragmentDataUpdate\", function () {\n        _this.setState({\n          data: _this._resolver.resolve()\n        });\n      });\n      (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_hasMore\", function () {\n        var connectionData = _this._getConnectionData();\n\n        return !!(connectionData && connectionData.hasMore && connectionData.cursor);\n      });\n      (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_isLoading\", function () {\n        return !!_this._refetchSubscription;\n      });\n      (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_refetchConnection\", function (totalCount, observerOrCallback, refetchVariables) {\n        if (!_this._canFetchPage('refetchConnection')) {\n          return {\n            dispose: function dispose() {}\n          };\n        }\n\n        _this._refetchVariables = refetchVariables;\n        var paginatingVariables = {\n          count: totalCount,\n          cursor: null,\n          totalCount: totalCount\n        };\n\n        var fetch = _this._fetchPage(paginatingVariables, toObserver(observerOrCallback), {\n          force: true\n        });\n\n        return {\n          dispose: fetch.unsubscribe\n        };\n      });\n      (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_loadMore\", function (pageSize, observerOrCallback, options) {\n        if (!_this._canFetchPage('loadMore')) {\n          return {\n            dispose: function dispose() {}\n          };\n        }\n\n        var observer = toObserver(observerOrCallback);\n\n        var connectionData = _this._getConnectionData();\n\n        if (!connectionData) {\n          Observable.create(function (sink) {\n            return sink.complete();\n          }).subscribe(observer);\n          return null;\n        }\n\n        var totalCount = connectionData.edgeCount + pageSize;\n\n        if (options && options.force) {\n          return _this._refetchConnection(totalCount, observerOrCallback);\n        }\n\n        var _ConnectionInterface$ = ConnectionInterface.get(),\n            END_CURSOR = _ConnectionInterface$.END_CURSOR,\n            START_CURSOR = _ConnectionInterface$.START_CURSOR;\n\n        var cursor = connectionData.cursor;\n        process.env.NODE_ENV !== \"production\" ? warning(cursor != null && cursor !== '', 'ReactRelayPaginationContainer: Cannot `loadMore` without valid `%s` (got `%s`)', direction === FORWARD ? END_CURSOR : START_CURSOR, cursor) : void 0;\n        var paginatingVariables = {\n          count: pageSize,\n          cursor: cursor,\n          totalCount: totalCount\n        };\n\n        var fetch = _this._fetchPage(paginatingVariables, observer, options);\n\n        return {\n          dispose: fetch.unsubscribe\n        };\n      });\n      var relayContext = assertRelayContext(props.__relayContext);\n      var rootIsQueryRenderer = (_props$__rootIsQueryR = props.__rootIsQueryRenderer) !== null && _props$__rootIsQueryR !== void 0 ? _props$__rootIsQueryR : false;\n      _this._isARequestInFlight = false;\n      _this._refetchSubscription = null;\n      _this._refetchVariables = null;\n      _this._resolver = createFragmentSpecResolver(relayContext, containerName, fragments, props, rootIsQueryRenderer, _this._handleFragmentDataUpdate);\n      _this.state = {\n        data: _this._resolver.resolve(),\n        prevContext: relayContext,\n        contextForChildren: relayContext,\n        relayProp: _this._buildRelayProp(relayContext)\n      };\n      _this._isUnmounted = false;\n      _this._hasFetched = false;\n      return _this;\n    }\n\n    var _proto = _class.prototype;\n\n    _proto.componentDidMount = function componentDidMount() {\n      this._isUnmounted = false;\n    }\n    /**\n     * When new props are received, read data for the new props and subscribe\n     * for updates. Props may be the same in which case previous data and\n     * subscriptions can be reused.\n     */\n    ;\n\n    _proto.UNSAFE_componentWillReceiveProps = function UNSAFE_componentWillReceiveProps(nextProps) {\n      var _nextProps$__rootIsQu;\n\n      var relayContext = assertRelayContext(nextProps.__relayContext);\n      var rootIsQueryRenderer = (_nextProps$__rootIsQu = nextProps.__rootIsQueryRenderer) !== null && _nextProps$__rootIsQu !== void 0 ? _nextProps$__rootIsQu : false;\n      var prevIDs = getDataIDsFromObject(fragments, this.props);\n      var nextIDs = getDataIDsFromObject(fragments, nextProps);\n      var prevRootVariables = getRootVariablesForFragments(fragments, this.props);\n      var nextRootVariables = getRootVariablesForFragments(fragments, nextProps); // If the environment has changed or props point to new records then\n      // previously fetched data and any pending fetches no longer apply:\n      // - Existing references are on the old environment.\n      // - Existing references are based on old variables.\n      // - Pending fetches are for the previous records.\n\n      if (relayContext.environment !== this.state.prevContext.environment || !areEqual(prevRootVariables, nextRootVariables) || !areEqual(prevIDs, nextIDs)) {\n        this._cleanup(); // Child containers rely on context.relay being mutated (for gDSFP).\n\n\n        this._resolver = createFragmentSpecResolver(relayContext, containerName, fragments, nextProps, rootIsQueryRenderer, this._handleFragmentDataUpdate);\n        this.setState({\n          prevContext: relayContext,\n          contextForChildren: relayContext,\n          relayProp: this._buildRelayProp(relayContext)\n        });\n      } else if (!this._hasFetched) {\n        this._resolver.setProps(nextProps);\n      }\n\n      var data = this._resolver.resolve();\n\n      if (data !== this.state.data) {\n        this.setState({\n          data: data\n        });\n      }\n    };\n\n    _proto.componentWillUnmount = function componentWillUnmount() {\n      this._isUnmounted = true;\n\n      this._cleanup();\n    };\n\n    _proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {\n      // Short-circuit if any Relay-related data has changed\n      if (nextState.data !== this.state.data || nextState.relayProp !== this.state.relayProp) {\n        return true;\n      } // Otherwise, for convenience short-circuit if all non-Relay props\n      // are scalar and equal\n\n\n      var keys = Object.keys(nextProps);\n\n      for (var ii = 0; ii < keys.length; ii++) {\n        var _key = keys[ii];\n\n        if (_key === '__relayContext') {\n          if (nextState.prevContext.environment !== this.state.prevContext.environment) {\n            return true;\n          }\n        } else {\n          if (!fragments.hasOwnProperty(_key) && !isScalarAndEqual(nextProps[_key], this.props[_key])) {\n            return true;\n          }\n        }\n      }\n\n      return false;\n    };\n\n    _proto._buildRelayProp = function _buildRelayProp(relayContext) {\n      return {\n        hasMore: this._hasMore,\n        isLoading: this._isLoading,\n        loadMore: this._loadMore,\n        refetchConnection: this._refetchConnection,\n        environment: relayContext.environment\n      };\n    }\n    /**\n     * Render new data for the existing props/context.\n     */\n    ;\n\n    _proto._getConnectionData = function _getConnectionData() {\n      // Extract connection data and verify there are more edges to fetch\n      var _this$props = this.props,\n          _ = _this$props.componentRef,\n          restProps = (0, _objectWithoutPropertiesLoose2[\"default\"])(_this$props, [\"componentRef\"]);\n      var props = (0, _objectSpread3[\"default\"])((0, _objectSpread3[\"default\"])({}, restProps), this.state.data);\n      var connectionData = getConnectionFromProps(props);\n\n      if (connectionData == null) {\n        return null;\n      }\n\n      var _ConnectionInterface$2 = ConnectionInterface.get(),\n          EDGES = _ConnectionInterface$2.EDGES,\n          PAGE_INFO = _ConnectionInterface$2.PAGE_INFO,\n          HAS_NEXT_PAGE = _ConnectionInterface$2.HAS_NEXT_PAGE,\n          HAS_PREV_PAGE = _ConnectionInterface$2.HAS_PREV_PAGE,\n          END_CURSOR = _ConnectionInterface$2.END_CURSOR,\n          START_CURSOR = _ConnectionInterface$2.START_CURSOR;\n\n      !(typeof connectionData === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: Expected `getConnectionFromProps()` in `%s`' + 'to return `null` or a plain object with %s and %s properties, got `%s`.', componentName, EDGES, PAGE_INFO, connectionData) : invariant(false) : void 0;\n      var edges = connectionData[EDGES];\n      var pageInfo = connectionData[PAGE_INFO];\n\n      if (edges == null || pageInfo == null) {\n        return null;\n      }\n\n      !Array.isArray(edges) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: Expected `getConnectionFromProps()` in `%s`' + 'to return an object with %s: Array, got `%s`.', componentName, EDGES, edges) : invariant(false) : void 0;\n      !(typeof pageInfo === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: Expected `getConnectionFromProps()` in `%s`' + 'to return an object with %s: Object, got `%s`.', componentName, PAGE_INFO, pageInfo) : invariant(false) : void 0;\n      var hasMore = direction === FORWARD ? pageInfo[HAS_NEXT_PAGE] : pageInfo[HAS_PREV_PAGE];\n      var cursor = direction === FORWARD ? pageInfo[END_CURSOR] : pageInfo[START_CURSOR];\n\n      if (typeof hasMore !== 'boolean' || edges.length !== 0 && typeof cursor === 'undefined') {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'ReactRelayPaginationContainer: Cannot paginate without %s fields in `%s`. ' + 'Be sure to fetch %s (got `%s`) and %s (got `%s`).', PAGE_INFO, componentName, direction === FORWARD ? HAS_NEXT_PAGE : HAS_PREV_PAGE, hasMore, direction === FORWARD ? END_CURSOR : START_CURSOR, cursor) : void 0;\n        return null;\n      }\n\n      return {\n        cursor: cursor,\n        edgeCount: edges.length,\n        hasMore: hasMore\n      };\n    };\n\n    _proto._getQueryFetcher = function _getQueryFetcher() {\n      if (!this._queryFetcher) {\n        this._queryFetcher = new ReactRelayQueryFetcher();\n      }\n\n      return this._queryFetcher;\n    };\n\n    _proto._canFetchPage = function _canFetchPage(method) {\n      if (this._isUnmounted) {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'ReactRelayPaginationContainer: Unexpected call of `%s` ' + 'on unmounted container `%s`. It looks like some instances ' + 'of your container still trying to fetch data but they already ' + 'unmounted. Please make sure you clear all timers, intervals, async ' + 'calls, etc that may trigger `%s` call.', method, containerName, method) : void 0;\n        return false;\n      }\n\n      return true;\n    };\n\n    _proto._fetchPage = function _fetchPage(paginatingVariables, observer, options) {\n      var _this2 = this;\n\n      var _assertRelayContext = assertRelayContext(this.props.__relayContext),\n          environment = _assertRelayContext.environment;\n\n      var _this$props2 = this.props,\n          _ = _this$props2.componentRef,\n          __relayContext = _this$props2.__relayContext,\n          __rootIsQueryRenderer = _this$props2.__rootIsQueryRenderer,\n          restProps = (0, _objectWithoutPropertiesLoose2[\"default\"])(_this$props2, [\"componentRef\", \"__relayContext\", \"__rootIsQueryRenderer\"]);\n      var props = (0, _objectSpread3[\"default\"])((0, _objectSpread3[\"default\"])({}, restProps), this.state.data);\n      var fragmentVariables;\n      var rootVariables = getRootVariablesForFragments(fragments, restProps); // $FlowFixMe[cannot-spread-interface]\n\n      fragmentVariables = getVariablesFromObject(fragments, restProps); // $FlowFixMe[cannot-spread-interface]\n\n      fragmentVariables = (0, _objectSpread3[\"default\"])((0, _objectSpread3[\"default\"])((0, _objectSpread3[\"default\"])({}, rootVariables), fragmentVariables), this._refetchVariables);\n      var fetchVariables = connectionConfig.getVariables(props, {\n        count: paginatingVariables.count,\n        cursor: paginatingVariables.cursor\n      }, fragmentVariables);\n      !(typeof fetchVariables === 'object' && fetchVariables !== null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayPaginationContainer: Expected `getVariables()` to ' + 'return an object, got `%s` in `%s`.', fetchVariables, componentName) : invariant(false) : void 0; // $FlowFixMe[cannot-spread-interface]\n\n      fetchVariables = (0, _objectSpread3[\"default\"])((0, _objectSpread3[\"default\"])({}, fetchVariables), this._refetchVariables);\n      fragmentVariables = (0, _objectSpread3[\"default\"])((0, _objectSpread3[\"default\"])({}, fetchVariables), fragmentVariables);\n      var cacheConfig = options ? {\n        force: !!options.force\n      } : undefined;\n\n      if (cacheConfig != null && (options === null || options === void 0 ? void 0 : options.metadata) != null) {\n        cacheConfig.metadata = options === null || options === void 0 ? void 0 : options.metadata;\n      }\n\n      var request = getRequest(connectionConfig.query);\n      var operation = createOperationDescriptor(request, fetchVariables, cacheConfig);\n      var refetchSubscription = null;\n\n      if (this._refetchSubscription) {\n        this._refetchSubscription.unsubscribe();\n      }\n\n      this._hasFetched = true;\n\n      var onNext = function onNext(payload, complete) {\n        var prevData = _this2._resolver.resolve();\n\n        _this2._resolver.setVariables(getFragmentVariables(fragmentVariables, paginatingVariables.totalCount), operation.request.node);\n\n        var nextData = _this2._resolver.resolve(); // Workaround slightly different handling for connection in different\n        // core implementations:\n        // - Classic core requires the count to be explicitly incremented\n        // - Modern core automatically appends new items, updating the count\n        //   isn't required to see new data.\n        //\n        // `setState` is only required if changing the variables would change the\n        // resolved data.\n        // TODO #14894725: remove PaginationContainer equal check\n\n\n        if (!areEqual(prevData, nextData)) {\n          _this2.setState({\n            data: nextData,\n            contextForChildren: {\n              environment: _this2.props.__relayContext.environment\n            }\n          }, complete);\n        } else {\n          complete();\n        }\n      };\n\n      var cleanup = function cleanup() {\n        if (_this2._refetchSubscription === refetchSubscription) {\n          _this2._refetchSubscription = null;\n          _this2._isARequestInFlight = false;\n        }\n      };\n\n      this._isARequestInFlight = true;\n      refetchSubscription = this._getQueryFetcher().execute({\n        environment: environment,\n        operation: operation,\n        preservePreviousReferences: true\n      }).mergeMap(function (payload) {\n        return Observable.create(function (sink) {\n          onNext(payload, function () {\n            sink.next(); // pass void to public observer's `next`\n\n            sink.complete();\n          });\n        });\n      }) // use do instead of finally so that observer's `complete` fires after cleanup\n      [\"do\"]({\n        error: cleanup,\n        complete: cleanup,\n        unsubscribe: cleanup\n      }).subscribe(observer || {});\n      this._refetchSubscription = this._isARequestInFlight ? refetchSubscription : null;\n      return refetchSubscription;\n    };\n\n    _proto._cleanup = function _cleanup() {\n      this._resolver.dispose();\n\n      this._refetchVariables = null;\n      this._hasFetched = false;\n\n      if (this._refetchSubscription) {\n        this._refetchSubscription.unsubscribe();\n\n        this._refetchSubscription = null;\n        this._isARequestInFlight = false;\n      }\n\n      if (this._queryFetcher) {\n        this._queryFetcher.dispose();\n      }\n    };\n\n    _proto.render = function render() {\n      var _this$props3 = this.props,\n          componentRef = _this$props3.componentRef,\n          __relayContext = _this$props3.__relayContext,\n          __rootIsQueryRenderer = _this$props3.__rootIsQueryRenderer,\n          props = (0, _objectWithoutPropertiesLoose2[\"default\"])(_this$props3, [\"componentRef\", \"__relayContext\", \"__rootIsQueryRenderer\"]);\n      return /*#__PURE__*/React.createElement(ReactRelayContext.Provider, {\n        value: this.state.contextForChildren\n      }, /*#__PURE__*/React.createElement(Component, (0, _extends2[\"default\"])({}, props, this.state.data, {\n        ref: componentRef,\n        relay: this.state.relayProp\n      })));\n    };\n\n    return _class;\n  }(React.Component), (0, _defineProperty2[\"default\"])(_class, \"displayName\", containerName), _temp;\n}\n/**\n * Wrap the basic `createContainer()` function with logic to adapt to the\n * `context.relay.environment` in which it is rendered. Specifically, the\n * extraction of the environment-specific version of fragments in the\n * `fragmentSpec` is memoized once per environment, rather than once per\n * instance of the container constructed/rendered.\n */\n\n\nfunction createContainer(Component, fragmentSpec, connectionConfig) {\n  // $FlowFixMe[incompatible-return]\n  return buildReactRelayContainer(Component, fragmentSpec, function (ComponentClass, fragments) {\n    return createContainerWithFragments(ComponentClass, fragments, connectionConfig);\n  });\n}\n\nmodule.exports = {\n  createContainer: createContainer\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar useLazyLoadQueryNode = require('./useLazyLoadQueryNode');\n\nvar useMemoOperationDescriptor = require('./useMemoOperationDescriptor');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar _require = require('./loadQuery'),\n    useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;\n\nvar _require2 = require('relay-runtime'),\n    fetchQuery = _require2.__internal.fetchQuery;\n\nfunction useLazyLoadQuery(gqlQuery, variables, options) {\n  // We need to use this hook in order to be able to track if\n  // loadQuery was called during render\n  useTrackLoadQueryInRender();\n  var environment = useRelayEnvironment();\n  var query = useMemoOperationDescriptor(gqlQuery, variables, options && options.networkCacheConfig ? options.networkCacheConfig : {\n    force: true\n  });\n  var data = useLazyLoadQueryNode({\n    componentDisplayName: 'useLazyLoadQuery()',\n    fetchKey: options === null || options === void 0 ? void 0 : options.fetchKey,\n    fetchObservable: fetchQuery(environment, query),\n    fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,\n    query: query,\n    renderPolicy: options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy\n  });\n  return data;\n}\n\nmodule.exports = useLazyLoadQuery;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar invariant = require('invariant');\n\n/**\n * Fail fast if the user supplies invalid fragments as input.\n */\nfunction assertFragmentMap(componentName, fragmentSpec) {\n  !(fragmentSpec && typeof fragmentSpec === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Could not create Relay Container for `%s`. ' + 'Expected a set of GraphQL fragments, got `%s` instead.', componentName, fragmentSpec) : invariant(false) : void 0;\n\n  for (var key in fragmentSpec) {\n    if (fragmentSpec.hasOwnProperty(key)) {\n      var fragment = fragmentSpec[key];\n      !(fragment && (typeof fragment === 'object' || typeof fragment === 'function')) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Could not create Relay Container for `%s`. ' + 'The value of fragment `%s` was expected to be a fragment, got `%s` instead.', componentName, key, fragment) : invariant(false) : void 0;\n    }\n  }\n}\n\nmodule.exports = assertFragmentMap;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar useRefetchableFragmentNode = require('./useRefetchableFragmentNode');\n\nvar useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');\n\nvar _require = require('react'),\n    useDebugValue = _require.useDebugValue;\n\nvar _require2 = require('relay-runtime'),\n    getFragment = _require2.getFragment;\n\nfunction useRefetchableFragment(fragmentInput, fragmentRef) {\n  var fragmentNode = getFragment(fragmentInput);\n  useStaticFragmentNodeWarning(fragmentNode, 'first argument of useRefetchableFragment()');\n\n  var _useRefetchableFragme = useRefetchableFragmentNode(fragmentNode, fragmentRef, 'useRefetchableFragment()'),\n      fragmentData = _useRefetchableFragme.fragmentData,\n      refetch = _useRefetchableFragme.refetch;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useDebugValue({\n      fragment: fragmentNode.name,\n      data: fragmentData\n    });\n  }\n  /* $FlowExpectedError[prop-missing] : Exposed options is a subset of internal\n   * options */\n\n\n  return [fragmentData, refetch];\n}\n\nmodule.exports = useRefetchableFragment;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _require = require('react'),\n    useCallback = _require.useCallback,\n    useEffect = _require.useEffect,\n    useRef = _require.useRef;\n\n/**\n * This hook returns a mutable React ref that holds the value of whether a\n * fetch request is in flight. The reason this is a mutable ref instead of\n * state is because we don't actually want to trigger an update when this\n * changes, but instead synchronously keep track of whether the network request\n * is in flight, for example in order to bail out of a request if one is\n * already in flight. If this was state, due to the nature of concurrent\n * updates, this value wouldn't be in sync with when the request is actually\n * in flight.\n * The additional functions returned by this Hook can be used to mutate\n * the ref.\n */\nfunction useFetchTrackingRef() {\n  var subscriptionRef = useRef(null);\n  var isFetchingRef = useRef(false);\n  var disposeFetch = useCallback(function () {\n    if (subscriptionRef.current != null) {\n      subscriptionRef.current.unsubscribe();\n      subscriptionRef.current = null;\n    }\n\n    isFetchingRef.current = false;\n  }, []);\n  var startFetch = useCallback(function (subscription) {\n    subscriptionRef.current = subscription;\n    isFetchingRef.current = true;\n  }, []);\n  var completeFetch = useCallback(function () {\n    subscriptionRef.current = null;\n    isFetchingRef.current = false;\n  }, []); // Dipose of ongoing fetch on unmount\n\n  useEffect(function () {\n    return disposeFetch;\n  }, [disposeFetch]);\n  return {\n    isFetchingRef: isFetchingRef,\n    startFetch: startFetch,\n    disposeFetch: disposeFetch,\n    completeFetch: completeFetch\n  };\n}\n\nmodule.exports = useFetchTrackingRef;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar invariant = require('invariant');\n\nvar _require = require('relay-runtime'),\n    createOperationDescriptor = _require.createOperationDescriptor,\n    isRelayModernEnvironment = _require.isRelayModernEnvironment,\n    fetchQuery = _require.__internal.fetchQuery;\n\nvar ReactRelayQueryFetcher = /*#__PURE__*/function () {\n  function ReactRelayQueryFetcher(args) {\n    (0, _defineProperty2[\"default\"])(this, \"_selectionReferences\", []);\n    (0, _defineProperty2[\"default\"])(this, \"_callOnDataChangeWhenSet\", false);\n\n    if (args != null) {\n      this._cacheSelectionReference = args.cacheSelectionReference;\n      this._selectionReferences = args.selectionReferences;\n    }\n  }\n\n  var _proto = ReactRelayQueryFetcher.prototype;\n\n  _proto.getSelectionReferences = function getSelectionReferences() {\n    return {\n      cacheSelectionReference: this._cacheSelectionReference,\n      selectionReferences: this._selectionReferences\n    };\n  };\n\n  _proto.lookupInStore = function lookupInStore(environment, operation, fetchPolicy) {\n    if (fetchPolicy === 'store-and-network' || fetchPolicy === 'store-or-network') {\n      if (environment.check(operation).status === 'available') {\n        this._retainCachedOperation(environment, operation);\n\n        return environment.lookup(operation.fragment);\n      }\n    }\n\n    return null;\n  };\n\n  _proto.execute = function execute(_ref) {\n    var _this = this;\n\n    var environment = _ref.environment,\n        operation = _ref.operation,\n        _ref$preservePrevious = _ref.preservePreviousReferences,\n        preservePreviousReferences = _ref$preservePrevious === void 0 ? false : _ref$preservePrevious;\n    var reference = environment.retain(operation);\n\n    var error = function error() {\n      // We may have partially fulfilled the request, so let the next request\n      // or the unmount dispose of the references.\n      _this._selectionReferences = _this._selectionReferences.concat(reference);\n    };\n\n    var complete = function complete() {\n      if (!preservePreviousReferences) {\n        _this.disposeSelectionReferences();\n      }\n\n      _this._selectionReferences = _this._selectionReferences.concat(reference);\n    };\n\n    var unsubscribe = function unsubscribe() {\n      // Let the next request or the unmount code dispose of the references.\n      // We may have partially fulfilled the request.\n      _this._selectionReferences = _this._selectionReferences.concat(reference);\n    };\n\n    if (!isRelayModernEnvironment(environment)) {\n      return environment.execute({\n        operation: operation\n      })[\"do\"]({\n        error: error,\n        complete: complete,\n        unsubscribe: unsubscribe\n      });\n    }\n\n    return fetchQuery(environment, operation)[\"do\"]({\n      error: error,\n      complete: complete,\n      unsubscribe: unsubscribe\n    });\n  };\n\n  _proto.setOnDataChange = function setOnDataChange(onDataChange) {\n    !this._fetchOptions ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayQueryFetcher: `setOnDataChange` should have been called after having called `fetch`') : invariant(false) : void 0;\n\n    if (typeof onDataChange === 'function') {\n      // Mutate the most recent fetchOptions in place,\n      // So that in-progress requests can access the updated callback.\n      this._fetchOptions.onDataChangeCallbacks = this._fetchOptions.onDataChangeCallbacks || [];\n\n      this._fetchOptions.onDataChangeCallbacks.push(onDataChange);\n\n      if (this._callOnDataChangeWhenSet) {\n        // We don't reset '_callOnDataChangeWhenSet' because another callback may be set\n        if (this._error != null) {\n          onDataChange({\n            error: this._error\n          });\n        } else if (this._snapshot != null) {\n          onDataChange({\n            snapshot: this._snapshot\n          });\n        }\n      }\n    }\n  }\n  /**\n   * `fetch` fetches the data for the given operation.\n   * If a result is immediately available synchronously, it will be synchronously\n   * returned by this function.\n   *\n   * Otherwise, the fetched result will be communicated via the `onDataChange` callback.\n   * `onDataChange` will be called with the first result (**if it wasn't returned synchronously**),\n   * and then subsequently whenever the data changes.\n   */\n  ;\n\n  _proto.fetch = function fetch(fetchOptions, cacheConfigOverride) {\n    var _this2 = this;\n\n    var environment = fetchOptions.environment,\n        operation = fetchOptions.operation,\n        onDataChange = fetchOptions.onDataChange;\n    var fetchHasReturned = false;\n\n    var _error;\n\n    this.disposeRequest();\n    var oldOnDataChangeCallbacks = this._fetchOptions && this._fetchOptions.onDataChangeCallbacks;\n    this._fetchOptions = {\n      environment: environment,\n      onDataChangeCallbacks: oldOnDataChangeCallbacks || [],\n      operation: operation\n    };\n\n    if (onDataChange && this._fetchOptions.onDataChangeCallbacks.indexOf(onDataChange) === -1) {\n      this._fetchOptions.onDataChangeCallbacks.push(onDataChange);\n    }\n\n    var operationOverride = cacheConfigOverride ? createOperationDescriptor(operation.request.node, operation.request.variables, cacheConfigOverride) : operation;\n    var request = this.execute({\n      environment: environment,\n      operation: operationOverride\n    })[\"finally\"](function () {\n      _this2._pendingRequest = null;\n    }).subscribe({\n      next: function next() {\n        // If we received a response,\n        // Make a note that to notify the callback when it's later added.\n        _this2._callOnDataChangeWhenSet = true;\n        _this2._error = null; // Only notify of the first result if `next` is being called **asynchronously**\n        // (i.e. after `fetch` has returned).\n\n        _this2._onQueryDataAvailable({\n          notifyFirstResult: fetchHasReturned\n        });\n      },\n      error: function error(err) {\n        // If we received a response when we didn't have a change callback,\n        // Make a note that to notify the callback when it's later added.\n        _this2._callOnDataChangeWhenSet = true;\n        _this2._error = err;\n        _this2._snapshot = null;\n        var onDataChangeCallbacks = _this2._fetchOptions && _this2._fetchOptions.onDataChangeCallbacks; // Only notify of error if `error` is being called **asynchronously**\n        // (i.e. after `fetch` has returned).\n\n        if (fetchHasReturned) {\n          if (onDataChangeCallbacks) {\n            onDataChangeCallbacks.forEach(function (onDataChange) {\n              onDataChange({\n                error: err\n              });\n            });\n          }\n        } else {\n          _error = err;\n        }\n      }\n    });\n    this._pendingRequest = {\n      dispose: function dispose() {\n        request.unsubscribe();\n      }\n    };\n    fetchHasReturned = true;\n\n    if (_error) {\n      throw _error;\n    }\n\n    return this._snapshot;\n  };\n\n  _proto.retry = function retry(cacheConfigOverride) {\n    !this._fetchOptions ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayQueryFetcher: `retry` should be called after having called `fetch`') : invariant(false) : void 0;\n    return this.fetch({\n      environment: this._fetchOptions.environment,\n      operation: this._fetchOptions.operation,\n      onDataChange: null // If there are onDataChangeCallbacks they will be reused\n\n    }, cacheConfigOverride);\n  };\n\n  _proto.dispose = function dispose() {\n    this.disposeRequest();\n    this.disposeSelectionReferences();\n  };\n\n  _proto.disposeRequest = function disposeRequest() {\n    this._error = null;\n    this._snapshot = null; // order is important, dispose of pendingFetch before selectionReferences\n\n    if (this._pendingRequest) {\n      this._pendingRequest.dispose();\n    }\n\n    if (this._rootSubscription) {\n      this._rootSubscription.dispose();\n\n      this._rootSubscription = null;\n    }\n  };\n\n  _proto._retainCachedOperation = function _retainCachedOperation(environment, operation) {\n    this._disposeCacheSelectionReference();\n\n    this._cacheSelectionReference = environment.retain(operation);\n  };\n\n  _proto._disposeCacheSelectionReference = function _disposeCacheSelectionReference() {\n    this._cacheSelectionReference && this._cacheSelectionReference.dispose();\n    this._cacheSelectionReference = null;\n  };\n\n  _proto.disposeSelectionReferences = function disposeSelectionReferences() {\n    this._disposeCacheSelectionReference();\n\n    this._selectionReferences.forEach(function (r) {\n      return r.dispose();\n    });\n\n    this._selectionReferences = [];\n  };\n\n  _proto._onQueryDataAvailable = function _onQueryDataAvailable(_ref2) {\n    var _this3 = this;\n\n    var notifyFirstResult = _ref2.notifyFirstResult;\n    !this._fetchOptions ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ReactRelayQueryFetcher: `_onQueryDataAvailable` should have been called after having called `fetch`') : invariant(false) : void 0;\n    var _this$_fetchOptions = this._fetchOptions,\n        environment = _this$_fetchOptions.environment,\n        onDataChangeCallbacks = _this$_fetchOptions.onDataChangeCallbacks,\n        operation = _this$_fetchOptions.operation; // `_onQueryDataAvailable` can be called synchronously the first time and can be called\n    // multiple times by network layers that support data subscriptions.\n    // Wait until the first payload to call `onDataChange` and subscribe for data updates.\n\n    if (this._snapshot) {\n      return;\n    }\n\n    this._snapshot = environment.lookup(operation.fragment); // Subscribe to changes in the data of the root fragment\n\n    this._rootSubscription = environment.subscribe(this._snapshot, function (snapshot) {\n      // Read from this._fetchOptions in case onDataChange() was lazily added.\n      if (_this3._fetchOptions != null) {\n        var maybeNewOnDataChangeCallbacks = _this3._fetchOptions.onDataChangeCallbacks;\n\n        if (Array.isArray(maybeNewOnDataChangeCallbacks)) {\n          maybeNewOnDataChangeCallbacks.forEach(function (onDataChange) {\n            return onDataChange({\n              snapshot: snapshot\n            });\n          });\n        }\n      }\n    });\n\n    if (this._snapshot && notifyFirstResult && Array.isArray(onDataChangeCallbacks)) {\n      var snapshot = this._snapshot;\n      onDataChangeCallbacks.forEach(function (onDataChange) {\n        return onDataChange({\n          snapshot: snapshot\n        });\n      });\n    }\n  };\n\n  return ReactRelayQueryFetcher;\n}();\n\nmodule.exports = ReactRelayQueryFetcher;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @emails oncall+relay\n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar invariant = require('invariant');\n\n/**\n * JS maps (both plain objects and Map) maintain key insertion\n * order, which means there is an easy way to simulate LRU behavior\n * that should also perform quite well:\n *\n * To insert a new value, first delete the key from the inner _map,\n * then _map.set(k, v). By deleting and reinserting, you ensure that the\n * map sees the key as the last inserted key.\n *\n * Get does the same: if the key is present, delete and reinsert it.\n */\nvar LRUCache = /*#__PURE__*/function () {\n  function LRUCache(capacity) {\n    this._capacity = capacity;\n    !(this._capacity > 0) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'LRUCache: Unable to create instance of cache with zero or negative capacity.') : invariant(false) : void 0;\n    this._map = new Map();\n  }\n\n  var _proto = LRUCache.prototype;\n\n  _proto.set = function set(key, value) {\n    this._map[\"delete\"](key);\n\n    this._map.set(key, value);\n\n    if (this._map.size > this._capacity) {\n      var firstKey = this._map.keys().next();\n\n      if (!firstKey.done) {\n        this._map[\"delete\"](firstKey.value);\n      }\n    }\n  };\n\n  _proto.get = function get(key) {\n    var value = this._map.get(key);\n\n    if (value != null) {\n      this._map[\"delete\"](key);\n\n      this._map.set(key, value);\n    }\n\n    return value;\n  };\n\n  _proto.has = function has(key) {\n    return this._map.has(key);\n  };\n\n  _proto[\"delete\"] = function _delete(key) {\n    this._map[\"delete\"](key);\n  };\n\n  _proto.size = function size() {\n    return this._map.size;\n  };\n\n  _proto.capacity = function capacity() {\n    return this._capacity - this._map.size;\n  };\n\n  _proto.clear = function clear() {\n    this._map.clear();\n  };\n\n  return LRUCache;\n}();\n\nfunction create(capacity) {\n  return new LRUCache(capacity);\n}\n\nmodule.exports = {\n  create: create\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar React = require('react');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar _require = require('relay-runtime'),\n    defaultCommitMutation = _require.commitMutation;\n\nvar useState = React.useState,\n    useEffect = React.useEffect,\n    useRef = React.useRef,\n    useCallback = React.useCallback;\n\nvar useIsMountedRef = require('./useIsMountedRef');\n\nfunction useMutation(mutation) {\n  var commitMutationFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultCommitMutation;\n  var environment = useRelayEnvironment();\n  var isMountedRef = useIsMountedRef();\n  var environmentRef = useRef(environment);\n  var mutationRef = useRef(mutation);\n  var inFlightMutationsRef = useRef(new Set());\n\n  var _useState = useState(false),\n      isMutationInFlight = _useState[0],\n      setMutationInFlight = _useState[1];\n\n  var cleanup = useCallback(function (disposable) {\n    if (environmentRef.current === environment && mutationRef.current === mutation) {\n      inFlightMutationsRef.current[\"delete\"](disposable);\n\n      if (isMountedRef.current) {\n        setMutationInFlight(inFlightMutationsRef.current.size > 0);\n      }\n    }\n  }, [environment, isMountedRef, mutation]);\n  useEffect(function () {\n    if (environmentRef.current !== environment || mutationRef.current !== mutation) {\n      inFlightMutationsRef.current = new Set();\n\n      if (isMountedRef.current) {\n        setMutationInFlight(false);\n      }\n\n      environmentRef.current = environment;\n      mutationRef.current = mutation;\n    }\n  }, [environment, isMountedRef, mutation]);\n  var commit = useCallback(function (config) {\n    var disposable = commitMutationFn(environment, (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, config), {}, {\n      mutation: mutation,\n      onCompleted: function onCompleted(response, errors) {\n        cleanup(disposable);\n        config.onCompleted && config.onCompleted(response, errors);\n      },\n      onError: function onError(error) {\n        cleanup(disposable);\n        config.onError && config.onError(error);\n      },\n      onUnsubscribe: function onUnsubscribe() {\n        cleanup(disposable);\n        config.onUnsubscribe && config.onUnsubscribe();\n      }\n    }));\n    inFlightMutationsRef.current.add(disposable);\n\n    if (isMountedRef.current) {\n      setMutationInFlight(true);\n    }\n\n    return disposable;\n  }, [cleanup, commitMutationFn, environment, isMountedRef, mutation]);\n  return [commit, isMutationInFlight];\n}\n\nmodule.exports = useMutation;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar _require = require('relay-runtime'),\n    getSelector = _require.getSelector;\n\nfunction getRootVariablesForFragments(fragments, props) {\n  var rootVariables = {}; // NOTE: For extra safety, we make sure the rootVariables include the\n  // variables from all owners in this fragmentSpec, even though they\n  // should all point to the same owner\n\n  Object.keys(fragments).forEach(function (key) {\n    var _selector$selectors$, _selector$selectors$2, _selector$owner$varia;\n\n    var fragmentNode = fragments[key];\n    var fragmentRef = props[key];\n    var selector = getSelector(fragmentNode, fragmentRef);\n    var fragmentOwnerVariables = selector != null && selector.kind === 'PluralReaderSelector' ? (_selector$selectors$ = (_selector$selectors$2 = selector.selectors[0]) === null || _selector$selectors$2 === void 0 ? void 0 : _selector$selectors$2.owner.variables) !== null && _selector$selectors$ !== void 0 ? _selector$selectors$ : {} : (_selector$owner$varia = selector === null || selector === void 0 ? void 0 : selector.owner.variables) !== null && _selector$owner$varia !== void 0 ? _selector$owner$varia : {}; // $FlowFixMe[cannot-spread-interface]\n\n    rootVariables = (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, rootVariables), fragmentOwnerVariables);\n  });\n  return rootVariables;\n}\n\nmodule.exports = getRootVariablesForFragments;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n// This contextual profiler can be used to wrap a react sub-tree. It will bind\n// the RelayProfiler during the render phase of these components. Allows\n// collecting metrics for a specific part of your application.\n'use strict';\n\nvar React = require('react');\n\nvar ProfilerContext = React.createContext({\n  wrapPrepareQueryResource: function wrapPrepareQueryResource(cb) {\n    return cb();\n  }\n});\nmodule.exports = ProfilerContext;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar _objectWithoutPropertiesLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectWithoutPropertiesLoose\"));\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inheritsLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inheritsLoose\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar React = require('react');\n\nvar ReactRelayContext = require('./ReactRelayContext');\n\nvar ReactRelayQueryFetcher = require('./ReactRelayQueryFetcher');\n\nvar areEqual = require(\"fbjs/lib/areEqual\");\n\nvar buildReactRelayContainer = require('./buildReactRelayContainer');\n\nvar getRootVariablesForFragments = require('./getRootVariablesForFragments');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('./ReactRelayContainerUtils'),\n    getContainerName = _require.getContainerName;\n\nvar _require2 = require('./RelayContext'),\n    assertRelayContext = _require2.assertRelayContext;\n\nvar _require3 = require('relay-runtime'),\n    Observable = _require3.Observable,\n    createFragmentSpecResolver = _require3.createFragmentSpecResolver,\n    createOperationDescriptor = _require3.createOperationDescriptor,\n    getDataIDsFromObject = _require3.getDataIDsFromObject,\n    getRequest = _require3.getRequest,\n    getSelector = _require3.getSelector,\n    getVariablesFromObject = _require3.getVariablesFromObject,\n    isScalarAndEqual = _require3.isScalarAndEqual;\n\n/**\n * Composes a React component class, returning a new class that intercepts\n * props, resolving them with the provided fragments and subscribing for\n * updates.\n */\nfunction createContainerWithFragments(Component, fragments, taggedNode) {\n  var _class, _temp;\n\n  var containerName = getContainerName(Component);\n  return _temp = _class = /*#__PURE__*/function (_React$Component) {\n    (0, _inheritsLoose2[\"default\"])(_class, _React$Component);\n\n    function _class(props) {\n      var _props$__rootIsQueryR, _this;\n\n      _this = _React$Component.call(this, props) || this;\n      (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_handleFragmentDataUpdate\", function () {\n        var resolverFromThisUpdate = _this.state.resolver;\n\n        _this.setState(function (updatedState) {\n          return (// If this event belongs to the current data source, update.\n            // Otherwise we should ignore it.\n            resolverFromThisUpdate === updatedState.resolver ? {\n              data: updatedState.resolver.resolve()\n            } : null\n          );\n        });\n      });\n      (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_refetch\", function (refetchVariables, renderVariables, observerOrCallback, options) {\n        if (_this._isUnmounted) {\n          process.env.NODE_ENV !== \"production\" ? warning(false, 'ReactRelayRefetchContainer: Unexpected call of `refetch` ' + 'on unmounted container `%s`. It looks like some instances ' + 'of your container still trying to refetch the data but they already ' + 'unmounted. Please make sure you clear all timers, intervals, async ' + 'calls, etc that may trigger `refetch`.', containerName) : void 0;\n          return {\n            dispose: function dispose() {}\n          };\n        }\n\n        var _assertRelayContext = assertRelayContext(_this.props.__relayContext),\n            environment = _assertRelayContext.environment;\n\n        var rootVariables = getRootVariablesForFragments(fragments, _this.props);\n        var fetchVariables = typeof refetchVariables === 'function' ? refetchVariables(_this._getFragmentVariables()) : refetchVariables; // $FlowFixMe[cannot-spread-interface]\n\n        fetchVariables = (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, rootVariables), fetchVariables);\n        var fragmentVariables = renderVariables ? // $FlowFixMe[cannot-spread-interface]\n        (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, fetchVariables), renderVariables) : fetchVariables;\n        var cacheConfig = options ? {\n          force: !!options.force\n        } : undefined;\n\n        if (cacheConfig != null && (options === null || options === void 0 ? void 0 : options.metadata) != null) {\n          cacheConfig.metadata = options === null || options === void 0 ? void 0 : options.metadata;\n        }\n\n        var observer = typeof observerOrCallback === 'function' ? {\n          // callback is not exectued on complete or unsubscribe\n          // for backward compatibility\n          next: observerOrCallback,\n          error: observerOrCallback\n        } : observerOrCallback || {};\n        var query = getRequest(taggedNode);\n        var operation = createOperationDescriptor(query, fetchVariables, cacheConfig); // TODO: T26288752 find a better way\n\n        /* eslint-disable lint/react-state-props-mutation */\n\n        _this.state.localVariables = fetchVariables;\n        /* eslint-enable lint/react-state-props-mutation */\n        // Cancel any previously running refetch.\n\n        _this._refetchSubscription && _this._refetchSubscription.unsubscribe(); // Declare refetchSubscription before assigning it in .start(), since\n        // synchronous completion may call callbacks .subscribe() returns.\n\n        var refetchSubscription;\n\n        var storeSnapshot = _this._getQueryFetcher().lookupInStore(environment, operation, options === null || options === void 0 ? void 0 : options.fetchPolicy);\n\n        if (storeSnapshot != null) {\n          _this.state.resolver.setVariables(fragmentVariables, operation.request.node);\n\n          _this.setState(function (latestState) {\n            return {\n              data: latestState.resolver.resolve(),\n              contextForChildren: {\n                environment: _this.props.__relayContext.environment\n              }\n            };\n          }, function () {\n            observer.next && observer.next();\n            observer.complete && observer.complete();\n          });\n\n          return {\n            dispose: function dispose() {}\n          };\n        }\n\n        _this._getQueryFetcher().execute({\n          environment: environment,\n          operation: operation,\n          // TODO (T26430099): Cleanup old references\n          preservePreviousReferences: true\n        }).mergeMap(function (response) {\n          _this.state.resolver.setVariables(fragmentVariables, operation.request.node);\n\n          return Observable.create(function (sink) {\n            return _this.setState(function (latestState) {\n              return {\n                data: latestState.resolver.resolve(),\n                contextForChildren: {\n                  environment: _this.props.__relayContext.environment\n                }\n              };\n            }, function () {\n              sink.next();\n              sink.complete();\n            });\n          });\n        })[\"finally\"](function () {\n          // Finalizing a refetch should only clear this._refetchSubscription\n          // if the finizing subscription is the most recent call.\n          if (_this._refetchSubscription === refetchSubscription) {\n            _this._refetchSubscription = null;\n          }\n        }).subscribe((0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, observer), {}, {\n          start: function start(subscription) {\n            _this._refetchSubscription = refetchSubscription = subscription;\n            observer.start && observer.start(subscription);\n          }\n        }));\n\n        return {\n          dispose: function dispose() {\n            refetchSubscription && refetchSubscription.unsubscribe();\n          }\n        };\n      });\n      var relayContext = assertRelayContext(props.__relayContext);\n      var rootIsQueryRenderer = (_props$__rootIsQueryR = props.__rootIsQueryRenderer) !== null && _props$__rootIsQueryR !== void 0 ? _props$__rootIsQueryR : false;\n      _this._refetchSubscription = null; // Do not provide a subscription/callback here.\n      // It is possible for this render to be interrupted or aborted,\n      // In which case the subscription would cause a leak.\n      // We will add the subscription in componentDidMount().\n\n      var resolver = createFragmentSpecResolver(relayContext, containerName, fragments, props, rootIsQueryRenderer);\n      _this.state = {\n        data: resolver.resolve(),\n        localVariables: null,\n        prevProps: props,\n        prevPropsContext: relayContext,\n        contextForChildren: relayContext,\n        relayProp: getRelayProp(relayContext.environment, _this._refetch),\n        resolver: resolver\n      };\n      _this._isUnmounted = false;\n      return _this;\n    }\n\n    var _proto = _class.prototype;\n\n    _proto.componentDidMount = function componentDidMount() {\n      this._isUnmounted = false;\n\n      this._subscribeToNewResolver();\n    };\n\n    _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {\n      // If the environment has changed or props point to new records then\n      // previously fetched data and any pending fetches no longer apply:\n      // - Existing references are on the old environment.\n      // - Existing references are based on old variables.\n      // - Pending fetches are for the previous records.\n      if (this.state.resolver !== prevState.resolver) {\n        prevState.resolver.dispose();\n        this._queryFetcher && this._queryFetcher.dispose();\n        this._refetchSubscription && this._refetchSubscription.unsubscribe();\n\n        this._subscribeToNewResolver();\n      }\n    }\n    /**\n     * When new props are received, read data for the new props and add it to\n     * state. Props may be the same in which case previous data can be reused.\n     */\n    ;\n\n    _class.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {\n      var _nextProps$__rootIsQu;\n\n      // Any props change could impact the query, so we mirror props in state.\n      // This is an unusual pattern, but necessary for this container usecase.\n      var prevProps = prevState.prevProps;\n      var relayContext = assertRelayContext(nextProps.__relayContext);\n      var rootIsQueryRenderer = (_nextProps$__rootIsQu = nextProps.__rootIsQueryRenderer) !== null && _nextProps$__rootIsQu !== void 0 ? _nextProps$__rootIsQu : false;\n      var prevIDs = getDataIDsFromObject(fragments, prevProps);\n      var nextIDs = getDataIDsFromObject(fragments, nextProps);\n      var prevRootVariables = getRootVariablesForFragments(fragments, prevProps);\n      var nextRootVariables = getRootVariablesForFragments(fragments, nextProps);\n      var resolver = prevState.resolver; // If the environment has changed or props point to new records then\n      // previously fetched data and any pending fetches no longer apply:\n      // - Existing references are on the old environment.\n      // - Existing references are based on old variables.\n      // - Pending fetches are for the previous records.\n\n      if (prevState.prevPropsContext.environment !== relayContext.environment || !areEqual(prevRootVariables, nextRootVariables) || !areEqual(prevIDs, nextIDs)) {\n        // Do not provide a subscription/callback here.\n        // It is possible for this render to be interrupted or aborted,\n        // In which case the subscription would cause a leak.\n        // We will add the subscription in componentDidUpdate().\n        resolver = createFragmentSpecResolver(relayContext, containerName, fragments, nextProps, rootIsQueryRenderer);\n        return {\n          data: resolver.resolve(),\n          localVariables: null,\n          prevProps: nextProps,\n          prevPropsContext: relayContext,\n          contextForChildren: relayContext,\n          relayProp: getRelayProp(relayContext.environment, prevState.relayProp.refetch),\n          resolver: resolver\n        };\n      } else if (!prevState.localVariables) {\n        resolver.setProps(nextProps);\n      }\n\n      var data = resolver.resolve();\n\n      if (data !== prevState.data) {\n        return {\n          data: data,\n          prevProps: nextProps\n        };\n      }\n\n      return null;\n    };\n\n    _proto.componentWillUnmount = function componentWillUnmount() {\n      this._isUnmounted = true;\n      this.state.resolver.dispose();\n      this._queryFetcher && this._queryFetcher.dispose();\n      this._refetchSubscription && this._refetchSubscription.unsubscribe();\n    };\n\n    _proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {\n      // Short-circuit if any Relay-related data has changed\n      if (nextState.data !== this.state.data || nextState.relayProp !== this.state.relayProp) {\n        return true;\n      } // Otherwise, for convenience short-circuit if all non-Relay props\n      // are scalar and equal\n\n\n      var keys = Object.keys(nextProps);\n\n      for (var ii = 0; ii < keys.length; ii++) {\n        var _key = keys[ii];\n\n        if (_key === '__relayContext') {\n          if (this.state.prevPropsContext.environment !== nextState.prevPropsContext.environment) {\n            return true;\n          }\n        } else {\n          if (!fragments.hasOwnProperty(_key) && !isScalarAndEqual(nextProps[_key], this.props[_key])) {\n            return true;\n          }\n        }\n      }\n\n      return false;\n    };\n\n    _proto._subscribeToNewResolver = function _subscribeToNewResolver() {\n      var _this$state = this.state,\n          data = _this$state.data,\n          resolver = _this$state.resolver; // Event listeners are only safe to add during the commit phase,\n      // So they won't leak if render is interrupted or errors.\n\n      resolver.setCallback(this._handleFragmentDataUpdate); // External values could change between render and commit.\n      // Check for this case, even though it requires an extra store read.\n\n      var maybeNewData = resolver.resolve();\n\n      if (data !== maybeNewData) {\n        this.setState({\n          data: maybeNewData\n        });\n      }\n    }\n    /**\n     * Render new data for the existing props/context.\n     */\n    ;\n\n    _proto._getFragmentVariables = function _getFragmentVariables() {\n      return getVariablesFromObject(fragments, this.props);\n    };\n\n    _proto._getQueryFetcher = function _getQueryFetcher() {\n      if (!this._queryFetcher) {\n        this._queryFetcher = new ReactRelayQueryFetcher();\n      }\n\n      return this._queryFetcher;\n    };\n\n    _proto.render = function render() {\n      var _this$props = this.props,\n          componentRef = _this$props.componentRef,\n          __relayContext = _this$props.__relayContext,\n          __rootIsQueryRenderer = _this$props.__rootIsQueryRenderer,\n          props = (0, _objectWithoutPropertiesLoose2[\"default\"])(_this$props, [\"componentRef\", \"__relayContext\", \"__rootIsQueryRenderer\"]);\n      var _this$state2 = this.state,\n          relayProp = _this$state2.relayProp,\n          contextForChildren = _this$state2.contextForChildren;\n      return /*#__PURE__*/React.createElement(ReactRelayContext.Provider, {\n        value: contextForChildren\n      }, /*#__PURE__*/React.createElement(Component, (0, _extends2[\"default\"])({}, props, this.state.data, {\n        ref: componentRef,\n        relay: relayProp\n      })));\n    };\n\n    return _class;\n  }(React.Component), (0, _defineProperty2[\"default\"])(_class, \"displayName\", containerName), _temp;\n}\n\nfunction getRelayProp(environment, refetch) {\n  return {\n    environment: environment,\n    refetch: refetch\n  };\n}\n/**\n * Wrap the basic `createContainer()` function with logic to adapt to the\n * `context.relay.environment` in which it is rendered. Specifically, the\n * extraction of the environment-specific version of fragments in the\n * `fragmentSpec` is memoized once per environment, rather than once per\n * instance of the container constructed/rendered.\n */\n\n\nfunction createContainer(Component, fragmentSpec, taggedNode) {\n  // $FlowFixMe[incompatible-return]\n  return buildReactRelayContainer(Component, fragmentSpec, function (ComponentClass, fragments) {\n    return createContainerWithFragments(ComponentClass, fragments, taggedNode);\n  });\n}\n\nmodule.exports = {\n  createContainer: createContainer\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar _objectWithoutPropertiesLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectWithoutPropertiesLoose\"));\n\nvar _assertThisInitialized2 = _interopRequireDefault(require(\"@babel/runtime/helpers/assertThisInitialized\"));\n\nvar _inheritsLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inheritsLoose\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar React = require('react');\n\nvar areEqual = require(\"fbjs/lib/areEqual\");\n\nvar buildReactRelayContainer = require('./buildReactRelayContainer');\n\nvar getRootVariablesForFragments = require('./getRootVariablesForFragments');\n\nvar _require = require('./ReactRelayContainerUtils'),\n    getContainerName = _require.getContainerName;\n\nvar _require2 = require('./RelayContext'),\n    assertRelayContext = _require2.assertRelayContext;\n\nvar _require3 = require('relay-runtime'),\n    createFragmentSpecResolver = _require3.createFragmentSpecResolver,\n    getDataIDsFromObject = _require3.getDataIDsFromObject,\n    isScalarAndEqual = _require3.isScalarAndEqual;\n\n/**\n * Composes a React component class, returning a new class that intercepts\n * props, resolving them with the provided fragments and subscribing for\n * updates.\n */\nfunction createContainerWithFragments(Component, fragments) {\n  var _class, _temp;\n\n  var containerName = getContainerName(Component);\n  return _temp = _class = /*#__PURE__*/function (_React$Component) {\n    (0, _inheritsLoose2[\"default\"])(_class, _React$Component);\n\n    function _class(props) {\n      var _props$__rootIsQueryR, _this;\n\n      _this = _React$Component.call(this, props) || this;\n      (0, _defineProperty2[\"default\"])((0, _assertThisInitialized2[\"default\"])(_this), \"_handleFragmentDataUpdate\", function () {\n        var resolverFromThisUpdate = _this.state.resolver;\n\n        _this.setState(function (updatedState) {\n          return (// If this event belongs to the current data source, update.\n            // Otherwise we should ignore it.\n            resolverFromThisUpdate === updatedState.resolver ? {\n              data: updatedState.resolver.resolve(),\n              relayProp: getRelayProp(updatedState.relayProp.environment)\n            } : null\n          );\n        });\n      });\n      var relayContext = assertRelayContext(props.__relayContext);\n      var rootIsQueryRenderer = (_props$__rootIsQueryR = props.__rootIsQueryRenderer) !== null && _props$__rootIsQueryR !== void 0 ? _props$__rootIsQueryR : false; // Do not provide a subscription/callback here.\n      // It is possible for this render to be interrupted or aborted,\n      // In which case the subscription would cause a leak.\n      // We will add the subscription in componentDidMount().\n\n      var resolver = createFragmentSpecResolver(relayContext, containerName, fragments, props, rootIsQueryRenderer);\n      _this.state = {\n        data: resolver.resolve(),\n        prevProps: props,\n        prevPropsContext: relayContext,\n        relayProp: getRelayProp(relayContext.environment),\n        resolver: resolver\n      };\n      return _this;\n    }\n    /**\n     * When new props are received, read data for the new props and subscribe\n     * for updates. Props may be the same in which case previous data and\n     * subscriptions can be reused.\n     */\n\n\n    _class.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {\n      var _nextProps$__rootIsQu;\n\n      // Any props change could impact the query, so we mirror props in state.\n      // This is an unusual pattern, but necessary for this container usecase.\n      var prevProps = prevState.prevProps;\n      var relayContext = assertRelayContext(nextProps.__relayContext);\n      var rootIsQueryRenderer = (_nextProps$__rootIsQu = nextProps.__rootIsQueryRenderer) !== null && _nextProps$__rootIsQu !== void 0 ? _nextProps$__rootIsQu : false;\n      var prevIDs = getDataIDsFromObject(fragments, prevProps);\n      var nextIDs = getDataIDsFromObject(fragments, nextProps);\n      var resolver = prevState.resolver; // If the environment has changed or props point to new records then\n      // previously fetched data and any pending fetches no longer apply:\n      // - Existing references are on the old environment.\n      // - Existing references are based on old variables.\n      // - Pending fetches are for the previous records.\n\n      if (prevState.prevPropsContext.environment !== relayContext.environment || !areEqual(prevIDs, nextIDs)) {\n        // Do not provide a subscription/callback here.\n        // It is possible for this render to be interrupted or aborted,\n        // In which case the subscription would cause a leak.\n        // We will add the subscription in componentDidUpdate().\n        resolver = createFragmentSpecResolver(relayContext, containerName, fragments, nextProps, rootIsQueryRenderer);\n        return {\n          data: resolver.resolve(),\n          prevPropsContext: relayContext,\n          prevProps: nextProps,\n          relayProp: getRelayProp(relayContext.environment),\n          resolver: resolver\n        };\n      } else {\n        resolver.setProps(nextProps);\n        var data = resolver.resolve();\n\n        if (data !== prevState.data) {\n          return {\n            data: data,\n            prevProps: nextProps,\n            prevPropsContext: relayContext,\n            relayProp: getRelayProp(relayContext.environment)\n          };\n        }\n      }\n\n      return null;\n    };\n\n    var _proto = _class.prototype;\n\n    _proto.componentDidMount = function componentDidMount() {\n      this._subscribeToNewResolver();\n\n      this._rerenderIfStoreHasChanged();\n    };\n\n    _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {\n      if (this.state.resolver !== prevState.resolver) {\n        prevState.resolver.dispose();\n\n        this._subscribeToNewResolver();\n      }\n\n      this._rerenderIfStoreHasChanged();\n    };\n\n    _proto.componentWillUnmount = function componentWillUnmount() {\n      this.state.resolver.dispose();\n    };\n\n    _proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {\n      // Short-circuit if any Relay-related data has changed\n      if (nextState.data !== this.state.data) {\n        return true;\n      } // Otherwise, for convenience short-circuit if all non-Relay props\n      // are scalar and equal\n\n\n      var keys = Object.keys(nextProps);\n\n      for (var ii = 0; ii < keys.length; ii++) {\n        var _key = keys[ii];\n\n        if (_key === '__relayContext') {\n          if (nextState.prevPropsContext.environment !== this.state.prevPropsContext.environment) {\n            return true;\n          }\n        } else {\n          if (!fragments.hasOwnProperty(_key) && !isScalarAndEqual(nextProps[_key], this.props[_key])) {\n            return true;\n          }\n        }\n      }\n\n      return false;\n    }\n    /**\n     * Render new data for the existing props/context.\n     */\n    ;\n\n    _proto._rerenderIfStoreHasChanged = function _rerenderIfStoreHasChanged() {\n      var _this$state = this.state,\n          data = _this$state.data,\n          resolver = _this$state.resolver; // External values could change between render and commit.\n      // Check for this case, even though it requires an extra store read.\n\n      var maybeNewData = resolver.resolve();\n\n      if (data !== maybeNewData) {\n        this.setState({\n          data: maybeNewData\n        });\n      }\n    };\n\n    _proto._subscribeToNewResolver = function _subscribeToNewResolver() {\n      var resolver = this.state.resolver; // Event listeners are only safe to add during the commit phase,\n      // So they won't leak if render is interrupted or errors.\n\n      resolver.setCallback(this._handleFragmentDataUpdate);\n    };\n\n    _proto.render = function render() {\n      var _this$props = this.props,\n          componentRef = _this$props.componentRef,\n          __relayContext = _this$props.__relayContext,\n          __rootIsQueryRenderer = _this$props.__rootIsQueryRenderer,\n          props = (0, _objectWithoutPropertiesLoose2[\"default\"])(_this$props, [\"componentRef\", \"__relayContext\", \"__rootIsQueryRenderer\"]);\n      return React.createElement(Component, (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, props), this.state.data), {}, {\n        ref: componentRef,\n        relay: this.state.relayProp\n      }));\n    };\n\n    return _class;\n  }(React.Component), (0, _defineProperty2[\"default\"])(_class, \"displayName\", containerName), _temp;\n}\n\nfunction getRelayProp(environment) {\n  return {\n    environment: environment\n  };\n}\n/**\n * Wrap the basic `createContainer()` function with logic to adapt to the\n * `context.relay.environment` in which it is rendered. Specifically, the\n * extraction of the environment-specific version of fragments in the\n * `fragmentSpec` is memoized once per environment, rather than once per\n * instance of the container constructed/rendered.\n */\n\n\nfunction createContainer(Component, fragmentSpec) {\n  // $FlowFixMe[incompatible-return]\n  return buildReactRelayContainer(Component, fragmentSpec, createContainerWithFragments);\n}\n\nmodule.exports = {\n  createContainer: createContainer\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n/**\n * Determine if a given value is an object that implements the `Environment`\n * interface defined in `RelayEnvironmentTypes`.\n */\n\nfunction isRelayEnvironment(environment) {\n  return typeof environment === 'object' && environment !== null && // TODO: add applyMutation/sendMutation once ready in both cores\n  typeof environment.check === 'function' && typeof environment.lookup === 'function' && typeof environment.retain === 'function' && typeof environment.execute === 'function' && typeof environment.subscribe === 'function';\n}\n\nmodule.exports = isRelayEnvironment;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @emails oncall+relay\n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar LRUCache = require('./LRUCache');\n\nvar invariant = require('invariant');\n\nvar _require = require('relay-runtime'),\n    isPromise = _require.isPromise;\n\nvar CACHE_CAPACITY = 1000;\nvar DEFAULT_FETCH_POLICY = 'store-or-network';\nvar DATA_RETENTION_TIMEOUT = 5 * 60 * 1000;\nvar WEAKMAP_SUPPORTED = typeof WeakMap === 'function';\n\nfunction getQueryCacheIdentifier(environment, operation, maybeFetchPolicy, maybeRenderPolicy, cacheBreaker) {\n  var fetchPolicy = maybeFetchPolicy !== null && maybeFetchPolicy !== void 0 ? maybeFetchPolicy : DEFAULT_FETCH_POLICY;\n  var renderPolicy = maybeRenderPolicy !== null && maybeRenderPolicy !== void 0 ? maybeRenderPolicy : environment.UNSTABLE_getDefaultRenderPolicy();\n  var cacheIdentifier = \"\".concat(fetchPolicy, \"-\").concat(renderPolicy, \"-\").concat(operation.request.identifier);\n\n  if (cacheBreaker != null) {\n    return \"\".concat(cacheIdentifier, \"-\").concat(cacheBreaker);\n  }\n\n  return cacheIdentifier;\n}\n\nfunction getQueryResult(operation, cacheIdentifier) {\n  var rootFragmentRef = {\n    __id: operation.fragment.dataID,\n    __fragments: (0, _defineProperty2[\"default\"])({}, operation.fragment.node.name, operation.request.variables),\n    __fragmentOwner: operation.request\n  };\n  return {\n    cacheIdentifier: cacheIdentifier,\n    fragmentNode: operation.request.node.fragment,\n    fragmentRef: rootFragmentRef,\n    operation: operation\n  };\n}\n\nvar nextID = 200000;\n\nfunction createCacheEntry(cacheIdentifier, operation, value, networkSubscription, onDispose) {\n  var currentValue = value;\n  var retainCount = 0;\n  var retainDisposable = null;\n  var releaseTemporaryRetain = null;\n  var currentNetworkSubscription = networkSubscription;\n\n  var retain = function retain(environment) {\n    retainCount++;\n\n    if (retainCount === 1) {\n      retainDisposable = environment.retain(operation);\n    }\n\n    return {\n      dispose: function dispose() {\n        retainCount = Math.max(0, retainCount - 1);\n\n        if (retainCount === 0) {\n          !(retainDisposable != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected disposable to release query to be defined.' + \"If you're seeing this, this is likely a bug in Relay.\") : invariant(false) : void 0;\n          retainDisposable.dispose();\n          retainDisposable = null;\n        }\n\n        onDispose(cacheEntry);\n      }\n    };\n  };\n\n  var cacheEntry = {\n    cacheIdentifier: cacheIdentifier,\n    id: nextID++,\n    getValue: function getValue() {\n      return currentValue;\n    },\n    setValue: function setValue(val) {\n      currentValue = val;\n    },\n    getRetainCount: function getRetainCount() {\n      return retainCount;\n    },\n    getNetworkSubscription: function getNetworkSubscription() {\n      return currentNetworkSubscription;\n    },\n    setNetworkSubscription: function setNetworkSubscription(subscription) {\n      if (currentNetworkSubscription != null) {\n        currentNetworkSubscription.unsubscribe();\n      }\n\n      currentNetworkSubscription = subscription;\n    },\n    temporaryRetain: function temporaryRetain(environment) {\n      // NOTE: If we're executing in a server environment, there's no need\n      // to create temporary retains, since the component will never commit.\n      if (environment.isServer()) {\n        return {\n          dispose: function dispose() {}\n        };\n      } // NOTE: temporaryRetain is called during the render phase. However,\n      // given that we can't tell if this render will eventually commit or not,\n      // we create a timer to autodispose of this retain in case the associated\n      // component never commits.\n      // If the component /does/ commit, permanentRetain will clear this timeout\n      // and permanently retain the data.\n\n\n      var disposable = retain(environment);\n      var releaseQueryTimeout = null;\n\n      var localReleaseTemporaryRetain = function localReleaseTemporaryRetain() {\n        clearTimeout(releaseQueryTimeout);\n        releaseQueryTimeout = null;\n        releaseTemporaryRetain = null;\n        disposable.dispose(); // Normally if this entry never commits, the request would've ended by the\n        // time this timeout expires and the temporary retain is released. However,\n        // we need to do this for live queries which remain open indefinitely.\n\n        if (retainCount <= 0 && currentNetworkSubscription != null) {\n          currentNetworkSubscription.unsubscribe();\n        }\n      };\n\n      releaseQueryTimeout = setTimeout(localReleaseTemporaryRetain, DATA_RETENTION_TIMEOUT); // NOTE: Since temporaryRetain can be called multiple times, we release\n      // the previous temporary retain after we re-establish a new one, since\n      // we only ever need a single temporary retain until the permanent retain is\n      // established.\n      // temporaryRetain may be called multiple times by React during the render\n      // phase, as well as multiple times by other query components that are\n      // rendering the same query/variables.\n\n      if (releaseTemporaryRetain != null) {\n        releaseTemporaryRetain();\n      }\n\n      releaseTemporaryRetain = localReleaseTemporaryRetain;\n      return {\n        dispose: function dispose() {\n          releaseTemporaryRetain && releaseTemporaryRetain();\n        }\n      };\n    },\n    permanentRetain: function permanentRetain(environment) {\n      var disposable = retain(environment);\n\n      if (releaseTemporaryRetain != null) {\n        releaseTemporaryRetain();\n        releaseTemporaryRetain = null;\n      }\n\n      return {\n        dispose: function dispose() {\n          disposable.dispose();\n\n          if (retainCount <= 0 && currentNetworkSubscription != null) {\n            currentNetworkSubscription.unsubscribe();\n          }\n        }\n      };\n    }\n  };\n  return cacheEntry;\n}\n\nvar QueryResourceImpl = /*#__PURE__*/function () {\n  function QueryResourceImpl(environment) {\n    var _this = this;\n\n    (0, _defineProperty2[\"default\"])(this, \"_clearCacheEntry\", function (cacheEntry) {\n      if (cacheEntry.getRetainCount() <= 0) {\n        _this._cache[\"delete\"](cacheEntry.cacheIdentifier);\n      }\n    });\n    this._environment = environment;\n    this._cache = LRUCache.create(CACHE_CAPACITY);\n  }\n\n  var _proto = QueryResourceImpl.prototype;\n\n  _proto.prepare = function prepare(operation, fetchObservable, maybeFetchPolicy, maybeRenderPolicy, observer, cacheBreaker, profilerContext) {\n    var cacheIdentifier = getQueryCacheIdentifier(this._environment, operation, maybeFetchPolicy, maybeRenderPolicy, cacheBreaker);\n    return this.prepareWithIdentifier(cacheIdentifier, operation, fetchObservable, maybeFetchPolicy, maybeRenderPolicy, observer, profilerContext);\n  }\n  /**\n   * This function should be called during a Component's render function,\n   * to either read an existing cached value for the query, or fetch the query\n   * and suspend.\n   */\n  ;\n\n  _proto.prepareWithIdentifier = function prepareWithIdentifier(cacheIdentifier, operation, fetchObservable, maybeFetchPolicy, maybeRenderPolicy, observer, profilerContext) {\n    var environment = this._environment;\n    var fetchPolicy = maybeFetchPolicy !== null && maybeFetchPolicy !== void 0 ? maybeFetchPolicy : DEFAULT_FETCH_POLICY;\n    var renderPolicy = maybeRenderPolicy !== null && maybeRenderPolicy !== void 0 ? maybeRenderPolicy : environment.UNSTABLE_getDefaultRenderPolicy(); // 1. Check if there's a cached value for this operation, and reuse it if\n    // it's available\n\n    var cacheEntry = this._cache.get(cacheIdentifier);\n\n    var temporaryRetainDisposable = null;\n\n    if (cacheEntry == null) {\n      // 2. If a cached value isn't available, try fetching the operation.\n      // _fetchAndSaveQuery will update the cache with either a Promise or\n      // an Error to throw, or a QueryResult to return.\n      cacheEntry = this._fetchAndSaveQuery(cacheIdentifier, operation, fetchObservable, fetchPolicy, renderPolicy, profilerContext, (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, observer), {}, {\n        unsubscribe: function unsubscribe(subscription) {\n          // 4. If the request is cancelled, make sure to dispose\n          // of the temporary retain; this will ensure that a promise\n          // doesn't remain unnecessarily cached until the temporary retain\n          // expires. Not clearing the temporary retain might cause the\n          // query to incorrectly re-suspend.\n          if (temporaryRetainDisposable != null) {\n            temporaryRetainDisposable.dispose();\n          }\n\n          var observerUnsubscribe = observer === null || observer === void 0 ? void 0 : observer.unsubscribe;\n          observerUnsubscribe && observerUnsubscribe(subscription);\n        }\n      }));\n    } // 3. Temporarily retain here in render phase. When the component reading\n    // the operation is committed, we will transfer ownership of data retention\n    // to the component.\n    // In case the component never commits (mounts or updates) from this render,\n    // this data retention hold will auto-release itself after a timeout.\n\n\n    temporaryRetainDisposable = cacheEntry.temporaryRetain(environment);\n    var cachedValue = cacheEntry.getValue();\n\n    if (isPromise(cachedValue) || cachedValue instanceof Error) {\n      throw cachedValue;\n    }\n\n    return cachedValue;\n  }\n  /**\n   * This function should be called during a component's commit phase\n   * (e.g. inside useEffect), in order to retain the operation in the Relay store\n   * and transfer ownership of the operation to the component lifecycle.\n   */\n  ;\n\n  _proto.retain = function retain(queryResult, profilerContext) {\n    var environment = this._environment;\n    var cacheIdentifier = queryResult.cacheIdentifier,\n        operation = queryResult.operation;\n\n    var cacheEntry = this._getOrCreateCacheEntry(cacheIdentifier, operation, queryResult, null);\n\n    var disposable = cacheEntry.permanentRetain(environment);\n\n    environment.__log({\n      name: 'queryresource.retain',\n      profilerContext: profilerContext,\n      resourceID: cacheEntry.id\n    });\n\n    return {\n      dispose: function dispose() {\n        disposable.dispose();\n      }\n    };\n  };\n\n  _proto.TESTS_ONLY__getCacheEntry = function TESTS_ONLY__getCacheEntry(operation, maybeFetchPolicy, maybeRenderPolicy, cacheBreaker) {\n    var environment = this._environment;\n    var cacheIdentifier = getQueryCacheIdentifier(environment, operation, maybeFetchPolicy, maybeRenderPolicy, cacheBreaker);\n    return this._cache.get(cacheIdentifier);\n  };\n\n  _proto._getOrCreateCacheEntry = function _getOrCreateCacheEntry(cacheIdentifier, operation, value, networkSubscription) {\n    var cacheEntry = this._cache.get(cacheIdentifier);\n\n    if (cacheEntry == null) {\n      cacheEntry = createCacheEntry(cacheIdentifier, operation, value, networkSubscription, this._clearCacheEntry);\n\n      this._cache.set(cacheIdentifier, cacheEntry);\n    }\n\n    return cacheEntry;\n  };\n\n  _proto._fetchAndSaveQuery = function _fetchAndSaveQuery(cacheIdentifier, operation, fetchObservable, fetchPolicy, renderPolicy, profilerContext, observer) {\n    var _this2 = this;\n\n    var environment = this._environment; // NOTE: Running `check` will write missing data to the store using any\n    // missing data handlers specified on the environment;\n    // We run it here first to make the handlers get a chance to populate\n    // missing data.\n\n    var queryAvailability = environment.check(operation);\n    var queryStatus = queryAvailability.status;\n    var hasFullQuery = queryStatus === 'available';\n    var canPartialRender = hasFullQuery || renderPolicy === 'partial' && queryStatus !== 'stale';\n    var shouldFetch;\n    var shouldAllowRender;\n\n    var resolveNetworkPromise = function resolveNetworkPromise() {};\n\n    switch (fetchPolicy) {\n      case 'store-only':\n        {\n          shouldFetch = false;\n          shouldAllowRender = true;\n          break;\n        }\n\n      case 'store-or-network':\n        {\n          shouldFetch = !hasFullQuery;\n          shouldAllowRender = canPartialRender;\n          break;\n        }\n\n      case 'store-and-network':\n        {\n          shouldFetch = true;\n          shouldAllowRender = canPartialRender;\n          break;\n        }\n\n      case 'network-only':\n      default:\n        {\n          shouldFetch = true;\n          shouldAllowRender = false;\n          break;\n        }\n    } // NOTE: If this value is false, we will cache a promise for this\n    // query, which means we will suspend here at this query root.\n    // If it's true, we will cache the query resource and allow rendering to\n    // continue.\n\n\n    if (shouldAllowRender) {\n      var queryResult = getQueryResult(operation, cacheIdentifier);\n\n      var _cacheEntry = createCacheEntry(cacheIdentifier, operation, queryResult, null, this._clearCacheEntry);\n\n      this._cache.set(cacheIdentifier, _cacheEntry);\n    }\n\n    if (shouldFetch) {\n      var _queryResult = getQueryResult(operation, cacheIdentifier);\n\n      var networkSubscription;\n      fetchObservable.subscribe({\n        start: function start(subscription) {\n          networkSubscription = subscription;\n\n          var cacheEntry = _this2._cache.get(cacheIdentifier);\n\n          if (cacheEntry) {\n            cacheEntry.setNetworkSubscription(networkSubscription);\n          }\n\n          var observerStart = observer === null || observer === void 0 ? void 0 : observer.start;\n          observerStart && observerStart(subscription);\n        },\n        next: function next() {\n          var snapshot = environment.lookup(operation.fragment);\n\n          var cacheEntry = _this2._getOrCreateCacheEntry(cacheIdentifier, operation, _queryResult, networkSubscription);\n\n          cacheEntry.setValue(_queryResult);\n          resolveNetworkPromise();\n          var observerNext = observer === null || observer === void 0 ? void 0 : observer.next;\n          observerNext && observerNext(snapshot);\n        },\n        error: function error(_error) {\n          var cacheEntry = _this2._getOrCreateCacheEntry(cacheIdentifier, operation, _error, networkSubscription);\n\n          cacheEntry.setValue(_error);\n          resolveNetworkPromise();\n          networkSubscription = null;\n          cacheEntry.setNetworkSubscription(null);\n          var observerError = observer === null || observer === void 0 ? void 0 : observer.error;\n          observerError && observerError(_error);\n        },\n        complete: function complete() {\n          resolveNetworkPromise();\n          networkSubscription = null;\n\n          var cacheEntry = _this2._cache.get(cacheIdentifier);\n\n          if (cacheEntry) {\n            cacheEntry.setNetworkSubscription(null);\n          }\n\n          var observerComplete = observer === null || observer === void 0 ? void 0 : observer.complete;\n          observerComplete && observerComplete();\n        },\n        unsubscribe: observer === null || observer === void 0 ? void 0 : observer.unsubscribe\n      });\n\n      var _cacheEntry2 = this._cache.get(cacheIdentifier);\n\n      if (!_cacheEntry2) {\n        var networkPromise = new Promise(function (resolve) {\n          resolveNetworkPromise = resolve;\n        }); // $FlowExpectedError[prop-missing] Expando to annotate Promises.\n\n        networkPromise.displayName = 'Relay(' + operation.fragment.node.name + ')';\n        _cacheEntry2 = createCacheEntry(cacheIdentifier, operation, networkPromise, networkSubscription, this._clearCacheEntry);\n\n        this._cache.set(cacheIdentifier, _cacheEntry2);\n      }\n    } else {\n      var observerComplete = observer === null || observer === void 0 ? void 0 : observer.complete;\n      observerComplete && observerComplete();\n    }\n\n    var cacheEntry = this._cache.get(cacheIdentifier);\n\n    !(cacheEntry != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected to have cached a result when attempting to fetch query.' + \"If you're seeing this, this is likely a bug in Relay.\") : invariant(false) : void 0;\n\n    environment.__log({\n      name: 'queryresource.fetch',\n      resourceID: cacheEntry.id,\n      operation: operation,\n      profilerContext: profilerContext,\n      fetchPolicy: fetchPolicy,\n      renderPolicy: renderPolicy,\n      queryAvailability: queryAvailability,\n      shouldFetch: shouldFetch\n    });\n\n    return cacheEntry;\n  };\n\n  return QueryResourceImpl;\n}();\n\nfunction createQueryResource(environment) {\n  return new QueryResourceImpl(environment);\n}\n\nvar dataResources = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();\n\nfunction getQueryResourceForEnvironment(environment) {\n  var cached = dataResources.get(environment);\n\n  if (cached) {\n    return cached;\n  }\n\n  var newDataResource = createQueryResource(environment);\n  dataResources.set(environment, newDataResource);\n  return newDataResource;\n}\n\nmodule.exports = {\n  createQueryResource: createQueryResource,\n  getQueryResourceForEnvironment: getQueryResourceForEnvironment,\n  getQueryCacheIdentifier: getQueryCacheIdentifier\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar getRefetchMetadata = require('./getRefetchMetadata');\n\nvar invariant = require('invariant');\n\nfunction getPaginationMetadata(fragmentNode, componentDisplayName) {\n  var _fragmentNode$metadat, _fragmentNode$metadat2;\n\n  var _getRefetchMetadata = getRefetchMetadata(fragmentNode, componentDisplayName),\n      paginationRequest = _getRefetchMetadata.refetchableRequest,\n      refetchMetadata = _getRefetchMetadata.refetchMetadata;\n\n  var paginationMetadata = refetchMetadata.connection;\n  !(paginationMetadata != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: getPaginationMetadata(): Expected fragment `%s` to include a ' + 'connection when using `%s`. Did you forget to add a @connection ' + 'directive to the connection field in the fragment?', componentDisplayName, fragmentNode.name) : invariant(false) : void 0;\n  var connectionPathInFragmentData = paginationMetadata.path;\n  var connectionMetadata = ((_fragmentNode$metadat = (_fragmentNode$metadat2 = fragmentNode.metadata) === null || _fragmentNode$metadat2 === void 0 ? void 0 : _fragmentNode$metadat2.connection) !== null && _fragmentNode$metadat !== void 0 ? _fragmentNode$metadat : [])[0];\n  !(connectionMetadata != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: getPaginationMetadata(): Expected fragment `%s` to include a ' + 'connection when using `%s`. Did you forget to add a @connection ' + 'directive to the connection field in the fragment?', componentDisplayName, fragmentNode.name) : invariant(false) : void 0;\n  var identifierField = refetchMetadata.identifierField;\n  !(identifierField == null || typeof identifierField === 'string') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: getRefetchMetadata(): Expected `identifierField` to be a string.') : invariant(false) : void 0;\n  return {\n    connectionPathInFragmentData: connectionPathInFragmentData,\n    identifierField: identifierField,\n    paginationRequest: paginationRequest,\n    paginationMetadata: paginationMetadata,\n    stream: connectionMetadata.stream === true\n  };\n}\n\nmodule.exports = getPaginationMetadata;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar ProfilerContext = require('./ProfilerContext');\n\nvar getRefetchMetadata = require('./getRefetchMetadata');\n\nvar getValueAtPath = require('./getValueAtPath');\n\nvar invariant = require('invariant');\n\nvar useFragmentNode = require('./useFragmentNode');\n\nvar useIsMountedRef = require('./useIsMountedRef');\n\nvar useQueryLoader = require('./useQueryLoader');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('./FragmentResource'),\n    getFragmentResourceForEnvironment = _require.getFragmentResourceForEnvironment;\n\nvar _require2 = require('./QueryResource'),\n    getQueryResourceForEnvironment = _require2.getQueryResourceForEnvironment;\n\nvar _require3 = require('react'),\n    useCallback = _require3.useCallback,\n    useContext = _require3.useContext,\n    useReducer = _require3.useReducer;\n\nvar _require4 = require('relay-runtime'),\n    fetchQuery = _require4.__internal.fetchQuery,\n    createOperationDescriptor = _require4.createOperationDescriptor,\n    getFragmentIdentifier = _require4.getFragmentIdentifier,\n    getSelector = _require4.getSelector;\n\nfunction reducer(state, action) {\n  switch (action.type) {\n    case 'refetch':\n      {\n        var _action$refetchEnviro;\n\n        return (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, state), {}, {\n          fetchPolicy: action.fetchPolicy,\n          mirroredEnvironment: (_action$refetchEnviro = action.refetchEnvironment) !== null && _action$refetchEnviro !== void 0 ? _action$refetchEnviro : state.mirroredEnvironment,\n          onComplete: action.onComplete,\n          refetchEnvironment: action.refetchEnvironment,\n          refetchQuery: action.refetchQuery,\n          renderPolicy: action.renderPolicy\n        });\n      }\n\n    case 'reset':\n      {\n        return {\n          fetchPolicy: undefined,\n          mirroredEnvironment: action.environment,\n          mirroredFragmentIdentifier: action.fragmentIdentifier,\n          onComplete: undefined,\n          refetchQuery: null,\n          renderPolicy: undefined\n        };\n      }\n\n    default:\n      {\n        action.type;\n        throw new Error('useRefetchableFragmentNode: Unexpected action type');\n      }\n  }\n}\n\nfunction useRefetchableFragmentNode(fragmentNode, parentFragmentRef, componentDisplayName) {\n  var parentEnvironment = useRelayEnvironment();\n\n  var _getRefetchMetadata = getRefetchMetadata(fragmentNode, componentDisplayName),\n      refetchableRequest = _getRefetchMetadata.refetchableRequest,\n      fragmentRefPathInResponse = _getRefetchMetadata.fragmentRefPathInResponse,\n      identifierField = _getRefetchMetadata.identifierField;\n\n  var fragmentIdentifier = getFragmentIdentifier(fragmentNode, parentFragmentRef);\n\n  var _useReducer = useReducer(reducer, {\n    fetchPolicy: undefined,\n    mirroredEnvironment: parentEnvironment,\n    mirroredFragmentIdentifier: fragmentIdentifier,\n    onComplete: undefined,\n    refetchEnvironment: null,\n    refetchQuery: null,\n    renderPolicy: undefined\n  }),\n      refetchState = _useReducer[0],\n      dispatch = _useReducer[1];\n\n  var fetchPolicy = refetchState.fetchPolicy,\n      mirroredEnvironment = refetchState.mirroredEnvironment,\n      mirroredFragmentIdentifier = refetchState.mirroredFragmentIdentifier,\n      onComplete = refetchState.onComplete,\n      refetchEnvironment = refetchState.refetchEnvironment,\n      refetchQuery = refetchState.refetchQuery,\n      renderPolicy = refetchState.renderPolicy;\n  var environment = refetchEnvironment !== null && refetchEnvironment !== void 0 ? refetchEnvironment : parentEnvironment;\n  var QueryResource = getQueryResourceForEnvironment(environment);\n  var FragmentResource = getFragmentResourceForEnvironment(environment);\n  var profilerContext = useContext(ProfilerContext);\n  var shouldReset = environment !== mirroredEnvironment || fragmentIdentifier !== mirroredFragmentIdentifier;\n\n  var _useQueryLoader = useQueryLoader(refetchableRequest),\n      queryRef = _useQueryLoader[0],\n      loadQuery = _useQueryLoader[1],\n      disposeQuery = _useQueryLoader[2];\n\n  var fragmentRef = parentFragmentRef;\n\n  if (shouldReset) {\n    dispatch({\n      type: 'reset',\n      environment: environment,\n      fragmentIdentifier: fragmentIdentifier\n    });\n    disposeQuery();\n  } else if (refetchQuery != null && queryRef != null) {\n    // If refetch was called, we expect to have a refetchQuery and queryRef\n    // in state, since both state updates to set the refetchQuery and the\n    // queryRef occur simultaneously.\n    // In this case, we need to read the refetched query data (potentially\n    // suspending if it's in flight), and extract the new fragment ref\n    // from the query in order read the current @refetchable fragment\n    // with the updated fragment owner as the new refetchQuery.\n    // Before observing the refetch, record the current ID and typename\n    // so that, if we are refetching existing data on\n    // a field that implements Node, after refetching we\n    // can validate that the received data is consistent\n    var debugPreviousIDAndTypename;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      debugPreviousIDAndTypename = debugFunctions.getInitialIDAndType(refetchQuery.request.variables, fragmentRefPathInResponse, environment);\n    }\n\n    var handleQueryCompleted = function handleQueryCompleted(maybeError) {\n      onComplete && onComplete(maybeError !== null && maybeError !== void 0 ? maybeError : null);\n    }; // The queryRef.source obtained from useQueryLoader will be\n    // an observable we can consume /if/ a network request was\n    // started. Otherwise, given that QueryResource.prepare\n    // always expects an observable we fall back to a new network\n    // observable. Note however that if loadQuery did not make a network\n    // request, we don't expect to make one here, unless the state of\n    // the cache has changed between the call to refetch and this\n    // render.\n\n\n    var fetchObservable = queryRef.source != null ? queryRef.source : fetchQuery(environment, refetchQuery); // Now wwe can we read the refetch query here using the\n    // queryRef provided from useQueryLoader. Note that the\n    // network request is started during the call to refetch,\n    // but if the refetch query is still in flight, we will suspend\n    // at this point:\n\n    var queryResult = profilerContext.wrapPrepareQueryResource(function () {\n      return QueryResource.prepare(refetchQuery, fetchObservable, fetchPolicy, renderPolicy, {\n        error: handleQueryCompleted,\n        complete: function complete() {\n          // Validate that the type of the object we got back matches the type\n          // of the object already in the store\n          if (process.env.NODE_ENV !== \"production\") {\n            debugFunctions.checkSameTypeAfterRefetch(debugPreviousIDAndTypename, environment, fragmentNode, componentDisplayName);\n          }\n\n          handleQueryCompleted();\n        }\n      }, queryRef.fetchKey, profilerContext);\n    });\n    var queryData = FragmentResource.read(queryResult.fragmentNode, queryResult.fragmentRef, componentDisplayName).data;\n    !(queryData != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected to be able to read refetch query response. ' + \"If you're seeing this, this is likely a bug in Relay.\") : invariant(false) : void 0; // After reading/fetching the refetch query, we extract from the\n    // refetch query response the new fragment ref we need to use to read\n    // the fragment. The new fragment ref will point to the refetch query\n    // as its fragment owner.\n\n    var refetchedFragmentRef = getValueAtPath(queryData, fragmentRefPathInResponse);\n    fragmentRef = refetchedFragmentRef;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      // Validate that the id of the object we got back matches the id\n      // we queried for in the variables.\n      // We do this during render instead of onComplete to make sure we are\n      // only validating the most recent refetch.\n      debugFunctions.checkSameIDAfterRefetch(debugPreviousIDAndTypename, fragmentRef, fragmentNode, componentDisplayName);\n    }\n  } // We read and subscribe to the fragment using useFragmentNode.\n  // If refetch was called, we read the fragment using the new computed\n  // fragment ref from the refetch query response; otherwise, we use the\n  // fragment ref passed by the caller as normal.\n\n\n  var _useFragmentNode = useFragmentNode(fragmentNode, fragmentRef, componentDisplayName),\n      fragmentData = _useFragmentNode.data,\n      disableStoreUpdates = _useFragmentNode.disableStoreUpdates,\n      enableStoreUpdates = _useFragmentNode.enableStoreUpdates;\n\n  var refetch = useRefetchFunction(componentDisplayName, dispatch, disposeQuery, fragmentData, fragmentIdentifier, fragmentNode, fragmentRefPathInResponse, identifierField, loadQuery, parentFragmentRef, refetchableRequest);\n  return {\n    fragmentData: fragmentData,\n    fragmentRef: fragmentRef,\n    refetch: refetch,\n    disableStoreUpdates: disableStoreUpdates,\n    enableStoreUpdates: enableStoreUpdates\n  };\n}\n\nfunction useRefetchFunction(componentDisplayName, dispatch, disposeQuery, fragmentData, fragmentIdentifier, fragmentNode, fragmentRefPathInResponse, identifierField, loadQuery, parentFragmentRef, refetchableRequest) {\n  var isMountedRef = useIsMountedRef();\n  var identifierValue = identifierField != null && fragmentData != null && typeof fragmentData === 'object' ? fragmentData[identifierField] : null;\n  return useCallback(function (providedRefetchVariables, options) {\n    // Bail out and warn if we're trying to refetch after the component\n    // has unmounted\n    if (isMountedRef.current !== true) {\n      process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Unexpected call to `refetch` on unmounted component for fragment ' + '`%s` in `%s`. It looks like some instances of your component are ' + 'still trying to fetch data but they already unmounted. ' + 'Please make sure you clear all timers, intervals, ' + 'async calls, etc that may trigger a fetch.', fragmentNode.name, componentDisplayName) : void 0;\n      return {\n        dispose: function dispose() {}\n      };\n    }\n\n    if (parentFragmentRef == null) {\n      process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Unexpected call to `refetch` while using a null fragment ref ' + 'for fragment `%s` in `%s`. When calling `refetch`, we expect ' + \"initial fragment data to be non-null. Please make sure you're \" + 'passing a valid fragment ref to `%s` before calling ' + '`refetch`, or make sure you pass all required variables to `refetch`.', fragmentNode.name, componentDisplayName, componentDisplayName) : void 0;\n    }\n\n    var refetchEnvironment = options === null || options === void 0 ? void 0 : options.__environment;\n    var fetchPolicy = options === null || options === void 0 ? void 0 : options.fetchPolicy;\n    var renderPolicy = options === null || options === void 0 ? void 0 : options.UNSTABLE_renderPolicy;\n    var onComplete = options === null || options === void 0 ? void 0 : options.onComplete;\n    var fragmentSelector = getSelector(fragmentNode, parentFragmentRef);\n    var parentVariables;\n    var fragmentVariables;\n\n    if (fragmentSelector == null) {\n      parentVariables = {};\n      fragmentVariables = {};\n    } else if (fragmentSelector.kind === 'PluralReaderSelector') {\n      var _fragmentSelector$sel, _fragmentSelector$sel2, _fragmentSelector$sel3, _fragmentSelector$sel4;\n\n      parentVariables = (_fragmentSelector$sel = (_fragmentSelector$sel2 = fragmentSelector.selectors[0]) === null || _fragmentSelector$sel2 === void 0 ? void 0 : _fragmentSelector$sel2.owner.variables) !== null && _fragmentSelector$sel !== void 0 ? _fragmentSelector$sel : {};\n      fragmentVariables = (_fragmentSelector$sel3 = (_fragmentSelector$sel4 = fragmentSelector.selectors[0]) === null || _fragmentSelector$sel4 === void 0 ? void 0 : _fragmentSelector$sel4.variables) !== null && _fragmentSelector$sel3 !== void 0 ? _fragmentSelector$sel3 : {};\n    } else {\n      parentVariables = fragmentSelector.owner.variables;\n      fragmentVariables = fragmentSelector.variables;\n    } // A user of `useRefetchableFragment()` may pass a subset of\n    // all variables required by the fragment when calling `refetch()`.\n    // We fill in any variables not passed by the call to `refetch()` with the\n    // variables from the original parent fragment owner.\n    // $FlowFixMe[cannot-spread-interface]\n\n\n    var refetchVariables = (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, parentVariables), fragmentVariables), providedRefetchVariables); // If the query needs an identifier value ('id' or similar) and one\n    // was not explicitly provided, read it from the fragment data.\n\n    if (identifierField != null && !providedRefetchVariables.hasOwnProperty('id')) {\n      // @refetchable fragments are guaranteed to have an `id` selection\n      // if the type is Node, implements Node, or is @fetchable. Double-check\n      // that there actually is a value at runtime.\n      if (typeof identifierValue !== 'string') {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Expected result to have a string  ' + '`%s` in order to refetch, got `%s`.', identifierField, identifierValue) : void 0;\n      }\n\n      refetchVariables.id = identifierValue;\n    }\n\n    var refetchQuery = createOperationDescriptor(refetchableRequest, refetchVariables, {\n      force: true\n    }); // We call loadQuery which will start a network request if necessary\n    // and update the querRef from useQueryLoader.\n    // Note the following:\n    // - loadQuery will dispose of any previously refetched queries.\n    // - We use the variables extracted off the OperationDescriptor\n    // so that they have been filtered out to include only the\n    // variables actually declared in the query.\n\n    loadQuery(refetchQuery.request.variables, {\n      fetchPolicy: fetchPolicy,\n      __environment: refetchEnvironment,\n      __nameForWarning: 'refetch'\n    });\n    dispatch({\n      type: 'refetch',\n      fetchPolicy: fetchPolicy,\n      onComplete: onComplete,\n      refetchEnvironment: refetchEnvironment,\n      refetchQuery: refetchQuery,\n      renderPolicy: renderPolicy\n    });\n    return {\n      dispose: disposeQuery\n    };\n  }, // NOTE: We disable react-hooks-deps warning because:\n  //   - We know fragmentRefPathInResponse is static, so it can be omitted from\n  //     deps\n  //   - We know fragmentNode is static, so it can be omitted from deps.\n  //   - fragmentNode and parentFragmentRef are also captured by including\n  //     fragmentIdentifier\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [fragmentIdentifier, dispatch, disposeQuery, identifierValue]);\n}\n\nvar debugFunctions;\n\nif (process.env.NODE_ENV !== \"production\") {\n  debugFunctions = {\n    getInitialIDAndType: function getInitialIDAndType(memoRefetchVariables, fragmentRefPathInResponse, environment) {\n      var _require5 = require('relay-runtime'),\n          Record = _require5.Record; // $FlowFixMe[prop-missing]\n\n\n      var id = memoRefetchVariables === null || memoRefetchVariables === void 0 ? void 0 : memoRefetchVariables.id;\n\n      if (fragmentRefPathInResponse.length !== 1 || fragmentRefPathInResponse[0] !== 'node' || id == null) {\n        return null;\n      }\n\n      var recordSource = environment.getStore().getSource();\n      var record = recordSource.get(id);\n      var typename = record && Record.getType(record);\n\n      if (typename == null) {\n        return null;\n      }\n\n      return {\n        id: id,\n        typename: typename\n      };\n    },\n    checkSameTypeAfterRefetch: function checkSameTypeAfterRefetch(previousIDAndType, environment, fragmentNode, componentDisplayName) {\n      var _require6 = require('relay-runtime'),\n          Record = _require6.Record;\n\n      if (!previousIDAndType) {\n        return;\n      }\n\n      var recordSource = environment.getStore().getSource();\n      var record = recordSource.get(previousIDAndType.id);\n      var typename = record && Record.getType(record);\n\n      if (typename !== previousIDAndType.typename) {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Call to `refetch` returned data with a different ' + '__typename: was `%s`, now `%s`, on `%s` in `%s`. ' + 'Please make sure the server correctly implements' + 'unique id requirement.', previousIDAndType.typename, typename, fragmentNode.name, componentDisplayName) : void 0;\n      }\n    },\n    checkSameIDAfterRefetch: function checkSameIDAfterRefetch(previousIDAndTypename, refetchedFragmentRef, fragmentNode, componentDisplayName) {\n      if (previousIDAndTypename == null) {\n        return;\n      }\n\n      var _require7 = require('relay-runtime'),\n          ID_KEY = _require7.ID_KEY; // $FlowExpectedError[incompatible-use]\n\n\n      var resultID = refetchedFragmentRef[ID_KEY];\n\n      if (resultID != null && resultID !== previousIDAndTypename.id) {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Call to `refetch` returned a different id, expected ' + '`%s`, got `%s`, on `%s` in `%s`. ' + 'Please make sure the server correctly implements ' + 'unique id requirement.', resultID, previousIDAndTypename.id, fragmentNode.name, componentDisplayName) : void 0;\n      }\n    }\n  };\n}\n\nmodule.exports = useRefetchableFragmentNode;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar React = require('react');\n\nvar ReactRelayContext = require('react-relay/ReactRelayContext');\n\nvar useMemo = React.useMemo;\n\nfunction RelayEnvironmentProvider(props) {\n  var children = props.children,\n      environment = props.environment;\n  var context = useMemo(function () {\n    return {\n      environment: environment\n    };\n  }, [environment]);\n  return /*#__PURE__*/React.createElement(ReactRelayContext.Provider, {\n    value: context\n  }, children);\n}\n\nmodule.exports = RelayEnvironmentProvider;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar React = require('react');\n\nmodule.exports = React.createContext({\n  rootIsQueryRenderer: false\n});","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar invariant = require('invariant');\n\nfunction getValueAtPath(data, path) {\n  var result = data;\n\n  var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(path),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var key = _step.value;\n\n      if (result == null) {\n        return null;\n      }\n\n      if (typeof key === 'number') {\n        !Array.isArray(result) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected an array when extracting value at path. ' + \"If you're seeing this, this is likely a bug in Relay.\") : invariant(false) : void 0;\n        result = result[key];\n      } else {\n        !(typeof result === 'object' && !Array.isArray(result)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected an object when extracting value at path. ' + \"If you're seeing this, this is likely a bug in Relay.\") : invariant(false) : void 0;\n        result = result[key];\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return result;\n}\n\nmodule.exports = getValueAtPath;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar invariant = require('invariant');\n\nfunction getRefetchMetadata(fragmentNode, componentDisplayName) {\n  var _fragmentNode$metadat, _fragmentNode$metadat2;\n\n  !(((_fragmentNode$metadat = fragmentNode.metadata) === null || _fragmentNode$metadat === void 0 ? void 0 : _fragmentNode$metadat.plural) !== true) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: getRefetchMetadata(): Expected fragment `%s` not to be plural when using ' + '`%s`. Remove `@relay(plural: true)` from fragment `%s` ' + 'in order to use it with `%s`.', fragmentNode.name, componentDisplayName, fragmentNode.name, componentDisplayName) : invariant(false) : void 0;\n  var refetchMetadata = (_fragmentNode$metadat2 = fragmentNode.metadata) === null || _fragmentNode$metadat2 === void 0 ? void 0 : _fragmentNode$metadat2.refetch;\n  !(refetchMetadata != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: getRefetchMetadata(): Expected fragment `%s` to be refetchable when using `%s`. ' + 'Did you forget to add a @refetchable directive to the fragment?', componentDisplayName, fragmentNode.name) : invariant(false) : void 0; // handle both commonjs and es modules\n\n  var refetchableRequest = refetchMetadata.operation[\"default\"] ? refetchMetadata.operation[\"default\"] : refetchMetadata.operation;\n  var fragmentRefPathInResponse = refetchMetadata.fragmentPathInResult;\n  !(typeof refetchableRequest !== 'string') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: getRefetchMetadata(): Expected refetch query to be an ' + \"operation and not a string when using `%s`. If you're seeing this, \" + 'this is likely a bug in Relay.', componentDisplayName) : invariant(false) : void 0;\n  var identifierField = refetchMetadata.identifierField;\n  !(identifierField == null || typeof identifierField === 'string') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: getRefetchMetadata(): Expected `identifierField` to be a string.') : invariant(false) : void 0;\n  return {\n    fragmentRefPathInResponse: fragmentRefPathInResponse,\n    identifierField: identifierField,\n    refetchableRequest: refetchableRequest,\n    refetchMetadata: refetchMetadata\n  };\n}\n\nmodule.exports = getRefetchMetadata;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar _objectSpread4 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nfunction getPaginationVariables(direction, count, cursor, baseVariables, extraVariables, paginationMetadata) {\n  var _objectSpread3;\n\n  var backwardMetadata = paginationMetadata.backward,\n      forwardMetadata = paginationMetadata.forward;\n\n  if (direction === 'backward') {\n    var _objectSpread2;\n\n    !(backwardMetadata != null && backwardMetadata.count != null && backwardMetadata.cursor != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected backward pagination metadata to be available. ' + \"If you're seeing this, this is likely a bug in Relay.\") : invariant(false) : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!extraVariables.hasOwnProperty(backwardMetadata.cursor), 'Relay: `UNSTABLE_extraVariables` provided by caller should not ' + 'contain cursor variable `%s`. This variable is automatically ' + 'determined by Relay.', backwardMetadata.cursor) : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!extraVariables.hasOwnProperty(backwardMetadata.count), 'Relay: `UNSTABLE_extraVariables` provided by caller should not ' + 'contain count variable `%s`. This variable is automatically ' + 'determined by Relay.', backwardMetadata.count) : void 0; // $FlowFixMe[cannot-spread-interface]\n\n    var _paginationVariables = (0, _objectSpread4[\"default\"])((0, _objectSpread4[\"default\"])((0, _objectSpread4[\"default\"])({}, baseVariables), extraVariables), {}, (_objectSpread2 = {}, (0, _defineProperty2[\"default\"])(_objectSpread2, backwardMetadata.cursor, cursor), (0, _defineProperty2[\"default\"])(_objectSpread2, backwardMetadata.count, count), _objectSpread2));\n\n    if (forwardMetadata && forwardMetadata.cursor) {\n      _paginationVariables[forwardMetadata.cursor] = null;\n    }\n\n    if (forwardMetadata && forwardMetadata.count) {\n      _paginationVariables[forwardMetadata.count] = null;\n    }\n\n    return _paginationVariables;\n  }\n\n  !(forwardMetadata != null && forwardMetadata.count != null && forwardMetadata.cursor != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected forward pagination metadata to be available. ' + \"If you're seeing this, this is likely a bug in Relay.\") : invariant(false) : void 0;\n  process.env.NODE_ENV !== \"production\" ? warning(!extraVariables.hasOwnProperty(forwardMetadata.cursor), 'Relay: `UNSTABLE_extraVariables` provided by caller should not ' + 'contain cursor variable `%s`. This variable is automatically ' + 'determined by Relay.', forwardMetadata.cursor) : void 0;\n  process.env.NODE_ENV !== \"production\" ? warning(!extraVariables.hasOwnProperty(forwardMetadata.count), 'Relay: `UNSTABLE_extraVariables` provided by caller should not ' + 'contain count variable `%s`. This variable is automatically ' + 'determined by Relay.', forwardMetadata.count) : void 0; // $FlowFixMe[cannot-spread-interface]\n\n  var paginationVariables = (0, _objectSpread4[\"default\"])((0, _objectSpread4[\"default\"])((0, _objectSpread4[\"default\"])({}, baseVariables), extraVariables), {}, (_objectSpread3 = {}, (0, _defineProperty2[\"default\"])(_objectSpread3, forwardMetadata.cursor, cursor), (0, _defineProperty2[\"default\"])(_objectSpread3, forwardMetadata.count, count), _objectSpread3));\n\n  if (backwardMetadata && backwardMetadata.cursor) {\n    paginationVariables[backwardMetadata.cursor] = null;\n  }\n\n  if (backwardMetadata && backwardMetadata.count) {\n    paginationVariables[backwardMetadata.count] = null;\n  }\n\n  return paginationVariables;\n}\n\nmodule.exports = getPaginationVariables;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar React = require('react');\n\nvar _React$__SECRET_INTER =\n/* $FlowFixMe[prop-missing] Flow doesn't know about React's internals for\n * good reason, but for now, Relay needs the dispatcher to read context. */\nReact.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,\n    ReactCurrentDispatcher = _React$__SECRET_INTER.ReactCurrentDispatcher,\n    ReactCurrentOwner = _React$__SECRET_INTER.ReactCurrentOwner;\n\nfunction readContext(Context) {\n  var dispatcher = ReactCurrentDispatcher != null ? ReactCurrentDispatcher.current : ReactCurrentOwner.currentDispatcher;\n  return dispatcher.readContext(Context);\n}\n\nmodule.exports = readContext;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n'use strict';\n\nvar React = require('react');\n\nvar invariant = require('invariant');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar _require = require('relay-runtime'),\n    getObservableForActiveRequest = _require.__internal.getObservableForActiveRequest,\n    getSelector = _require.getSelector;\n\nvar useEffect = React.useEffect,\n    useState = React.useState,\n    useMemo = React.useMemo;\n\nfunction useIsOperationNodeActive(fragmentNode, fragmentRef) {\n  var environment = useRelayEnvironment();\n  var observable = useMemo(function () {\n    var selector = getSelector(fragmentNode, fragmentRef);\n\n    if (selector == null) {\n      return null;\n    }\n\n    !(selector.kind === 'SingularReaderSelector') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'useIsOperationNodeActive: Plural fragments are not supported.') : invariant(false) : void 0;\n    return getObservableForActiveRequest(environment, selector.owner);\n  }, [environment, fragmentNode, fragmentRef]);\n\n  var _useState = useState(observable != null),\n      isActive = _useState[0],\n      setIsActive = _useState[1];\n\n  useEffect(function () {\n    var subscription;\n    setIsActive(observable != null);\n\n    if (observable != null) {\n      var onCompleteOrError = function onCompleteOrError() {\n        setIsActive(false);\n      };\n\n      subscription = observable.subscribe({\n        complete: onCompleteOrError,\n        error: onCompleteOrError\n      });\n    }\n\n    return function () {\n      if (subscription) {\n        subscription.unsubscribe();\n      }\n    };\n  }, [observable]);\n  return isActive;\n}\n\nmodule.exports = useIsOperationNodeActive;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar ReactRelayContext = require('react-relay/ReactRelayContext');\n\nvar invariant = require('invariant');\n\nvar _require = require('react'),\n    useContext = _require.useContext;\n\nfunction useRelayEnvironment() {\n  var context = useContext(ReactRelayContext);\n  !(context != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'useRelayEnvironment: Expected to have found a Relay environment provided by ' + 'a `RelayEnvironmentProvider` component. ' + 'This usually means that useRelayEnvironment was used in a ' + 'component that is not a descendant of a `RelayEnvironmentProvider`. ' + 'Please make sure a `RelayEnvironmentProvider` has been rendered somewhere ' + 'as a parent or ancestor of your component.') : invariant(false) : void 0;\n  return context.environment;\n}\n\nmodule.exports = useRelayEnvironment;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('react'),\n    useRef = _require.useRef;\n\nfunction useStaticFragmentNodeWarning(fragmentNode, warningContext) {\n  if (process.env.NODE_ENV !== \"production\") {\n    // This is calling `useRef` conditionally, but based on the environment\n    // __DEV__ setting which shouldn't change. This allows us to only pay the\n    // cost of `useRef` in development mode to produce the warning.\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    var initialPropRef = useRef(fragmentNode.name);\n    process.env.NODE_ENV !== \"production\" ? warning(initialPropRef.current === fragmentNode.name, 'Relay: The %s has to remain the same over the lifetime of a component. ' + 'Changing it is not supported and will result in unexpected behavior.', warningContext) : void 0;\n  }\n}\n\nmodule.exports = useStaticFragmentNodeWarning;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('./FragmentResource'),\n    getFragmentResourceForEnvironment = _require.getFragmentResourceForEnvironment;\n\nvar _require2 = require('react'),\n    useEffect = _require2.useEffect,\n    useRef = _require2.useRef,\n    useState = _require2.useState;\n\nvar _require3 = require('relay-runtime'),\n    getFragmentIdentifier = _require3.getFragmentIdentifier;\n\nfunction useFragmentNode(fragmentNode, fragmentRef, componentDisplayName) {\n  var environment = useRelayEnvironment();\n  var FragmentResource = getFragmentResourceForEnvironment(environment);\n  var isMountedRef = useRef(false);\n\n  var _useState = useState(0),\n      forceUpdate = _useState[1];\n\n  var fragmentIdentifier = getFragmentIdentifier(fragmentNode, fragmentRef); // Read fragment data; this might suspend.\n\n  var fragmentResult = FragmentResource.readWithIdentifier(fragmentNode, fragmentRef, fragmentIdentifier, componentDisplayName);\n  var isListeningForUpdatesRef = useRef(true);\n\n  function enableStoreUpdates() {\n    isListeningForUpdatesRef.current = true;\n    var didMissUpdates = FragmentResource.checkMissedUpdates(fragmentResult)[0];\n\n    if (didMissUpdates) {\n      handleDataUpdate();\n    }\n  }\n\n  function disableStoreUpdates() {\n    isListeningForUpdatesRef.current = false;\n  }\n\n  function handleDataUpdate() {\n    if (isMountedRef.current === false || isListeningForUpdatesRef.current === false) {\n      return;\n    } // React bails out on noop state updates as an optimization.\n    // If we want to force an update via setState, we need to pass an value.\n    // The actual value can be arbitrary though, e.g. an incremented number.\n\n\n    forceUpdate(function (count) {\n      return count + 1;\n    });\n  } // Establish Relay store subscriptions in the commit phase, only if\n  // rendering for the first time, or if we need to subscribe to new data\n  // If the fragment identifier changes, it means that the variables on the\n  // fragment owner changed, or the fragment ref points to different records.\n  // In this case, we need to resubscribe to the Relay store.\n\n\n  useEffect(function () {\n    isMountedRef.current = true;\n    var disposable = FragmentResource.subscribe(fragmentResult, handleDataUpdate);\n    return function () {\n      // When unmounting or resubscribing to new data, clean up current\n      // subscription. This will also make sure fragment data is no longer\n      // cached so that next time it its read, it will be freshly read from\n      // the Relay store\n      isMountedRef.current = false;\n      disposable.dispose();\n    }; // NOTE: We disable react-hooks-deps warning because environment and fragmentIdentifier\n    // is capturing all information about whether the effect should be re-ran.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [environment, fragmentIdentifier]);\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (fragmentRef != null && (fragmentResult.data === undefined || Array.isArray(fragmentResult.data) && fragmentResult.data.length > 0 && fragmentResult.data.every(function (data) {\n      return data === undefined;\n    }))) {\n      process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Expected to have been able to read non-null data for ' + 'fragment `%s` declared in ' + '`%s`, since fragment reference was non-null. ' + \"Make sure that that `%s`'s parent isn't \" + 'holding on to and/or passing a fragment reference for data that ' + 'has been deleted.', fragmentNode.name, componentDisplayName, componentDisplayName) : void 0;\n    }\n  }\n\n  return {\n    // $FlowFixMe[incompatible-return]\n    data: fragmentResult.data,\n    disableStoreUpdates: disableStoreUpdates,\n    enableStoreUpdates: enableStoreUpdates\n  };\n}\n\nmodule.exports = useFragmentNode;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar _inheritsLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inheritsLoose\"));\n\nvar React = require('react');\n\nvar ReactRelayContext = require('./ReactRelayContext');\n\nvar ReactRelayQueryFetcher = require('./ReactRelayQueryFetcher');\n\nvar ReactRelayQueryRendererContext = require('./ReactRelayQueryRendererContext');\n\nvar areEqual = require(\"fbjs/lib/areEqual\");\n\nvar _require = require('relay-runtime'),\n    createOperationDescriptor = _require.createOperationDescriptor,\n    deepFreeze = _require.deepFreeze,\n    getRequest = _require.getRequest;\n\n/**\n * React may double-fire the constructor, and we call 'fetch' in the\n * constructor. If a request is already in flight from a previous call to the\n * constructor, just reuse the query fetcher and wait for the response.\n */\nvar requestCache = {};\nvar queryRendererContext = {\n  rootIsQueryRenderer: true\n};\n\n/**\n * @public\n *\n * Orchestrates fetching and rendering data for a single view or view hierarchy:\n * - Fetches the query/variables using the given network implementation.\n * - Normalizes the response(s) to that query, publishing them to the given\n *   store.\n * - Renders the pending/fail/success states with the provided render function.\n * - Subscribes for updates to the root data and re-renders with any changes.\n */\nvar ReactRelayQueryRenderer = /*#__PURE__*/function (_React$Component) {\n  (0, _inheritsLoose2[\"default\"])(ReactRelayQueryRenderer, _React$Component);\n\n  function ReactRelayQueryRenderer(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this; // Callbacks are attached to the current instance and shared with static\n    // lifecyles by bundling with state. This is okay to do because the\n    // callbacks don't change in reaction to props. However we should not\n    // \"leak\" them before mounting (since we would be unable to clean up). For\n    // that reason, we define them as null initially and fill them in after\n    // mounting to avoid leaking memory.\n\n    var retryCallbacks = {\n      handleDataChange: null,\n      handleRetryAfterError: null\n    };\n    var queryFetcher;\n    var requestCacheKey;\n\n    if (props.query) {\n      var query = props.query;\n      var request = getRequest(query);\n      requestCacheKey = getRequestCacheKey(request.params, props.variables);\n      queryFetcher = requestCache[requestCacheKey] ? requestCache[requestCacheKey].queryFetcher : new ReactRelayQueryFetcher();\n    } else {\n      queryFetcher = new ReactRelayQueryFetcher();\n    }\n\n    _this.state = (0, _objectSpread2[\"default\"])({\n      prevPropsEnvironment: props.environment,\n      prevPropsVariables: props.variables,\n      prevQuery: props.query,\n      queryFetcher: queryFetcher,\n      retryCallbacks: retryCallbacks\n    }, fetchQueryAndComputeStateFromProps(props, queryFetcher, retryCallbacks, requestCacheKey));\n    return _this;\n  }\n\n  ReactRelayQueryRenderer.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {\n    if (prevState.prevQuery !== nextProps.query || prevState.prevPropsEnvironment !== nextProps.environment || !areEqual(prevState.prevPropsVariables, nextProps.variables)) {\n      var query = nextProps.query;\n      var prevSelectionReferences = prevState.queryFetcher.getSelectionReferences();\n      prevState.queryFetcher.disposeRequest();\n      var queryFetcher;\n\n      if (query) {\n        var request = getRequest(query);\n        var requestCacheKey = getRequestCacheKey(request.params, nextProps.variables);\n        queryFetcher = requestCache[requestCacheKey] ? requestCache[requestCacheKey].queryFetcher : new ReactRelayQueryFetcher(prevSelectionReferences);\n      } else {\n        queryFetcher = new ReactRelayQueryFetcher(prevSelectionReferences);\n      }\n\n      return (0, _objectSpread2[\"default\"])({\n        prevQuery: nextProps.query,\n        prevPropsEnvironment: nextProps.environment,\n        prevPropsVariables: nextProps.variables,\n        queryFetcher: queryFetcher\n      }, fetchQueryAndComputeStateFromProps(nextProps, queryFetcher, prevState.retryCallbacks // passing no requestCacheKey will cause it to be recalculated internally\n      // and we want the updated requestCacheKey, since variables may have changed\n      ));\n    }\n\n    return null;\n  };\n\n  var _proto = ReactRelayQueryRenderer.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    var _this2 = this;\n\n    var _this$state = this.state,\n        retryCallbacks = _this$state.retryCallbacks,\n        queryFetcher = _this$state.queryFetcher,\n        requestCacheKey = _this$state.requestCacheKey;\n\n    if (requestCacheKey) {\n      delete requestCache[requestCacheKey];\n    }\n\n    retryCallbacks.handleDataChange = function (params) {\n      var error = params.error == null ? null : params.error;\n      var snapshot = params.snapshot == null ? null : params.snapshot;\n\n      _this2.setState(function (prevState) {\n        var prevRequestCacheKey = prevState.requestCacheKey;\n\n        if (prevRequestCacheKey) {\n          delete requestCache[prevRequestCacheKey];\n        } // Don't update state if nothing has changed.\n\n\n        if (snapshot === prevState.snapshot && error === prevState.error) {\n          return null;\n        }\n\n        return {\n          renderProps: getRenderProps(error, snapshot, prevState.queryFetcher, prevState.retryCallbacks),\n          snapshot: snapshot,\n          requestCacheKey: null\n        };\n      });\n    };\n\n    retryCallbacks.handleRetryAfterError = function (error) {\n      return _this2.setState(function (prevState) {\n        var prevRequestCacheKey = prevState.requestCacheKey;\n\n        if (prevRequestCacheKey) {\n          delete requestCache[prevRequestCacheKey];\n        }\n\n        return {\n          renderProps: getLoadingRenderProps(),\n          requestCacheKey: null\n        };\n      });\n    }; // Re-initialize the ReactRelayQueryFetcher with callbacks.\n    // If data has changed since constructions, this will re-render.\n\n\n    if (this.props.query) {\n      queryFetcher.setOnDataChange(retryCallbacks.handleDataChange);\n    }\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate() {\n    // We don't need to cache the request after the component commits\n    var requestCacheKey = this.state.requestCacheKey;\n\n    if (requestCacheKey) {\n      delete requestCache[requestCacheKey]; // HACK\n\n      delete this.state.requestCacheKey;\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.state.queryFetcher.dispose();\n  };\n\n  _proto.shouldComponentUpdate = function shouldComponentUpdate(nextProps, nextState) {\n    return nextProps.render !== this.props.render || nextState.renderProps !== this.state.renderProps;\n  };\n\n  _proto.render = function render() {\n    var _this$state2 = this.state,\n        renderProps = _this$state2.renderProps,\n        relayContext = _this$state2.relayContext; // Note that the root fragment results in `renderProps.props` is already\n    // frozen by the store; this call is to freeze the renderProps object and\n    // error property if set.\n\n    if (process.env.NODE_ENV !== \"production\") {\n      deepFreeze(renderProps);\n    }\n\n    return /*#__PURE__*/React.createElement(ReactRelayContext.Provider, {\n      value: relayContext\n    }, /*#__PURE__*/React.createElement(ReactRelayQueryRendererContext.Provider, {\n      value: queryRendererContext\n    }, this.props.render(renderProps)));\n  };\n\n  return ReactRelayQueryRenderer;\n}(React.Component);\n\nfunction getLoadingRenderProps() {\n  return {\n    error: null,\n    props: null,\n    // `props: null` indicates that the data is being fetched (i.e. loading)\n    retry: null\n  };\n}\n\nfunction getEmptyRenderProps() {\n  return {\n    error: null,\n    props: {},\n    // `props: {}` indicates no data available\n    retry: null\n  };\n}\n\nfunction getRenderProps(error, snapshot, queryFetcher, retryCallbacks) {\n  return {\n    error: error ? error : null,\n    props: snapshot ? snapshot.data : null,\n    retry: function retry(cacheConfigOverride) {\n      var syncSnapshot = queryFetcher.retry(cacheConfigOverride);\n\n      if (syncSnapshot && typeof retryCallbacks.handleDataChange === 'function') {\n        retryCallbacks.handleDataChange({\n          snapshot: syncSnapshot\n        });\n      } else if (error && typeof retryCallbacks.handleRetryAfterError === 'function') {\n        // If retrying after an error and no synchronous result available,\n        // reset the render props\n        retryCallbacks.handleRetryAfterError(error);\n      }\n    }\n  };\n}\n\nfunction getRequestCacheKey(request, variables) {\n  return JSON.stringify({\n    id: request.cacheID ? request.cacheID : request.id,\n    variables: variables\n  });\n}\n\nfunction fetchQueryAndComputeStateFromProps(props, queryFetcher, retryCallbacks, requestCacheKey) {\n  var environment = props.environment,\n      query = props.query,\n      variables = props.variables,\n      cacheConfig = props.cacheConfig;\n  var genericEnvironment = environment;\n\n  if (query) {\n    var request = getRequest(query);\n    var operation = createOperationDescriptor(request, variables, cacheConfig);\n    var relayContext = {\n      environment: genericEnvironment\n    };\n\n    if (typeof requestCacheKey === 'string' && requestCache[requestCacheKey]) {\n      // This same request is already in flight.\n      var snapshot = requestCache[requestCacheKey].snapshot;\n\n      if (snapshot) {\n        // Use the cached response\n        return {\n          error: null,\n          relayContext: relayContext,\n          renderProps: getRenderProps(null, snapshot, queryFetcher, retryCallbacks),\n          snapshot: snapshot,\n          requestCacheKey: requestCacheKey\n        };\n      } else {\n        // Render loading state\n        return {\n          error: null,\n          relayContext: relayContext,\n          renderProps: getLoadingRenderProps(),\n          snapshot: null,\n          requestCacheKey: requestCacheKey\n        };\n      }\n    }\n\n    try {\n      var storeSnapshot = queryFetcher.lookupInStore(genericEnvironment, operation, props.fetchPolicy);\n      var querySnapshot = queryFetcher.fetch({\n        environment: genericEnvironment,\n        onDataChange: retryCallbacks.handleDataChange,\n        operation: operation\n      }); // Use network data first, since it may be fresher\n\n      var _snapshot = querySnapshot || storeSnapshot; // cache the request to avoid duplicate requests\n\n\n      requestCacheKey = requestCacheKey || getRequestCacheKey(request.params, props.variables);\n      requestCache[requestCacheKey] = {\n        queryFetcher: queryFetcher,\n        snapshot: _snapshot\n      };\n\n      if (!_snapshot) {\n        return {\n          error: null,\n          relayContext: relayContext,\n          renderProps: getLoadingRenderProps(),\n          snapshot: null,\n          requestCacheKey: requestCacheKey\n        };\n      }\n\n      return {\n        error: null,\n        relayContext: relayContext,\n        renderProps: getRenderProps(null, _snapshot, queryFetcher, retryCallbacks),\n        snapshot: _snapshot,\n        requestCacheKey: requestCacheKey\n      };\n    } catch (error) {\n      return {\n        error: error,\n        relayContext: relayContext,\n        renderProps: getRenderProps(error, null, queryFetcher, retryCallbacks),\n        snapshot: null,\n        requestCacheKey: requestCacheKey\n      };\n    }\n  } else {\n    queryFetcher.dispose();\n    var _relayContext = {\n      environment: genericEnvironment\n    };\n    return {\n      error: null,\n      relayContext: _relayContext,\n      renderProps: getEmptyRenderProps(),\n      requestCacheKey: null // if there is an error, don't cache request\n\n    };\n  }\n}\n\nmodule.exports = ReactRelayQueryRenderer;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @emails oncall+relay\n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\n\nvar LRUCache = require('./LRUCache');\n\nvar invariant = require('invariant');\n\nvar _require = require('relay-runtime'),\n    getPromiseForActiveRequest = _require.__internal.getPromiseForActiveRequest,\n    getFragmentIdentifier = _require.getFragmentIdentifier,\n    getSelector = _require.getSelector,\n    isPromise = _require.isPromise,\n    recycleNodesInto = _require.recycleNodesInto,\n    reportMissingRequiredFields = _require.reportMissingRequiredFields;\n\nvar WEAKMAP_SUPPORTED = typeof WeakMap === 'function';\n// TODO: Fix to not rely on LRU. If the number of active fragments exceeds this\n// capacity, readSpec() will fail to find cached entries and break object\n// identity even if data hasn't changed.\nvar CACHE_CAPACITY = 1000000; // this is frozen so that users don't accidentally push data into the array\n\nvar CONSTANT_READONLY_EMPTY_ARRAY = Object.freeze([]);\n\nfunction isMissingData(snapshot) {\n  if (Array.isArray(snapshot)) {\n    return snapshot.some(function (s) {\n      return s.isMissingData;\n    });\n  }\n\n  return snapshot.isMissingData;\n}\n\nfunction getFragmentResult(cacheKey, snapshot) {\n  if (Array.isArray(snapshot)) {\n    return {\n      cacheKey: cacheKey,\n      snapshot: snapshot,\n      data: snapshot.map(function (s) {\n        return s.data;\n      })\n    };\n  }\n\n  return {\n    cacheKey: cacheKey,\n    snapshot: snapshot,\n    data: snapshot.data\n  };\n}\n\nfunction getPromiseForPendingOperationAffectingOwner(environment, request) {\n  return environment.getOperationTracker().getPromiseForPendingOperationsAffectingOwner(request);\n}\n\nvar FragmentResourceImpl = /*#__PURE__*/function () {\n  function FragmentResourceImpl(environment) {\n    this._environment = environment;\n    this._cache = LRUCache.create(CACHE_CAPACITY);\n  }\n  /**\n   * This function should be called during a Component's render function,\n   * to read the data for a fragment, or suspend if the fragment is being\n   * fetched.\n   */\n\n\n  var _proto = FragmentResourceImpl.prototype;\n\n  _proto.read = function read(fragmentNode, fragmentRef, componentDisplayName, fragmentKey) {\n    return this.readWithIdentifier(fragmentNode, fragmentRef, getFragmentIdentifier(fragmentNode, fragmentRef), componentDisplayName, fragmentKey);\n  }\n  /**\n   * Like `read`, but with a pre-computed fragmentIdentifier that should be\n   * equal to `getFragmentIdentifier(fragmentNode, fragmentRef)` from the\n   * arguments.\n   */\n  ;\n\n  _proto.readWithIdentifier = function readWithIdentifier(fragmentNode, fragmentRef, fragmentIdentifier, componentDisplayName, fragmentKey) {\n    var _fragmentNode$metadat;\n\n    var environment = this._environment; // If fragmentRef is null or undefined, pass it directly through.\n    // This is a convenience when consuming fragments via a HOC API, when the\n    // prop corresponding to the fragment ref might be passed as null.\n\n    if (fragmentRef == null) {\n      return {\n        cacheKey: fragmentIdentifier,\n        data: null,\n        snapshot: null\n      };\n    } // If fragmentRef is plural, ensure that it is an array.\n    // If it's empty, return the empty array directly before doing any more work.\n\n\n    if ((fragmentNode === null || fragmentNode === void 0 ? void 0 : (_fragmentNode$metadat = fragmentNode.metadata) === null || _fragmentNode$metadat === void 0 ? void 0 : _fragmentNode$metadat.plural) === true) {\n      !Array.isArray(fragmentRef) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected fragment pointer%s for fragment `%s` to be ' + 'an array, instead got `%s`. Remove `@relay(plural: true)` ' + 'from fragment `%s` to allow the prop to be an object.', fragmentKey != null ? \" for key `\".concat(fragmentKey, \"`\") : '', fragmentNode.name, typeof fragmentRef, fragmentNode.name) : invariant(false) : void 0;\n\n      if (fragmentRef.length === 0) {\n        return {\n          cacheKey: fragmentIdentifier,\n          data: CONSTANT_READONLY_EMPTY_ARRAY,\n          snapshot: CONSTANT_READONLY_EMPTY_ARRAY\n        };\n      }\n    } // Now we actually attempt to read the fragment:\n    // 1. Check if there's a cached value for this fragment\n\n\n    var cachedValue = this._cache.get(fragmentIdentifier);\n\n    if (cachedValue != null) {\n      if (isPromise(cachedValue)) {\n        throw cachedValue;\n      }\n\n      if (cachedValue.snapshot) {\n        this._reportMissingRequiredFieldsInSnapshot(cachedValue.snapshot);\n\n        return cachedValue;\n      }\n    } // 2. If not, try reading the fragment from the Relay store.\n    // If the snapshot has data, return it and save it in cache\n\n\n    var fragmentSelector = getSelector(fragmentNode, fragmentRef);\n    !(fragmentSelector != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected to receive an object where `...%s` was spread, ' + 'but the fragment reference was not found`. This is most ' + 'likely the result of:\\n' + \"- Forgetting to spread `%s` in `%s`'s parent's fragment.\\n\" + '- Conditionally fetching `%s` but unconditionally passing %s prop ' + 'to `%s`. If the parent fragment only fetches the fragment conditionally ' + '- with e.g. `@include`, `@skip`, or inside a `... on SomeType { }` ' + 'spread  - then the fragment reference will not exist. ' + 'In this case, pass `null` if the conditions for evaluating the ' + 'fragment are not met (e.g. if the `@include(if)` value is false.)', fragmentNode.name, fragmentNode.name, componentDisplayName, fragmentNode.name, fragmentKey == null ? 'a fragment reference' : \"the `\".concat(fragmentKey, \"`\"), componentDisplayName) : invariant(false) : void 0;\n    var snapshot = fragmentSelector.kind === 'PluralReaderSelector' ? fragmentSelector.selectors.map(function (s) {\n      return environment.lookup(s);\n    }) : environment.lookup(fragmentSelector);\n    var fragmentOwner = fragmentSelector.kind === 'PluralReaderSelector' ? fragmentSelector.selectors[0].owner : fragmentSelector.owner;\n\n    if (!isMissingData(snapshot)) {\n      this._reportMissingRequiredFieldsInSnapshot(snapshot);\n\n      var fragmentResult = getFragmentResult(fragmentIdentifier, snapshot);\n\n      this._cache.set(fragmentIdentifier, fragmentResult);\n\n      return fragmentResult;\n    } // 3. If we don't have data in the store, check if a request is in\n    // flight for the fragment's parent query, or for another operation\n    // that may affect the parent's query data, such as a mutation\n    // or subscription. If a promise exists, cache the promise and use it\n    // to suspend.\n\n\n    var networkPromise = this._getAndSavePromiseForFragmentRequestInFlight(fragmentIdentifier, fragmentNode, fragmentOwner);\n\n    if (networkPromise != null) {\n      throw networkPromise;\n    }\n\n    this._reportMissingRequiredFieldsInSnapshot(snapshot);\n\n    return getFragmentResult(fragmentIdentifier, snapshot);\n  };\n\n  _proto._reportMissingRequiredFieldsInSnapshot = function _reportMissingRequiredFieldsInSnapshot(snapshot) {\n    var _this = this;\n\n    if (Array.isArray(snapshot)) {\n      snapshot.forEach(function (s) {\n        if (s.missingRequiredFields != null) {\n          reportMissingRequiredFields(_this._environment, s.missingRequiredFields);\n        }\n      });\n    } else {\n      if (snapshot.missingRequiredFields != null) {\n        reportMissingRequiredFields(this._environment, snapshot.missingRequiredFields);\n      }\n    }\n  };\n\n  _proto.readSpec = function readSpec(fragmentNodes, fragmentRefs, componentDisplayName) {\n    var result = {};\n\n    for (var _key in fragmentNodes) {\n      result[_key] = this.read(fragmentNodes[_key], fragmentRefs[_key], componentDisplayName, _key);\n    }\n\n    return result;\n  };\n\n  _proto.subscribe = function subscribe(fragmentResult, callback) {\n    var _this2 = this;\n\n    var environment = this._environment;\n    var cacheKey = fragmentResult.cacheKey;\n    var renderedSnapshot = fragmentResult.snapshot;\n\n    if (!renderedSnapshot) {\n      return {\n        dispose: function dispose() {}\n      };\n    } // 1. Check for any updates missed during render phase\n    // TODO(T44066760): More efficiently detect if we missed an update\n\n\n    var _this$checkMissedUpda = this.checkMissedUpdates(fragmentResult),\n        didMissUpdates = _this$checkMissedUpda[0],\n        currentSnapshot = _this$checkMissedUpda[1]; // 2. If an update was missed, notify the component so it updates with\n    // the latest data.\n\n\n    if (didMissUpdates) {\n      callback();\n    } // 3. Establish subscriptions on the snapshot(s)\n\n\n    var dataSubscriptions = [];\n\n    if (Array.isArray(renderedSnapshot)) {\n      !Array.isArray(currentSnapshot) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected snapshots to be plural. ' + \"If you're seeing this, this is likely a bug in Relay.\") : invariant(false) : void 0;\n      currentSnapshot.forEach(function (snapshot, idx) {\n        dataSubscriptions.push(environment.subscribe(snapshot, function (latestSnapshot) {\n          _this2._updatePluralSnapshot(cacheKey, currentSnapshot, latestSnapshot, idx);\n\n          callback();\n        }));\n      });\n    } else {\n      !(currentSnapshot != null && !Array.isArray(currentSnapshot)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected snapshot to be singular. ' + \"If you're seeing this, this is likely a bug in Relay.\") : invariant(false) : void 0;\n      dataSubscriptions.push(environment.subscribe(currentSnapshot, function (latestSnapshot) {\n        _this2._cache.set(cacheKey, getFragmentResult(cacheKey, latestSnapshot));\n\n        callback();\n      }));\n    }\n\n    return {\n      dispose: function dispose() {\n        dataSubscriptions.map(function (s) {\n          return s.dispose();\n        });\n\n        _this2._cache[\"delete\"](cacheKey);\n      }\n    };\n  };\n\n  _proto.subscribeSpec = function subscribeSpec(fragmentResults, callback) {\n    var _this3 = this;\n\n    var disposables = Object.keys(fragmentResults).map(function (key) {\n      return _this3.subscribe(fragmentResults[key], callback);\n    });\n    return {\n      dispose: function dispose() {\n        disposables.forEach(function (disposable) {\n          disposable.dispose();\n        });\n      }\n    };\n  };\n\n  _proto.checkMissedUpdates = function checkMissedUpdates(fragmentResult) {\n    var environment = this._environment;\n    var cacheKey = fragmentResult.cacheKey;\n    var renderedSnapshot = fragmentResult.snapshot;\n\n    if (!renderedSnapshot) {\n      return [false, null];\n    }\n\n    var didMissUpdates = false;\n\n    if (Array.isArray(renderedSnapshot)) {\n      var currentSnapshots = [];\n      renderedSnapshot.forEach(function (snapshot, idx) {\n        var currentSnapshot = environment.lookup(snapshot.selector);\n        var renderData = snapshot.data;\n        var currentData = currentSnapshot.data;\n        var updatedData = recycleNodesInto(renderData, currentData);\n\n        if (updatedData !== renderData) {\n          currentSnapshot = (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, currentSnapshot), {}, {\n            data: updatedData\n          });\n          didMissUpdates = true;\n        }\n\n        currentSnapshots[idx] = currentSnapshot;\n      });\n\n      if (didMissUpdates) {\n        this._cache.set(cacheKey, getFragmentResult(cacheKey, currentSnapshots));\n      }\n\n      return [didMissUpdates, currentSnapshots];\n    }\n\n    var currentSnapshot = environment.lookup(renderedSnapshot.selector);\n    var renderData = renderedSnapshot.data;\n    var currentData = currentSnapshot.data;\n    var updatedData = recycleNodesInto(renderData, currentData);\n    currentSnapshot = {\n      data: updatedData,\n      isMissingData: currentSnapshot.isMissingData,\n      seenRecords: currentSnapshot.seenRecords,\n      selector: currentSnapshot.selector,\n      missingRequiredFields: currentSnapshot.missingRequiredFields\n    };\n\n    if (updatedData !== renderData) {\n      this._cache.set(cacheKey, getFragmentResult(cacheKey, currentSnapshot));\n\n      didMissUpdates = true;\n    }\n\n    return [didMissUpdates, currentSnapshot];\n  };\n\n  _proto.checkMissedUpdatesSpec = function checkMissedUpdatesSpec(fragmentResults) {\n    var _this4 = this;\n\n    return Object.keys(fragmentResults).some(function (key) {\n      return _this4.checkMissedUpdates(fragmentResults[key])[0];\n    });\n  };\n\n  _proto._getAndSavePromiseForFragmentRequestInFlight = function _getAndSavePromiseForFragmentRequestInFlight(cacheKey, fragmentNode, fragmentOwner) {\n    var _this5 = this;\n\n    var _getPromiseForActiveR;\n\n    var environment = this._environment;\n    var networkPromise = (_getPromiseForActiveR = getPromiseForActiveRequest(environment, fragmentOwner)) !== null && _getPromiseForActiveR !== void 0 ? _getPromiseForActiveR : getPromiseForPendingOperationAffectingOwner(environment, fragmentOwner);\n\n    if (!networkPromise) {\n      return null;\n    } // When the Promise for the request resolves, we need to make sure to\n    // update the cache with the latest data available in the store before\n    // resolving the Promise\n\n\n    var promise = networkPromise.then(function () {\n      _this5._cache[\"delete\"](cacheKey);\n    })[\"catch\"](function (error) {\n      _this5._cache[\"delete\"](cacheKey);\n    });\n\n    this._cache.set(cacheKey, promise);\n\n    var queryName = fragmentOwner.node.params.name;\n    var fragmentName = fragmentNode.name;\n    var promiseDisplayName = queryName === fragmentName ? \"Relay(\".concat(queryName, \")\") : \"Relay(\".concat(queryName, \":\").concat(fragmentName, \")\"); // $FlowExpectedError[prop-missing] Expando to annotate Promises.\n\n    promise.displayName = promiseDisplayName;\n    return promise;\n  };\n\n  _proto._updatePluralSnapshot = function _updatePluralSnapshot(cacheKey, baseSnapshots, latestSnapshot, idx) {\n    var currentFragmentResult = this._cache.get(cacheKey);\n\n    if (isPromise(currentFragmentResult)) {\n      reportInvalidCachedData(latestSnapshot.selector.node.name);\n      return;\n    }\n\n    var currentSnapshot = currentFragmentResult === null || currentFragmentResult === void 0 ? void 0 : currentFragmentResult.snapshot;\n\n    if (currentSnapshot && !Array.isArray(currentSnapshot)) {\n      reportInvalidCachedData(latestSnapshot.selector.node.name);\n      return;\n    }\n\n    var nextSnapshots = currentSnapshot ? (0, _toConsumableArray2[\"default\"])(currentSnapshot) : (0, _toConsumableArray2[\"default\"])(baseSnapshots);\n    nextSnapshots[idx] = latestSnapshot;\n\n    this._cache.set(cacheKey, getFragmentResult(cacheKey, nextSnapshots));\n  };\n\n  return FragmentResourceImpl;\n}();\n\nfunction reportInvalidCachedData(nodeName) {\n  !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected to find cached data for plural fragment `%s` when ' + 'receiving a subscription. ' + \"If you're seeing this, this is likely a bug in Relay.\", nodeName) : invariant(false) : void 0;\n}\n\nfunction createFragmentResource(environment) {\n  return new FragmentResourceImpl(environment);\n}\n\nvar dataResources = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();\n\nfunction getFragmentResourceForEnvironment(environment) {\n  var cached = dataResources.get(environment);\n\n  if (cached) {\n    return cached;\n  }\n\n  var newDataResource = createFragmentResource(environment);\n  dataResources.set(environment, newDataResource);\n  return newDataResource;\n}\n\nmodule.exports = {\n  createFragmentResource: createFragmentResource,\n  getFragmentResourceForEnvironment: getFragmentResourceForEnvironment\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar EntryPointContainer = require('./relay-hooks/EntryPointContainer.react');\n\nvar ReactRelayContext = require('./ReactRelayContext');\n\nvar ReactRelayFragmentContainer = require('./ReactRelayFragmentContainer');\n\nvar ReactRelayLocalQueryRenderer = require('./ReactRelayLocalQueryRenderer');\n\nvar ReactRelayPaginationContainer = require('./ReactRelayPaginationContainer');\n\nvar ReactRelayQueryRenderer = require('./ReactRelayQueryRenderer');\n\nvar ReactRelayRefetchContainer = require('./ReactRelayRefetchContainer');\n\nvar RelayEnvironmentProvider = require('./relay-hooks/RelayEnvironmentProvider');\n\nvar RelayRuntime = require('relay-runtime');\n\nvar loadEntryPoint = require('./relay-hooks/loadEntryPoint');\n\nvar useEntryPointLoader = require('./relay-hooks/useEntryPointLoader');\n\nvar useFragment = require('./relay-hooks/useFragment');\n\nvar useLazyLoadQuery = require('./relay-hooks/useLazyLoadQuery');\n\nvar useMutation = require('./relay-hooks/useMutation');\n\nvar usePaginationFragment = require('./relay-hooks/usePaginationFragment');\n\nvar usePreloadedQuery = require('./relay-hooks/usePreloadedQuery');\n\nvar useQueryLoader = require('./relay-hooks/useQueryLoader');\n\nvar useRefetchableFragment = require('./relay-hooks/useRefetchableFragment');\n\nvar useRelayEnvironment = require('./relay-hooks/useRelayEnvironment');\n\nvar useSubscribeToInvalidationState = require('./relay-hooks/useSubscribeToInvalidationState');\n\nvar useSubscription = require('./relay-hooks/useSubscription');\n\nvar _require = require('./relay-hooks/loadQuery'),\n    loadQuery = _require.loadQuery;\n\n/**\n * The public interface to react-relay.\n * Currently contains both Relay Hooks and legacy Container APIs.\n * Will eventually only export the interface from ./hooks.js.\n */\nmodule.exports = {\n  ConnectionHandler: RelayRuntime.ConnectionHandler,\n  QueryRenderer: ReactRelayQueryRenderer,\n  LocalQueryRenderer: ReactRelayLocalQueryRenderer,\n  MutationTypes: RelayRuntime.MutationTypes,\n  RangeOperations: RelayRuntime.RangeOperations,\n  ReactRelayContext: ReactRelayContext,\n  applyOptimisticMutation: RelayRuntime.applyOptimisticMutation,\n  commitLocalUpdate: RelayRuntime.commitLocalUpdate,\n  commitMutation: RelayRuntime.commitMutation,\n  createFragmentContainer: ReactRelayFragmentContainer.createContainer,\n  createPaginationContainer: ReactRelayPaginationContainer.createContainer,\n  createRefetchContainer: ReactRelayRefetchContainer.createContainer,\n  fetchQuery_DEPRECATED: RelayRuntime.fetchQuery_DEPRECATED,\n  graphql: RelayRuntime.graphql,\n  readInlineData: RelayRuntime.readInlineData,\n  requestSubscription: RelayRuntime.requestSubscription,\n  // Relay Hooks\n  EntryPointContainer: EntryPointContainer,\n  RelayEnvironmentProvider: RelayEnvironmentProvider,\n  fetchQuery: RelayRuntime.fetchQuery,\n  loadQuery: loadQuery,\n  loadEntryPoint: loadEntryPoint,\n  useFragment: useFragment,\n  useLazyLoadQuery: useLazyLoadQuery,\n  useEntryPointLoader: useEntryPointLoader,\n  useQueryLoader: useQueryLoader,\n  useMutation: useMutation,\n  usePaginationFragment: usePaginationFragment,\n  usePreloadedQuery: usePreloadedQuery,\n  useRefetchableFragment: useRefetchableFragment,\n  useRelayEnvironment: useRelayEnvironment,\n  useSubscribeToInvalidationState: useSubscribeToInvalidationState,\n  useSubscription: useSubscription\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n * @emails oncall+relay\n */\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar React = require('react');\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('relay-runtime'),\n    PreloadableQueryRegistry = _require.PreloadableQueryRegistry,\n    ReplaySubject = _require.ReplaySubject,\n    createOperationDescriptor = _require.createOperationDescriptor,\n    getRequest = _require.getRequest,\n    getRequestIdentifier = _require.getRequestIdentifier,\n    Observable = _require.Observable,\n    RelayFeatureFlags = _require.RelayFeatureFlags,\n    fetchQueryDeduped = _require.__internal.fetchQueryDeduped;\n\nvar RenderDispatcher = null;\nvar fetchKey = 100001;\n\nfunction useTrackLoadQueryInRender() {\n  if (RenderDispatcher === null) {\n    var _React$__SECRET_INTER, _React$__SECRET_INTER2;\n\n    // Flow does not know of React internals (rightly so), but we need to\n    // ensure here that this function isn't called inside render.\n    RenderDispatcher = // $FlowFixMe[prop-missing]\n    (_React$__SECRET_INTER = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === null || _React$__SECRET_INTER === void 0 ? void 0 : (_React$__SECRET_INTER2 = _React$__SECRET_INTER.ReactCurrentDispatcher) === null || _React$__SECRET_INTER2 === void 0 ? void 0 : _React$__SECRET_INTER2.current;\n  }\n}\n\nfunction loadQuery(environment, preloadableRequest, variables, options, environmentProviderOptions) {\n  var _React$__SECRET_INTER3, _React$__SECRET_INTER4, _options$__nameForWar, _options$fetchPolicy;\n\n  // This code ensures that we don't call loadQuery during render.\n  var CurrentDispatcher = // $FlowFixMe[prop-missing]\n  (_React$__SECRET_INTER3 = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED) === null || _React$__SECRET_INTER3 === void 0 ? void 0 : (_React$__SECRET_INTER4 = _React$__SECRET_INTER3.ReactCurrentDispatcher) === null || _React$__SECRET_INTER4 === void 0 ? void 0 : _React$__SECRET_INTER4.current;\n  process.env.NODE_ENV !== \"production\" ? warning(RenderDispatcher == null || CurrentDispatcher !== RenderDispatcher, 'Relay: `%s` should not be called inside a React render function.', (_options$__nameForWar = options === null || options === void 0 ? void 0 : options.__nameForWarning) !== null && _options$__nameForWar !== void 0 ? _options$__nameForWar : 'loadQuery') : void 0; // Every time you call loadQuery, we will generate a new fetchKey.\n  // This will ensure that every query reference that is created and\n  // passed to usePreloadedQuery is independently evaluated,\n  // even if they are for the same query/variables.\n  // Specifically, we want to avoid a case where we try to refetch a\n  // query by calling loadQuery a second time, and have the Suspense\n  // cache in usePreloadedQuery reuse the cached result instead of\n  // re-evaluating the new query ref and triggering a refetch if\n  // necessary.\n\n  fetchKey++;\n  var fetchPolicy = (_options$fetchPolicy = options === null || options === void 0 ? void 0 : options.fetchPolicy) !== null && _options$fetchPolicy !== void 0 ? _options$fetchPolicy : 'store-or-network';\n  var networkCacheConfig = (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, options === null || options === void 0 ? void 0 : options.networkCacheConfig), {}, {\n    force: true\n  }); // executeWithNetworkSource will retain and execute an operation\n  // against the Relay store, given an Observable that would provide\n  // the network events for the operation.\n\n  var retainReference;\n  var didExecuteNetworkSource = false;\n\n  var executeWithNetworkSource = function executeWithNetworkSource(operation, networkObservable) {\n    didExecuteNetworkSource = true;\n    return environment.executeWithSource({\n      operation: operation,\n      source: networkObservable\n    });\n  }; // N.B. For loadQuery, we unconventionally want to return an Observable\n  // that isn't lazily executed, meaning that we don't want to wait\n  // until the returned Observable is subscribed to to actually start\n  // fetching and executing an operation; i.e. we want to execute the\n  // operation eagerly, when loadQuery is called.\n  // For this reason, we use an intermediate executionSubject which\n  // allows us to capture the events that occur during the eager execution\n  // of the operation, and then replay them to the Observable we\n  // ultimately return.\n\n\n  var executionSubject = new ReplaySubject();\n  var returnedObservable = Observable.create(function (sink) {\n    return executionSubject.subscribe(sink);\n  });\n  var unsubscribeFromNetworkRequest;\n  var networkError = null; // makeNetworkRequest will immediately start a raw network request if\n  // one isn't already in flight and return an Observable that when\n  // subscribed to will replay the network events that have occured so far,\n  // as well as subsequent events.\n\n  var didMakeNetworkRequest = false;\n\n  var makeNetworkRequest = function makeNetworkRequest(params) {\n    // N.B. this function is called synchronously or not at all\n    // didMakeNetworkRequest is safe to rely on in the returned value\n    // Even if the request gets deduped below, we still wan't to return an\n    // observable that provides the replayed network events for the query,\n    // so we set this to true before deduping, to guarantee that the\n    // `source` observable is returned.\n    didMakeNetworkRequest = true;\n    var observable;\n    var subject = new ReplaySubject();\n\n    if (RelayFeatureFlags.ENABLE_LOAD_QUERY_REQUEST_DEDUPING === true) {\n      // Here, we are calling fetchQueryDeduped at the network layer level,\n      // which ensures that only a single network request is active for a given\n      // (environment, identifier) pair.\n      // Since network requests can be started /before/ we have the query ast\n      // necessary to process the results, we need to dedupe the raw requests\n      // separately from deduping the operation execution; specifically,\n      // if `loadQuery` is called multiple times before the query ast is available,\n      // we still want the network request to be deduped.\n      // - If a duplicate active network request is found, it will return an\n      // Observable that replays the events of the already active request.\n      // - If no duplicate active network request is found, it will call the fetchFn\n      // to start the request, and return an Observable that will replay\n      // the events from the network request.\n      // We provide an extra key to the identifier to distinguish deduping\n      // of raw network requests vs deduping of operation executions.\n      var identifier = 'raw-network-request-' + getRequestIdentifier(params, variables);\n      observable = fetchQueryDeduped(environment, identifier, function () {\n        var network = environment.getNetwork();\n        return network.execute(params, variables, networkCacheConfig);\n      });\n    } else {\n      var network = environment.getNetwork();\n      observable = network.execute(params, variables, networkCacheConfig);\n    }\n\n    var _observable$subscribe = observable.subscribe({\n      error: function error(err) {\n        networkError = err;\n        subject.error(err);\n      },\n      next: function next(data) {\n        subject.next(data);\n      },\n      complete: function complete() {\n        subject.complete();\n      }\n    }),\n        unsubscribe = _observable$subscribe.unsubscribe;\n\n    unsubscribeFromNetworkRequest = unsubscribe;\n    return Observable.create(function (sink) {\n      var subjectSubscription = subject.subscribe(sink);\n      return function () {\n        subjectSubscription.unsubscribe();\n        unsubscribeFromNetworkRequest();\n      };\n    });\n  };\n\n  var unsubscribeFromExecution;\n\n  var executeDeduped = function executeDeduped(operation, fetchFn) {\n    if (RelayFeatureFlags.ENABLE_LOAD_QUERY_REQUEST_DEDUPING === true) {\n      // N.B. at this point, if we're calling execute with a query ast (OperationDescriptor),\n      // we are guaranteed to have started a network request. We set this to\n      // true here as well since `makeNetworkRequest` might get skipped in the case\n      // where the query ast is already available and the query executions get deduped.\n      // Even if the execution gets deduped below, we still wan't to return\n      // an observable that provides the replayed network events for the query,\n      // so we set this to true before deduping, to guarantee that the `source`\n      // observable is returned.\n      didMakeNetworkRequest = true;\n    } // Here, we are calling fetchQueryDeduped, which ensures that only\n    // a single operation is active for a given (environment, identifier) pair,\n    // and also tracks the active state of the operation, which is necessary\n    // for our Suspense infra to later be able to suspend (or not) on\n    // active operations. Even though we already dedupe raw network requests,\n    // we also need to dedupe and keep track operation execution for our Suspense\n    // infra, and we also want to avoid processing responses more than once, for\n    // the cases where `loadQuery` might be called multiple times after the query ast\n    // is available.\n    // - If a duplicate active operation is found, it will return an\n    // Observable that replays the events of the already active operation.\n    // - If no duplicate active operation is found, it will call the fetchFn\n    // to execute the operation, and return an Observable that will provide\n    // the events for executing the operation.\n\n\n    var _fetchQueryDeduped$su = fetchQueryDeduped(environment, operation.request.identifier, fetchFn).subscribe({\n      error: function error(err) {\n        executionSubject.error(err);\n      },\n      next: function next(data) {\n        executionSubject.next(data);\n      },\n      complete: function complete() {\n        executionSubject.complete();\n      }\n    });\n\n    unsubscribeFromExecution = _fetchQueryDeduped$su.unsubscribe;\n  };\n\n  var checkAvailabilityAndExecute = function checkAvailabilityAndExecute(concreteRequest) {\n    var operation = createOperationDescriptor(concreteRequest, variables, networkCacheConfig);\n    retainReference = environment.retain(operation);\n\n    if (fetchPolicy === 'store-only') {\n      return;\n    } // N.B. If the fetch policy allows fulfillment from the store but the\n    // environment already has the data for that operation cached in the store,\n    // then we do nothing.\n\n\n    var shouldFetch = fetchPolicy !== 'store-or-network' || environment.check(operation).status !== 'available';\n\n    if (shouldFetch) {\n      executeDeduped(operation, function () {\n        // N.B. Since we have the operation synchronously available here,\n        // we can immediately fetch and execute the operation.\n        var networkObservable = makeNetworkRequest(concreteRequest.params);\n        var executeObservable = executeWithNetworkSource(operation, networkObservable);\n        return executeObservable;\n      });\n    }\n  };\n\n  var params;\n  var cancelOnLoadCallback;\n  var queryId;\n\n  if (preloadableRequest.kind === 'PreloadableConcreteRequest') {\n    var preloadableConcreteRequest = preloadableRequest;\n    params = preloadableConcreteRequest.params;\n    var _params = params;\n    queryId = _params.id;\n    !(queryId !== null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: `loadQuery` requires that preloadable query `%s` has a persisted query id', params.name) : invariant(false) : void 0;\n\n    var _module = PreloadableQueryRegistry.get(queryId);\n\n    if (_module != null) {\n      checkAvailabilityAndExecute(_module);\n    } else {\n      // If the module isn't synchronously available, we launch the\n      // network request immediately if the fetchPolicy might produce\n      // a network fetch, regardless of the state of the store cache. We\n      // do this because we can't check if a query is cached without the\n      // ast, and we know that if we don't have the query ast\n      // available, then this query could've never been written to the\n      // store in the first place, so it couldn't have been cached.\n      var networkObservable = fetchPolicy === 'store-only' ? null : makeNetworkRequest(params);\n\n      var _PreloadableQueryRegi = PreloadableQueryRegistry.onLoad( // $FlowFixMe[incompatible-call]\n      queryId, function (preloadedModule) {\n        cancelOnLoadCallback();\n        var operation = createOperationDescriptor(preloadedModule, variables, networkCacheConfig);\n        retainReference = environment.retain(operation);\n\n        if (networkObservable != null) {\n          executeDeduped(operation, function () {\n            return executeWithNetworkSource(operation, networkObservable);\n          });\n        }\n      });\n\n      cancelOnLoadCallback = _PreloadableQueryRegi.dispose;\n    }\n  } else {\n    var graphQlTaggedNode = preloadableRequest;\n    var request = getRequest(graphQlTaggedNode);\n    params = request.params;\n    queryId = params.cacheID != null ? params.cacheID : params.id;\n    checkAvailabilityAndExecute(request);\n  }\n\n  var isDisposed = false;\n  return {\n    kind: 'PreloadedQuery',\n    environment: environment,\n    environmentProviderOptions: environmentProviderOptions,\n    dispose: function dispose() {\n      if (isDisposed) {\n        return;\n      }\n\n      if (didExecuteNetworkSource) {\n        unsubscribeFromExecution && unsubscribeFromExecution();\n      } else {\n        unsubscribeFromNetworkRequest && unsubscribeFromNetworkRequest();\n      }\n\n      retainReference && retainReference.dispose();\n      cancelOnLoadCallback && cancelOnLoadCallback();\n      isDisposed = true;\n    },\n    fetchKey: fetchKey,\n    id: queryId,\n\n    // $FlowFixMe[unsafe-getters-setters] - this has no side effects\n    get isDisposed() {\n      return isDisposed;\n    },\n\n    // $FlowFixMe[unsafe-getters-setters] - this has no side effects\n    get networkError() {\n      return networkError;\n    },\n\n    name: params.name,\n    networkCacheConfig: networkCacheConfig,\n    fetchPolicy: fetchPolicy,\n    source: didMakeNetworkRequest ? returnedObservable : undefined,\n    variables: variables\n  };\n}\n\nmodule.exports = {\n  loadQuery: loadQuery,\n  useTrackLoadQueryInRender: useTrackLoadQueryInRender\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar getPaginationVariables = require('./getPaginationVariables');\n\nvar getValueAtPath = require('./getValueAtPath');\n\nvar invariant = require('invariant');\n\nvar useFetchTrackingRef = require('./useFetchTrackingRef');\n\nvar useIsMountedRef = require('./useIsMountedRef');\n\nvar useIsOperationNodeActive = require('./useIsOperationNodeActive');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('react'),\n    useCallback = _require.useCallback,\n    useEffect = _require.useEffect,\n    useState = _require.useState;\n\nvar _require2 = require('relay-runtime'),\n    ConnectionInterface = _require2.ConnectionInterface,\n    fetchQuery = _require2.__internal.fetchQuery,\n    createOperationDescriptor = _require2.createOperationDescriptor,\n    getSelector = _require2.getSelector;\n\nfunction useLoadMoreFunction(args) {\n  var direction = args.direction,\n      fragmentNode = args.fragmentNode,\n      fragmentRef = args.fragmentRef,\n      fragmentIdentifier = args.fragmentIdentifier,\n      fragmentData = args.fragmentData,\n      connectionPathInFragmentData = args.connectionPathInFragmentData,\n      paginationRequest = args.paginationRequest,\n      paginationMetadata = args.paginationMetadata,\n      componentDisplayName = args.componentDisplayName,\n      observer = args.observer,\n      onReset = args.onReset,\n      identifierField = args.identifierField;\n  var environment = useRelayEnvironment();\n\n  var _useFetchTrackingRef = useFetchTrackingRef(),\n      isFetchingRef = _useFetchTrackingRef.isFetchingRef,\n      startFetch = _useFetchTrackingRef.startFetch,\n      disposeFetch = _useFetchTrackingRef.disposeFetch,\n      completeFetch = _useFetchTrackingRef.completeFetch;\n\n  var identifierValue = identifierField != null && fragmentData != null && typeof fragmentData === 'object' ? fragmentData[identifierField] : null;\n  var isMountedRef = useIsMountedRef();\n\n  var _useState = useState(environment),\n      mirroredEnvironment = _useState[0],\n      setMirroredEnvironment = _useState[1];\n\n  var _useState2 = useState(fragmentIdentifier),\n      mirroredFragmentIdentifier = _useState2[0],\n      setMirroredFragmentIdentifier = _useState2[1];\n\n  var isParentQueryActive = useIsOperationNodeActive(fragmentNode, fragmentRef);\n  var shouldReset = environment !== mirroredEnvironment || fragmentIdentifier !== mirroredFragmentIdentifier;\n\n  if (shouldReset) {\n    disposeFetch();\n    onReset();\n    setMirroredEnvironment(environment);\n    setMirroredFragmentIdentifier(fragmentIdentifier);\n  }\n\n  var _getConnectionState = getConnectionState(direction, fragmentNode, fragmentData, connectionPathInFragmentData),\n      cursor = _getConnectionState.cursor,\n      hasMore = _getConnectionState.hasMore; // Dispose of pagination requests in flight when unmounting\n\n\n  useEffect(function () {\n    return function () {\n      disposeFetch();\n    };\n  }, [disposeFetch]);\n  var loadMore = useCallback(function (count, options) {\n    // TODO(T41131846): Fetch/Caching policies for loadMore\n    var onComplete = options === null || options === void 0 ? void 0 : options.onComplete;\n\n    if (isMountedRef.current !== true) {\n      // Bail out and warn if we're trying to paginate after the component\n      // has unmounted\n      process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Unexpected fetch on unmounted component for fragment ' + '`%s` in `%s`. It looks like some instances of your component are ' + 'still trying to fetch data but they already unmounted. ' + 'Please make sure you clear all timers, intervals, ' + 'async calls, etc that may trigger a fetch.', fragmentNode.name, componentDisplayName) : void 0;\n      return {\n        dispose: function dispose() {}\n      };\n    }\n\n    var fragmentSelector = getSelector(fragmentNode, fragmentRef);\n\n    if (isFetchingRef.current === true || fragmentData == null || isParentQueryActive) {\n      if (fragmentSelector == null) {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Unexpected fetch while using a null fragment ref ' + 'for fragment `%s` in `%s`. When fetching more items, we expect ' + \"initial fragment data to be non-null. Please make sure you're \" + 'passing a valid fragment ref to `%s` before paginating.', fragmentNode.name, componentDisplayName, componentDisplayName) : void 0;\n      }\n\n      if (onComplete) {\n        onComplete(null);\n      }\n\n      return {\n        dispose: function dispose() {}\n      };\n    }\n\n    !(fragmentSelector != null && fragmentSelector.kind !== 'PluralReaderSelector') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected to be able to find a non-plural fragment owner for ' + \"fragment `%s` when using `%s`. If you're seeing this, \" + 'this is likely a bug in Relay.', fragmentNode.name, componentDisplayName) : invariant(false) : void 0;\n    var parentVariables = fragmentSelector.owner.variables;\n    var fragmentVariables = fragmentSelector.variables;\n    var extraVariables = options === null || options === void 0 ? void 0 : options.UNSTABLE_extraVariables; // $FlowFixMe[cannot-spread-interface]\n\n    var baseVariables = (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, parentVariables), fragmentVariables);\n    var paginationVariables = getPaginationVariables(direction, count, cursor, baseVariables, // $FlowFixMe[cannot-spread-interface]\n    (0, _objectSpread2[\"default\"])({}, extraVariables), paginationMetadata); // If the query needs an identifier value ('id' or similar) and one\n    // was not explicitly provided, read it from the fragment data.\n\n    if (identifierField != null) {\n      // @refetchable fragments are guaranteed to have an `id` selection\n      // if the type is Node, implements Node, or is @fetchable. Double-check\n      // that there actually is a value at runtime.\n      if (typeof identifierValue !== 'string') {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Expected result to have a string  ' + '`%s` in order to refetch, got `%s`.', identifierField, identifierValue) : void 0;\n      }\n\n      paginationVariables.id = identifierValue;\n    }\n\n    var paginationQuery = createOperationDescriptor(paginationRequest, paginationVariables, {\n      force: true\n    });\n    fetchQuery(environment, paginationQuery).subscribe((0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, observer), {}, {\n      start: function start(subscription) {\n        startFetch(subscription);\n        observer.start && observer.start(subscription);\n      },\n      complete: function complete() {\n        completeFetch();\n        observer.complete && observer.complete();\n        onComplete && onComplete(null);\n      },\n      error: function error(_error) {\n        completeFetch();\n        observer.error && observer.error(_error);\n        onComplete && onComplete(_error);\n      }\n    }));\n    return {\n      dispose: disposeFetch\n    };\n  }, // NOTE: We disable react-hooks-deps warning because all values\n  // inside paginationMetadata are static\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [environment, identifierValue, direction, cursor, startFetch, disposeFetch, completeFetch, isFetchingRef, isParentQueryActive, fragmentData, fragmentNode.name, fragmentRef, componentDisplayName]);\n  return [loadMore, hasMore, disposeFetch];\n}\n\nfunction getConnectionState(direction, fragmentNode, fragmentData, connectionPathInFragmentData) {\n  var _pageInfo$END_CURSOR, _pageInfo$START_CURSO;\n\n  var _ConnectionInterface$ = ConnectionInterface.get(),\n      EDGES = _ConnectionInterface$.EDGES,\n      PAGE_INFO = _ConnectionInterface$.PAGE_INFO,\n      HAS_NEXT_PAGE = _ConnectionInterface$.HAS_NEXT_PAGE,\n      HAS_PREV_PAGE = _ConnectionInterface$.HAS_PREV_PAGE,\n      END_CURSOR = _ConnectionInterface$.END_CURSOR,\n      START_CURSOR = _ConnectionInterface$.START_CURSOR;\n\n  var connection = getValueAtPath(fragmentData, connectionPathInFragmentData);\n\n  if (connection == null) {\n    return {\n      cursor: null,\n      hasMore: false\n    };\n  }\n\n  !(typeof connection === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected connection in fragment `%s` to have been `null`, or ' + 'a plain object with %s and %s properties. Instead got `%s`.', fragmentNode.name, EDGES, PAGE_INFO, connection) : invariant(false) : void 0;\n  var edges = connection[EDGES];\n  var pageInfo = connection[PAGE_INFO];\n\n  if (edges == null || pageInfo == null) {\n    return {\n      cursor: null,\n      hasMore: false\n    };\n  }\n\n  !Array.isArray(edges) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected connection in fragment `%s` to have a plural `%s` field. ' + 'Instead got `%s`.', fragmentNode.name, EDGES, edges) : invariant(false) : void 0;\n  !(typeof pageInfo === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected connection in fragment `%s` to have a `%s` field. ' + 'Instead got `%s`.', fragmentNode.name, PAGE_INFO, pageInfo) : invariant(false) : void 0;\n  var cursor = direction === 'forward' ? (_pageInfo$END_CURSOR = pageInfo[END_CURSOR]) !== null && _pageInfo$END_CURSOR !== void 0 ? _pageInfo$END_CURSOR : null : (_pageInfo$START_CURSO = pageInfo[START_CURSOR]) !== null && _pageInfo$START_CURSO !== void 0 ? _pageInfo$START_CURSO : null;\n  !(cursor === null || typeof cursor === 'string') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Relay: Expected page info for connection in fragment `%s` to have a ' + 'valid `%s`. Instead got `%s`.', fragmentNode.name, START_CURSOR, cursor) : invariant(false) : void 0;\n  var hasMore;\n\n  if (direction === 'forward') {\n    hasMore = cursor != null && pageInfo[HAS_NEXT_PAGE] === true;\n  } else {\n    hasMore = cursor != null && pageInfo[HAS_PREV_PAGE] === true;\n  }\n\n  return {\n    cursor: cursor,\n    hasMore: hasMore\n  };\n}\n\nmodule.exports = useLoadMoreFunction;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar useIsMountedRef = require('./useIsMountedRef');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar _require = require('./loadQuery'),\n    loadQuery = _require.loadQuery,\n    useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;\n\nvar _require2 = require('react'),\n    useCallback = _require2.useCallback,\n    useEffect = _require2.useEffect,\n    useRef = _require2.useRef,\n    useState = _require2.useState;\n\nvar initialNullQueryReferenceState = {\n  kind: 'NullQueryReference'\n};\n\nfunction useQueryLoader(preloadableRequest, initialQueryReference) {\n  /**\n   * We want to always call `queryReference.dispose()` for every call to\n   * `setQueryReference(loadQuery(...))` so that no leaks of data in Relay stores\n   * will occur.\n   *\n   * However, a call to `setState(newState)` is not always followed by a commit where\n   * this value is reflected in the state. Thus, we cannot reliably clean up each\n   * ref with `useEffect(() => () => queryReference.dispose(), [queryReference])`.\n   *\n   * Instead, we keep track of each call to `loadQuery` in a ref.\n   * Relying on the fact that if a state change commits, no state changes that were\n   * initiated prior to the currently committing state change will ever subsequently\n   * commit, we can safely dispose of all preloaded query references\n   * associated with state changes initiated prior to the currently committing state\n   * change.\n   *\n   * Finally, when the hook unmounts, we also dispose of all remaining uncommitted\n   * query references.\n   */\n  var initialQueryReferenceInternal = initialQueryReference !== null && initialQueryReference !== void 0 ? initialQueryReference : initialNullQueryReferenceState;\n  var environment = useRelayEnvironment();\n  useTrackLoadQueryInRender();\n  var isMountedRef = useIsMountedRef();\n  var undisposedQueryReferencesRef = useRef(new Set([initialQueryReferenceInternal]));\n\n  var _useState = useState(function () {\n    return initialQueryReferenceInternal;\n  }),\n      queryReference = _useState[0],\n      setQueryReference = _useState[1];\n\n  var _useState2 = useState(function () {\n    return initialQueryReferenceInternal;\n  }),\n      previousInitialQueryReference = _useState2[0],\n      setPreviousInitialQueryReference = _useState2[1];\n\n  if (initialQueryReferenceInternal !== previousInitialQueryReference) {\n    // Rendering the query reference makes it \"managed\" by this hook, so\n    // we start keeping track of it so we can dispose it when it is no longer\n    // necessary here\n    // TODO(T78446637): Handle disposal of managed query references in\n    // components that were never mounted after rendering\n    undisposedQueryReferencesRef.current.add(initialQueryReferenceInternal);\n    setPreviousInitialQueryReference(initialQueryReferenceInternal);\n    setQueryReference(initialQueryReferenceInternal);\n  }\n\n  var disposeQuery = useCallback(function () {\n    if (isMountedRef.current) {\n      undisposedQueryReferencesRef.current.add(initialNullQueryReferenceState);\n      setQueryReference(initialNullQueryReferenceState);\n    }\n  }, [isMountedRef]);\n  var queryLoaderCallback = useCallback(function (variables, options) {\n    var mergedOptions = options != null && options.hasOwnProperty('__environment') ? {\n      fetchPolicy: options.fetchPolicy,\n      networkCacheConfig: options.networkCacheConfig,\n      __nameForWarning: options.__nameForWarning\n    } : options;\n\n    if (isMountedRef.current) {\n      var _options$__environmen;\n\n      var updatedQueryReference = loadQuery((_options$__environmen = options === null || options === void 0 ? void 0 : options.__environment) !== null && _options$__environmen !== void 0 ? _options$__environmen : environment, preloadableRequest, variables, mergedOptions);\n      undisposedQueryReferencesRef.current.add(updatedQueryReference);\n      setQueryReference(updatedQueryReference);\n    }\n  }, [environment, preloadableRequest, setQueryReference, isMountedRef]);\n  var maybeHiddenOrFastRefresh = useRef(false);\n  useEffect(function () {\n    return function () {\n      // Attempt to detect if the component was\n      // hidden (by Offscreen API), or fast refresh occured;\n      // Only in these situations would the effect cleanup\n      // for \"unmounting\" run multiple times, so if\n      // we are ever able to read this ref with a value\n      // of true, it means that one of these cases\n      // has happened.\n      maybeHiddenOrFastRefresh.current = true;\n    };\n  }, []);\n  useEffect(function () {\n    if (maybeHiddenOrFastRefresh.current === true) {\n      // This block only runs if the component has previously \"unmounted\"\n      // due to it being hidden by the Offscreen API, or during fast refresh.\n      // At this point, the current queryReference will have been disposed\n      // by the previous cleanup, so instead of attempting to\n      // do our regular commit setup, which would incorrectly leave our\n      // current queryReference disposed, we need to load the query again\n      // and force a re-render by calling queryLoaderCallback again,\n      // so that the queryReference is correctly re-retained, and\n      // potentially refetched if necessary.\n      maybeHiddenOrFastRefresh.current = false;\n\n      if (queryReference.kind !== 'NullQueryReference') {\n        queryLoaderCallback(queryReference.variables, {\n          fetchPolicy: queryReference.fetchPolicy,\n          networkCacheConfig: queryReference.networkCacheConfig\n        });\n      }\n\n      return;\n    } // When a new queryReference is committed, we iterate over all\n    // query references in undisposedQueryReferences and dispose all of\n    // the refs that aren't the currently committed one. This ensures\n    // that we don't leave any dangling query references for the\n    // case that loadQuery is called multiple times before commit; when\n    // this happens, multiple state updates will be scheduled, but only one\n    // will commit, meaning that we need to keep track of and dispose any\n    // query references that don't end up committing.\n    // - We are relying on the fact that sets iterate in insertion order, and we\n    // can remove items from a set as we iterate over it (i.e. no iterator\n    // invalidation issues.) Thus, it is safe to loop through\n    // undisposedQueryReferences until we find queryReference, and\n    // remove and dispose all previous references.\n    // - We are guaranteed to find queryReference in the set, because if a\n    // state update results in a commit, no state updates initiated prior to that\n    // one will be committed, and we are disposing and removing references\n    // associated with updates that were scheduled prior to the currently\n    // committing state change. (A useEffect callback is called during the commit\n    // phase.)\n\n\n    var undisposedQueryReferences = undisposedQueryReferencesRef.current;\n\n    if (isMountedRef.current) {\n      var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(undisposedQueryReferences),\n          _step;\n\n      try {\n        for (_iterator.s(); !(_step = _iterator.n()).done;) {\n          var undisposedQueryReference = _step.value;\n\n          if (undisposedQueryReference === queryReference) {\n            break;\n          }\n\n          undisposedQueryReferences[\"delete\"](undisposedQueryReference);\n\n          if (undisposedQueryReference.kind !== 'NullQueryReference') {\n            undisposedQueryReference.dispose && undisposedQueryReference.dispose();\n          }\n        }\n      } catch (err) {\n        _iterator.e(err);\n      } finally {\n        _iterator.f();\n      }\n    }\n  }, [queryReference, isMountedRef, queryLoaderCallback]);\n  useEffect(function () {\n    return function disposeAllRemainingQueryReferences() {\n      // undisposedQueryReferences.current is never reassigned\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n      var _iterator2 = (0, _createForOfIteratorHelper2[\"default\"])(undisposedQueryReferencesRef.current),\n          _step2;\n\n      try {\n        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n          var unhandledStateChange = _step2.value;\n\n          if (unhandledStateChange.kind !== 'NullQueryReference') {\n            unhandledStateChange.dispose && unhandledStateChange.dispose();\n          }\n        }\n      } catch (err) {\n        _iterator2.e(err);\n      } finally {\n        _iterator2.f();\n      }\n    };\n  }, []);\n  return [queryReference.kind === 'NullQueryReference' ? null : queryReference, queryLoaderCallback, disposeQuery];\n}\n\nmodule.exports = useQueryLoader;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nfunction getComponentName(component) {\n  return component.displayName || component.name || 'Component';\n}\n\nfunction getContainerName(Component) {\n  return 'Relay(' + getComponentName(Component) + ')';\n}\n\nmodule.exports = {\n  getComponentName: getComponentName,\n  getContainerName: getContainerName\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar _require = require('react'),\n    useEffect = _require.useEffect,\n    useRef = _require.useRef;\n\n/**\n * This hook subscribes a callback to the invalidation state of the given data\n * ids.\n * Any time the invalidation state of the given data ids changes, the provided\n * callback will be called.\n * If new ids or a new callback are provided, the subscription will be\n * re-established and the previous one will be disposed.\n * The subscription will automatically be disposed on unmount\n */\nfunction useSubscribeToInvalidationState(dataIDs, callback) {\n  var environment = useRelayEnvironment();\n  var disposableRef = useRef(null);\n  var stableDataIDs = Array.from(dataIDs).sort().join('');\n  useEffect(function () {\n    var store = environment.getStore();\n    var invalidationState = store.lookupInvalidationState(dataIDs);\n    var disposable = store.subscribeToInvalidationState(invalidationState, callback);\n    disposableRef.current = disposable;\n    return function () {\n      return disposable.dispose();\n    }; // Intentionally excluding dataIDs, since we're using stableDataIDs\n    // instead\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [stableDataIDs, callback, environment]);\n  return {\n    dispose: function dispose() {\n      if (disposableRef.current != null) {\n        disposableRef.current.dispose();\n      }\n    }\n  };\n}\n\nmodule.exports = useSubscribeToInvalidationState;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar useFragmentNode = require('./useFragmentNode');\n\nvar useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');\n\nvar _require = require('./loadQuery'),\n    useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;\n\nvar _require2 = require('react'),\n    useDebugValue = _require2.useDebugValue;\n\nvar _require3 = require('relay-runtime'),\n    getFragment = _require3.getFragment;\n\nfunction useFragment(fragmentInput, fragmentRef) {\n  // We need to use this hook in order to be able to track if\n  // loadQuery was called during render\n  useTrackLoadQueryInRender();\n  var fragmentNode = getFragment(fragmentInput);\n  useStaticFragmentNodeWarning(fragmentNode, 'first argument of useFragment()');\n\n  var _useFragmentNode = useFragmentNode(fragmentNode, fragmentRef, 'useFragment()'),\n      data = _useFragmentNode.data;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useDebugValue({\n      fragment: fragmentNode.name,\n      data: data\n    });\n  }\n\n  return data;\n}\n\nmodule.exports = useFragment;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar React = require('react');\n\nvar areEqual = require(\"fbjs/lib/areEqual\");\n\nvar useMemo = React.useMemo,\n    useRef = React.useRef,\n    useState = React.useState;\n\nfunction useMemoVariables(variables) {\n  var _variablesChangedGene2;\n\n  // The value of this ref is a counter that should be incremented when\n  // variables change. This allows us to use the counter as a\n  // memoization value to indicate if the computation for useMemo\n  // should be re-executed.\n  var variablesChangedGenerationRef = useRef(0); // We mirror the variables to check if they have changed between renders\n\n  var _useState = useState(variables),\n      mirroredVariables = _useState[0],\n      setMirroredVariables = _useState[1];\n\n  var variablesChanged = !areEqual(variables, mirroredVariables);\n\n  if (variablesChanged) {\n    var _variablesChangedGene;\n\n    variablesChangedGenerationRef.current = ((_variablesChangedGene = variablesChangedGenerationRef.current) !== null && _variablesChangedGene !== void 0 ? _variablesChangedGene : 0) + 1;\n    setMirroredVariables(variables);\n  } // NOTE: We disable react-hooks-deps warning because we explicitly\n  // don't want to memoize on object identity\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n\n\n  var memoVariables = useMemo(function () {\n    return variables;\n  }, [variablesChangedGenerationRef.current]);\n  return [memoVariables, (_variablesChangedGene2 = variablesChangedGenerationRef.current) !== null && _variablesChangedGene2 !== void 0 ? _variablesChangedGene2 : 0];\n}\n\nmodule.exports = useMemoVariables;","/**\n * Relay v11.0.2\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nmodule.exports = require('./lib/ReactRelayContext.js');\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\n\nvar getPaginationMetadata = require('./getPaginationMetadata');\n\nvar useLoadMoreFunction = require('./useLoadMoreFunction');\n\nvar useRefetchableFragmentNode = require('./useRefetchableFragmentNode');\n\nvar useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');\n\nvar _require = require('react'),\n    useCallback = _require.useCallback,\n    useDebugValue = _require.useDebugValue,\n    useState = _require.useState;\n\nvar _require2 = require('relay-runtime'),\n    getFragment = _require2.getFragment,\n    getFragmentIdentifier = _require2.getFragmentIdentifier;\n\nfunction usePaginationFragment(fragmentInput, parentFragmentRef) {\n  var fragmentNode = getFragment(fragmentInput);\n  useStaticFragmentNodeWarning(fragmentNode, 'first argument of usePaginationFragment()');\n  var componentDisplayName = 'usePaginationFragment()';\n\n  var _getPaginationMetadat = getPaginationMetadata(fragmentNode, componentDisplayName),\n      connectionPathInFragmentData = _getPaginationMetadat.connectionPathInFragmentData,\n      paginationRequest = _getPaginationMetadat.paginationRequest,\n      paginationMetadata = _getPaginationMetadat.paginationMetadata,\n      identifierField = _getPaginationMetadat.identifierField;\n\n  var _useRefetchableFragme = useRefetchableFragmentNode(fragmentNode, parentFragmentRef, componentDisplayName),\n      fragmentData = _useRefetchableFragme.fragmentData,\n      fragmentRef = _useRefetchableFragme.fragmentRef,\n      refetch = _useRefetchableFragme.refetch;\n\n  var fragmentIdentifier = getFragmentIdentifier(fragmentNode, fragmentRef); // Backward pagination\n\n  var _useLoadMore = useLoadMore({\n    componentDisplayName: componentDisplayName,\n    connectionPathInFragmentData: connectionPathInFragmentData,\n    direction: 'backward',\n    fragmentData: fragmentData,\n    fragmentIdentifier: fragmentIdentifier,\n    fragmentNode: fragmentNode,\n    fragmentRef: fragmentRef,\n    identifierField: identifierField,\n    paginationMetadata: paginationMetadata,\n    paginationRequest: paginationRequest\n  }),\n      loadPrevious = _useLoadMore[0],\n      hasPrevious = _useLoadMore[1],\n      isLoadingPrevious = _useLoadMore[2],\n      disposeFetchPrevious = _useLoadMore[3]; // Forward pagination\n\n\n  var _useLoadMore2 = useLoadMore({\n    componentDisplayName: componentDisplayName,\n    connectionPathInFragmentData: connectionPathInFragmentData,\n    direction: 'forward',\n    fragmentData: fragmentData,\n    fragmentIdentifier: fragmentIdentifier,\n    fragmentNode: fragmentNode,\n    fragmentRef: fragmentRef,\n    identifierField: identifierField,\n    paginationMetadata: paginationMetadata,\n    paginationRequest: paginationRequest\n  }),\n      loadNext = _useLoadMore2[0],\n      hasNext = _useLoadMore2[1],\n      isLoadingNext = _useLoadMore2[2],\n      disposeFetchNext = _useLoadMore2[3];\n\n  var refetchPagination = useCallback(function (variables, options) {\n    disposeFetchNext();\n    disposeFetchPrevious();\n    return refetch(variables, (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, options), {}, {\n      __environment: undefined\n    }));\n  }, [disposeFetchNext, disposeFetchPrevious, refetch]);\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    useDebugValue({\n      fragment: fragmentNode.name,\n      data: fragmentData,\n      hasNext: hasNext,\n      isLoadingNext: isLoadingNext,\n      hasPrevious: hasPrevious,\n      isLoadingPrevious: isLoadingPrevious\n    });\n  }\n\n  return {\n    data: fragmentData,\n    loadNext: loadNext,\n    loadPrevious: loadPrevious,\n    hasNext: hasNext,\n    hasPrevious: hasPrevious,\n    isLoadingNext: isLoadingNext,\n    isLoadingPrevious: isLoadingPrevious,\n    refetch: refetchPagination\n  };\n}\n\nfunction useLoadMore(args) {\n  var _useState = useState(false),\n      isLoadingMore = _useState[0],\n      setIsLoadingMore = _useState[1];\n\n  var observer = {\n    start: function start() {\n      return setIsLoadingMore(true);\n    },\n    complete: function complete() {\n      return setIsLoadingMore(false);\n    },\n    error: function error() {\n      return setIsLoadingMore(false);\n    }\n  };\n\n  var handleReset = function handleReset() {\n    return setIsLoadingMore(false);\n  };\n\n  var _useLoadMoreFunction = useLoadMoreFunction((0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, args), {}, {\n    observer: observer,\n    onReset: handleReset\n  })),\n      loadMore = _useLoadMoreFunction[0],\n      hasMore = _useLoadMoreFunction[1],\n      disposeFetch = _useLoadMoreFunction[2];\n\n  return [loadMore, hasMore, isLoadingMore, disposeFetch];\n}\n\nmodule.exports = usePaginationFragment;","/**\n * Relay v11.0.2\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nmodule.exports = require('./lib/index.js');\n","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar React = require('react');\n\nvar ReactRelayContext = require('./ReactRelayContext');\n\nvar ReactRelayQueryRendererContext = require('./ReactRelayQueryRendererContext');\n\nvar useLayoutEffect = React.useLayoutEffect,\n    useState = React.useState,\n    useRef = React.useRef,\n    useMemo = React.useMemo;\n\nvar _require = require('relay-runtime'),\n    createOperationDescriptor = _require.createOperationDescriptor,\n    deepFreeze = _require.deepFreeze,\n    getRequest = _require.getRequest;\n\nvar areEqual = require(\"fbjs/lib/areEqual\");\n\nvar queryRendererContext = {\n  rootIsQueryRenderer: true\n};\n\nfunction useDeepCompare(value) {\n  var latestValue = React.useRef(value);\n\n  if (!areEqual(latestValue.current, value)) {\n    if (process.env.NODE_ENV !== \"production\") {\n      deepFreeze(value);\n    }\n\n    latestValue.current = value;\n  }\n\n  return latestValue.current;\n}\n\nfunction ReactRelayLocalQueryRenderer(props) {\n  var environment = props.environment,\n      query = props.query,\n      variables = props.variables,\n      render = props.render;\n  var latestVariables = useDeepCompare(variables);\n  var operation = useMemo(function () {\n    var request = getRequest(query);\n    return createOperationDescriptor(request, latestVariables);\n  }, [query, latestVariables]);\n  var relayContext = useMemo(function () {\n    return {\n      environment: environment\n    };\n  }, [environment]); // Use a ref to prevent rendering twice when data changes\n  // because of props change\n\n  var dataRef = useRef(null);\n\n  var _useState = useState(null),\n      forceUpdate = _useState[1];\n\n  var cleanupFnRef = useRef(null);\n  var snapshot = useMemo(function () {\n    environment.check(operation);\n    var res = environment.lookup(operation.fragment);\n    dataRef.current = res.data; // Run effects here so that the data can be retained\n    // and subscribed before the component commits\n\n    var retainDisposable = environment.retain(operation);\n    var subscribeDisposable = environment.subscribe(res, function (newSnapshot) {\n      dataRef.current = newSnapshot.data;\n      forceUpdate(dataRef.current);\n    });\n    var disposed = false;\n\n    function nextCleanupFn() {\n      if (!disposed) {\n        disposed = true;\n        cleanupFnRef.current = null;\n        retainDisposable.dispose();\n        subscribeDisposable.dispose();\n      }\n    }\n\n    if (cleanupFnRef.current) {\n      cleanupFnRef.current();\n    }\n\n    cleanupFnRef.current = nextCleanupFn;\n    return res;\n  }, [environment, operation]);\n  useLayoutEffect(function () {\n    var cleanupFn = cleanupFnRef.current;\n    return function () {\n      cleanupFn && cleanupFn();\n    };\n  }, [snapshot]);\n  return /*#__PURE__*/React.createElement(ReactRelayContext.Provider, {\n    value: relayContext\n  }, /*#__PURE__*/React.createElement(ReactRelayQueryRendererContext.Provider, {\n    value: queryRendererContext\n  }, render({\n    props: dataRef.current\n  })));\n}\n\nmodule.exports = ReactRelayLocalQueryRenderer;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar React = require('react');\n\nvar ReactRelayContext = require('./ReactRelayContext');\n\nvar ReactRelayQueryRendererContext = require('./ReactRelayQueryRendererContext');\n\nvar assertFragmentMap = require('./assertFragmentMap');\n\nvar invariant = require('invariant');\n\nvar readContext = require('./readContext');\n\nvar _require = require('./ReactRelayContainerUtils'),\n    getComponentName = _require.getComponentName,\n    getContainerName = _require.getContainerName;\n\nvar _require2 = require('relay-runtime'),\n    getFragment = _require2.getFragment;\n\n/**\n * Helper to create the Relay HOCs with ref forwarding, setting the displayName\n * and reading the React context.\n */\nfunction buildReactRelayContainer(ComponentClass, fragmentSpec, createContainerWithFragments) {\n  // Sanity-check user-defined fragment input\n  var containerName = getContainerName(ComponentClass);\n  assertFragmentMap(getComponentName(ComponentClass), fragmentSpec);\n  var fragments = {};\n\n  for (var key in fragmentSpec) {\n    fragments[key] = getFragment(fragmentSpec[key]);\n  }\n\n  var Container = createContainerWithFragments(ComponentClass, fragments);\n  Container.displayName = containerName;\n\n  function forwardRef(props, ref) {\n    var _queryRendererContext;\n\n    var context = readContext(ReactRelayContext);\n    !(context != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, '`%s` tried to render a context that was not valid this means that ' + '`%s` was rendered outside of a query renderer.', containerName, containerName) : invariant(false) : void 0;\n    var queryRendererContext = readContext(ReactRelayQueryRendererContext);\n    return /*#__PURE__*/React.createElement(Container, (0, _extends2[\"default\"])({}, props, {\n      __relayContext: context,\n      __rootIsQueryRenderer: (_queryRendererContext = queryRendererContext === null || queryRendererContext === void 0 ? void 0 : queryRendererContext.rootIsQueryRenderer) !== null && _queryRendererContext !== void 0 ? _queryRendererContext : false,\n      componentRef: props.componentRef || ref\n    }));\n  }\n\n  forwardRef.displayName = containerName;\n  var ForwardContainer = React.forwardRef(forwardRef);\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // Used by RelayModernTestUtils\n    ForwardContainer.__ComponentClass = ComponentClass;\n    ForwardContainer.displayName = containerName;\n  } // $FlowFixMe[incompatible-return]\n\n\n  return ForwardContainer;\n}\n\nmodule.exports = buildReactRelayContainer;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar invariant = require('invariant');\n\nvar isRelayEnvironment = require('./isRelayEnvironment');\n\n/**\n * Asserts that the input is a matches the `RelayContext` type defined in\n * `RelayEnvironmentTypes` and returns it as that type.\n */\nfunction assertRelayContext(relay) {\n  !isRelayContext(relay) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayContext: Expected `context.relay` to be an object conforming to ' + 'the `RelayContext` interface, got `%s`.', relay) : invariant(false) : void 0;\n  return relay;\n}\n/**\n * Determine if the input is a plain object that matches the `RelayContext`\n * type defined in `RelayEnvironmentTypes`.\n */\n\n\nfunction isRelayContext(context) {\n  return typeof context === 'object' && context !== null && !Array.isArray(context) && isRelayEnvironment(context.environment);\n}\n\nmodule.exports = {\n  assertRelayContext: assertRelayContext,\n  isRelayContext: isRelayContext\n};","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar React = require('react');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar _require = require('relay-runtime'),\n    requestSubscription = _require.requestSubscription;\n\nfunction useSubscription(config, requestSubscriptionFn) {\n  // N.B. this will re-subscribe every render if config or requestSubscriptionFn\n  // are not memoized.\n  // Please do not pass an object defined in-line.\n  var actualRequestSubscription = requestSubscriptionFn !== null && requestSubscriptionFn !== void 0 ? requestSubscriptionFn : requestSubscription;\n  var environment = useRelayEnvironment();\n  React.useEffect(function () {\n    var _requestSubscription = requestSubscription(environment, config),\n        dispose = _requestSubscription.dispose;\n\n    return dispose;\n  }, [environment, config, actualRequestSubscription]);\n}\n\nmodule.exports = useSubscription;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar React = require('react');\n\nvar useMemoVariables = require('./useMemoVariables');\n\nvar _require = require('relay-runtime'),\n    createOperationDescriptor = _require.createOperationDescriptor,\n    getRequest = _require.getRequest;\n\nvar useMemo = React.useMemo;\n\nfunction useMemoOperationDescriptor(gqlQuery, variables, cacheConfig) {\n  var _useMemoVariables = useMemoVariables(variables),\n      memoVariables = _useMemoVariables[0];\n\n  var _useMemoVariables2 = useMemoVariables(cacheConfig || {}),\n      memoCacheConfig = _useMemoVariables2[0];\n\n  return useMemo(function () {\n    return createOperationDescriptor(getRequest(gqlQuery), memoVariables, memoCacheConfig);\n  }, [gqlQuery, memoVariables, memoCacheConfig]);\n}\n\nmodule.exports = useMemoOperationDescriptor;","/**\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @emails oncall+relay\n * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar ProfilerContext = require('./ProfilerContext');\n\nvar React = require('react');\n\nvar useRelayEnvironment = require('./useRelayEnvironment');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('react'),\n    useContext = _require.useContext,\n    useEffect = _require.useEffect;\n\nfunction EntryPointContainer(_ref) {\n  var entryPointReference = _ref.entryPointReference,\n      props = _ref.props;\n  process.env.NODE_ENV !== \"production\" ? warning(entryPointReference.isDisposed === false, '<EntryPointContainer>: Expected entryPointReference to not be disposed ' + 'yet. This is because disposing the entrypoint marks it for future garbage ' + 'collection, and as such may no longer be present in the Relay store. ' + 'In the future, this will become a hard error.') : void 0;\n  var getComponent = entryPointReference.getComponent,\n      queries = entryPointReference.queries,\n      entryPoints = entryPointReference.entryPoints,\n      extraProps = entryPointReference.extraProps,\n      rootModuleID = entryPointReference.rootModuleID;\n  var Component = getComponent();\n  var profilerContext = useContext(ProfilerContext);\n  var environment = useRelayEnvironment();\n  useEffect(function () {\n    environment.__log({\n      name: 'entrypoint.root.consume',\n      profilerContext: profilerContext,\n      rootModuleID: rootModuleID\n    });\n  }, [environment, profilerContext, rootModuleID]);\n  return /*#__PURE__*/React.createElement(Component, {\n    entryPoints: entryPoints,\n    extraProps: extraProps,\n    props: props,\n    queries: queries\n  });\n}\n\nmodule.exports = EntryPointContainer;"],"sourceRoot":""}