{"version":3,"sources":["webpack://_N_E/./node_modules/relay-runtime/lib/util/isEmptyObject.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayStoreReactFlightUtils.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayStoreSubscriptions.js","webpack://_N_E/./src/NextPageTracking.tsx","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayModernRecord.js","webpack://_N_E/./node_modules/relay-runtime/lib/query/fetchQueryInternal.js","webpack://_N_E/./node_modules/fbjs/lib/warning.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/getFragmentIdentifier.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/objectSpread2.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/createPayloadFor3DField.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayRecordSource.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/RelayReplaySubject.js","webpack://_N_E/./node_modules/relay-runtime/lib/mutations/commitMutation.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/toPrimitive.js","webpack://_N_E/./node_modules/relay-runtime/lib/mutations/commitLocalUpdate.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/cloneRelayHandleSourceField.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/createRelayContext.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayModernSelector.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/recycleNodesInto.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayModernStore.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayModernEnvironment.js","webpack://_N_E/./node_modules/relay-runtime/lib/query/PreloadableQueryRegistry.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/iterableToArray.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/generateID.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/RelayProfiler.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/hasOverlappingIDs.js","webpack://_N_E/./node_modules/relay-runtime/lib/handlers/connection/ConnectionHandler.js","webpack://_N_E/./node_modules/relay-runtime/lib/mutations/RelayDeclarativeMutationConfig.js","webpack://_N_E/./node_modules/relay-runtime/lib/query/fetchQuery_DEPRECATED.js","webpack://_N_E/./node_modules/relay-runtime/lib/mutations/RelayRecordProxy.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayConcreteVariables.js","webpack://_N_E/./node_modules/relay-runtime/lib/handlers/RelayDefaultHandlerProvider.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/DataChecker.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack://_N_E/./node_modules/relay-runtime/lib/mutations/RelayRecordSourceMutator.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/RelayDefaultHandleKey.js","webpack://_N_E/./node_modules/relay-runtime/lib/network/ConvertToExecuteFunction.js","webpack://_N_E//codebuild/output/src112981716/src/MyLifetime/node_modules/next/dist/build/webpack/loaders/next-client-pages-loader.js?7e7d","webpack://_N_E/./node_modules/fbjs/lib/areEqual.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/ViewerPattern.js","webpack://_N_E/./node_modules/relay-runtime/lib/mutations/validateMutation.js","webpack://_N_E/./node_modules/relay-runtime/lib/query/fetchQuery.js","webpack://_N_E/./node_modules/invariant/browser.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/ClientID.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayReader.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/defaultGetDataID.js","webpack://_N_E/./node_modules/relay-runtime/lib/handlers/connection/MutationHandlers.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/resolveImmediate.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/reportMissingRequiredFields.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayOperationTracker.js","webpack://_N_E/./node_modules/relay-runtime/lib/query/GraphQLTag.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayPublishQueue.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/isRelayModernEnvironment.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/typeof.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/TypeID.js","webpack://_N_E/./node_modules/relay-runtime/index.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/getRequestIdentifier.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/RelayError.js","webpack://_N_E/./node_modules/relay-runtime/lib/handlers/connection/ConnectionInterface.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayOptimisticRecordSource.js","webpack://_N_E/./src/relay/createEnvironment/fetchGraphQL.tsx","webpack://_N_E/./src/relay/createEnvironment/index.ts","webpack://_N_E/./src/relay/createEnvironment/client.ts","webpack://_N_E/./src/theme/index.ts","webpack://_N_E/./src/theme/styles.ts","webpack://_N_E/./src/theme/colors.ts","webpack://_N_E/./src/theme/fonts.ts","webpack://_N_E/./src/theme/components/button.ts","webpack://_N_E/./src/theme/components/text.ts","webpack://_N_E/./src/theme/components/checkbox.ts","webpack://_N_E/./src/pages/_app.tsx","webpack://_N_E/./src/styles/font-face.ts","webpack://_N_E/./node_modules/relay-runtime/lib/store/createFragmentSpecResolver.js","webpack://_N_E/./node_modules/relay-runtime/lib/mutations/RelayRecordSourceProxy.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/OperationExecutor.js","webpack://_N_E/./node_modules/relay-runtime/lib/mutations/applyOptimisticMutation.js","webpack://_N_E/./node_modules/relay-runtime/lib/network/RelayQueryResponseCache.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/RelayFeatureFlags.js","webpack://_N_E/./node_modules/@babel/runtime/helpers/toPropertyKey.js","webpack://_N_E/./node_modules/fbjs/lib/emptyFunction.js","webpack://_N_E/./node_modules/relay-runtime/lib/network/RelayNetwork.js","webpack://_N_E/./node_modules/relay-runtime/lib/network/RelayObservable.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayModernOperationDescriptor.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayRecordState.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayStoreSubscriptionsUsingMapByID.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/ResolverFragments.js","webpack://_N_E/./node_modules/relay-runtime/lib/subscription/requestSubscription.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/getRelayHandleKey.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/getOperation.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayModernFragmentSpecResolver.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/RelayConcreteNode.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayStoreUtils.js","webpack://_N_E/./node_modules/relay-runtime/lib/mutations/RelayRecordSourceSelectorProxy.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayResponseNormalizer.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/defaultRequiredFieldLogger.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/isScalarAndEqual.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/isPromise.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/cloneRelayScalarHandleSourceField.js","webpack://_N_E/./node_modules/relay-runtime/lib/index.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayReferenceMarker.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/RelayRecordSourceMapImpl.js","webpack://_N_E/./node_modules/relay-runtime/lib/store/readInlineData.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/stableCopy.js","webpack://_N_E/./node_modules/relay-runtime/lib/util/deepFreeze.js"],"names":["hasOwnProperty","Object","prototype","module","exports","obj","_key","call","invariant","getType","REACT_FLIGHT_TREE_STORAGE_KEY","REACT_FLIGHT_TYPE_NAME","REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY","getReactFlightClientResponse","record","response","refineToReactFlightPayloadData","payload","status","Array","isArray","tree","queries","fragments","errors","RelayFeatureFlags","RelayReader","hasOverlappingIDs","recycleNodesInto","RelayStoreSubscriptions","log","this","_subscriptions","Set","__log","_proto","subscribe","snapshot","callback","_this","subscription","backup","stale","add","dispose","snapshotSubscriptions","source","forEach","read","selector","nextData","data","restoreSubscriptions","isMissingData","seenRecords","missingRequiredFields","updateSubscriptions","updatedRecordIDs","updatedOwners","sourceOperation","_this2","hasUpdatedRecords","size","owner","_updateSubscription","push","hasOverlappingUpdates","nextSnapshot","ENABLE_NOTIFY_SUBSCRIPTION","name","NextPageTracking","router","useRouter","handleRouteChange","url","page","getPageFromUrl","URL","pathname","TRACKING_ENABLED","global","analytics","useEffect","events","on","off","_objectSpread2","_interopRequireDefault","areEqual","deepFreeze","_require2","isClientID","ID_KEY","REF_KEY","REFS_KEY","TYPENAME_KEY","INVALIDATED_AT_KEY","ROOT_ID","clone","copyFields","sink","key","create","dataID","typeName","freeze","getDataID","getInvalidationEpoch","invalidatedAt","getLinkedRecordID","storageKey","link","getLinkedRecordIDs","links","getValue","value","merge","record1","record2","assign","setValue","setLinkedRecordID","linkedID","setLinkedRecordIDs","linkedIDs","update","prevRecord","nextRecord","updated","keys","ii","length","Observable","RelayReplaySubject","requestCachesByEnvironment","WeakMap","Map","fetchQueryDeduped","environment","identifier","fetchFn","requestCache","getRequestCache","cachedRequest","get","start","subject","subjectForInFlightStatus","set","next","cachedReq","getCachedRequest","error","_error","complete","unsubscribe","cachedRequestInstance","requestSubscription","getObserverCount","getObservableForCachedRequest","getActiveStatusObservableForCachedRequest","isRequestActive","cached","fetchQuery","operation","request","execute","getPromiseForActiveRequest","Promise","resolve","reject","resolveOnNext","getObservableForActiveRequest","warning","isEmptyObject","stableCopy","_require","getDataIDsFromFragment","getVariablesFromFragment","getSelector","fragmentNode","fragmentRef","_JSON$stringify","fragmentOwnerIdentifier","kind","selectors","map","sel","join","fragmentVariables","dataIDs","ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION","JSON","stringify","defineProperty","ownKeys","e","r","t","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","apply","arguments","getOwnPropertyDescriptors","defineProperties","__esModule","getModuleComponentKey","getModuleOperationKey","component","RelayRecordSourceMapImpl","RelayRecordSource","records","_defineProperty2","RelayObservable","_observable","_sinks","_events","i","closed","event","_complete","observer","_subscription","_toConsumableArray2","RelayDeclarativeMutationConfig","isRelayModernEnvironment","getRequest","generateUniqueClientID","createOperationDescriptor","config","mutation","params","operationKind","Error","optimisticResponse","optimisticUpdater","updater","configs","cacheConfig","onError","onUnsubscribe","variables","uploadables","_RelayDeclarativeMuta","convert","executeMutation","item","onCompleted","lookup","fragment","_typeof","input","hint","prim","Symbol","toPrimitive","undefined","res","TypeError","String","Number","commitUpdate","LINKED_FIELD","getHandleStorageKey","handleField","selections","sourceField","find","alias","args","handleKey","concreteType","plural","relayContext","firstReact","react","createContext","getFragmentVariables","FRAGMENT_OWNER_KEY","FRAGMENTS_KEY","IS_WITHIN_UNMATCHED_TYPE_REFINEMENT","getSingularSelector","mixedOwner","isWithinUnmatchedTypeRefinement","argumentVariables","createReaderSelector","getPluralSelector","items","metadata","ids","id","getDataIDs","_fragment$metadata","getVariablesFromPluralFragment","getVariablesFromSingularFragment","itemVariables","node","areEqualSelectors","thisSelector","thatSelector","createNormalizationSelector","getDataIDsFromObject","object","_key2","getSelectorsFromObject","getVariablesFromObject","_key3","hasWeakSetDefined","WeakSet","hasWeakMapDefined","prevData","canRecycle","prevArray","nextArray","reduce","wasEqual","nextItem","nextValue","prevObject","nextObject","prevKeys","nextKeys","_createForOfIteratorHelper2","DataChecker","RelayModernRecord","RelayOptimisticRecordSource","RelayReferenceMarker","RelayStoreReactFlightUtils","RelayStoreSubscriptionsUsingMapByID","RelayStoreUtils","defaultGetDataID","resolveImmediate","ROOT_TYPE","RelayModernStore","options","_options$gcReleaseBuf","_options$gcScheduler","_options$getDataID","_options$log","_options$operationLoa","_gcRun","done","_gcScheduler","_gcStep","_currentWriteEpoch","_gcHoldCounter","_gcReleaseBufferSize","gcReleaseBufferSize","gcScheduler","_getDataID","_globalInvalidationEpoch","_invalidationSubscriptions","_invalidatedRecordIDs","_queryCacheExpirationTime","queryCacheExpirationTime","_operationLoader","operationLoader","_optimisticSource","_recordSource","_releaseBuffer","_roots","_shouldScheduleGC","_storeSubscriptions","ENABLE_STORE_SUBSCRIPTIONS_REFACTOR","_updatedRecordIDs","_shouldProcessClientComponents","shouldProcessClientComponents","target","has","rootRecord","initializeRecordSource","getSource","_this$_optimisticSour","check","_this$_optimisticSour2","_options$target","_options$handlers","root","globalInvalidationEpoch","rootEntry","operationLastWrittenAt","epoch","handlers","operationAvailability","operationFetchTime","mostRecentlyInvalidatedAt","Date","now","fetchTime","getAvailabilityStatus","retain","disposed","refCount","_id","scheduleGC","shift","notify","invalidateStore","_this3","_updateInvalidationSubscription","invalidatedRecordIDs","clear","temporaryRootEntry","publish","idsMarkedForInvalidation","_this$_optimisticSour3","currentWriteEpoch","targetRecord","sourceRecord","getRecordIDs","updateTargetFromSource","optimistic","holdGC","_this4","toJSON","__getUpdatedRecordIDs","lookupInvalidationState","_this5","invalidations","_RelayModernRecord$ge","checkInvalidationState","prevInvalidationState","currentInvalidations","prevInvalidations","_step","_iterator","s","n","err","f","subscribeToInvalidationState","invalidationState","_this6","invalidatedStore","_this7","some","restore","_collect","__gc","gcRun","top","_step2","startEpoch","references","_iterator2","values","mark","storeIDs","remove","OperationExecutor","RelayDefaultHandlerProvider","RelayOperationTracker","RelayPublishQueue","defaultRequiredFieldLogger","generateID","RelayModernEnvironment","_config$log","_config$requiredField","_config$UNSTABLE_defa","_config$getDataID","_config$handlerProvid","_config$scheduler","_config$isServer","_config$operationTrac","configName","_treatMissingFieldsAsNull","treatMissingFieldsAsNull","reactFlightPayloadDeserializer","reactFlightServerErrorHandler","emptyFunction","requiredFieldLogger","_defaultRenderPolicy","UNSTABLE_defaultRenderPolicy","ENABLE_PARTIAL_RENDERING_DEFAULT","_operationExecutions","_network","__wrapNetworkWithLogObserver","network","_publishQueue","store","handlerProvider","_scheduler","scheduler","_store","_isServer","isServer","__setNet","newNet","_global","window","devToolsHook","__RELAY_DEVTOOLS_HOOK__","registerEnvironment","_missingFieldHandlers","missingFieldHandlers","_operationTracker","operationTracker","_reactFlightPayloadDeserializer","_reactFlightServerErrorHandler","getStore","getNetwork","getOperationTracker","requestIdentifier","UNSTABLE_getDefaultRenderPolicy","applyUpdate","optimisticUpdate","_scheduleUpdates","run","revertUpdate","replaceUpdate","newUpdate","applyMutation","optimisticConfig","_execute","createSource","_sink","isClientPayload","_checkSelectorAndHandleMissingFields","commitPayload","from","readSelector","result","commitSource","task","schedule","_ref","_ref2","_this8","force","executeWithSource","_ref3","_this$configName","concat","_ref4","_this9","executor","operationExecutions","publishQueue","cancel","that","transactionID","logObserver","info","preloadableQueryRegistry","PreloadableQueryRegistry","_preloadableQueries","_callbacks","callbacks","cb","setTimeout","onLoad","_this$_callbacks$get","iter","iterator","profileHandlersByName","defaultProfiler","stop","RelayProfiler","profile","state","stopHandlers","stopHandler","unshift","attachProfileHandler","handler","detachProfileHandler","array","element","index","indexOf","splice","removeFromArray","ITERATOR_KEY","ConnectionInterface","getRelayHandleKey","generateClientID","getStableStorageKey","CONNECTION","NEXT_EDGE_INDEX","buildConnectionEdge","connection","edge","EDGES","edgeIndex","edgeID","connectionEdge","copyFieldsFrom","mergeEdges","sourceEdges","targetEdges","nodeIDs","NODE","getLinkedRecord","nodeID","createEdge","edgeType","setLinkedRecord","deleteNode","_ConnectionInterface$5","edges","getLinkedRecords","nextEdges","slice","setLinkedRecords","getConnection","filters","getConnectionID","recordID","insertEdgeAfter","newEdge","cursor","_ConnectionInterface$2","CURSOR","foundCursor","insertEdgeBefore","_ConnectionInterface$4","_ConnectionInterface$","END_CURSOR","HAS_NEXT_PAGE","HAS_PREV_PAGE","PAGE_INFO","PAGE_INFO_TYPE","START_CURSOR","serverConnection","fieldKey","serverPageInfo","clientConnectionID","clientConnectionField","clientConnection","clientPageInfo","_connection","_serverEdges","prevEdges","prevPageInfo","after","before","_nodeIDs","last","startCursor","first","endCursor","serverEdges","ConnectionHandler","MutationTypes","RANGE_ADD","RANGE_DELETE","NODE_DELETE","RangeOperations","APPEND","PREPEND","getRootField","configOptimisticUpdates","configUpdates","type","nodeDeleteResult","deletedIDFieldName","rootField","deleteID","nodeDelete","rangeAddResult","parentID","connectionInfo","edgeName","parent","serverEdge","clientEdge","rangeBehavior","rangeAdd","rangeDeleteResult","connectionKeys","pathToConnection","deleteIDs","deletedIDField","eachField","idObject","recordProxy","_step3","_iterator3","_loop","rangeDelete","eachOptimisticUpdater","eachUpdater","taggedNode","query","toPromise","RelayRecordProxy","mutator","_dataID","_mutator","_source","isValidLeafValue","getOrCreateLinkedRecord","linkedRecord","_this$_source$get","clientID","invalidateRecord","markIDForInvalidation","every","rootVariables","argumentDefinitions","definition","defaultValue","getOperationVariables","operationVariables","def","MutationHandlers","handle","DeleteRecordHandler","DeleteEdgeHandler","AppendEdgeHandler","PrependEdgeHandler","AppendNodeHandler","PrependNodeHandler","RelayConcreteNode","RelayRecordSourceMutator","RelayRecordSourceProxy","cloneRelayHandleSourceField","cloneRelayScalarHandleSourceField","getOperation","EXISTENT","UNKNOWN","generateTypeID","CONDITION","CLIENT_COMPONENT","CLIENT_EXTENSION","DEFER","FLIGHT_FIELD","FRAGMENT_SPREAD","INLINE_FRAGMENT","LINKED_HANDLE","MODULE_IMPORT","SCALAR_FIELD","SCALAR_HANDLE","STREAM","TYPE_DISCRIMINATOR","getStorageKey","getArgumentValues","_mostRecentlyInvalidatedAt","_handlers","_recordSourceProxy","_recordWasMissing","_variables","_traverse","_getVariableValue","_handleMissing","_getDataForHandlers","field","_handleMissingScalarField","_this$_getDataForHand","newValue","_handleMissingLinkField","_this$_getDataForHand2","getStatus","_handleMissingPluralLinkField","_this$_getDataForHand3","Math","max","_traverseSelections","selection","_checkScalar","_checkPluralLink","_checkLink","condition","passingValue","abstractKey","ENABLE_PRECISE_TYPE_REFINEMENT","recordType","typeID","implementsInterface","_handleField","_checkModuleImport","recordWasMissing","_abstractKey","_recordType","_typeID","ENABLE_REACT_FLIGHT_COMPONENT_FIELD","_checkFlightField","moduleImport","operationKey","documentName","operationReference","normalizationRootNode","fieldValue","reachableExecutableDefinitions","_step4","prevVariables","_iterator4","arrayLikeToArray","arr","base","__sources","_base","unstable_getRawRecordWithChanges","baseRecord","sinkRecord","_getSinkRecord","sourceID","sinkID","sinkSource","baseSource","copyFieldsFromRecord","DEFAULT_HANDLE_KEY","convertFetch","fn","logRequestInfo","__NEXT_P","aStackPool","bStackPool","eq","a","b","aStack","bStack","objToStr","toString","className","isNaN","multiline","ignoreCase","constructor","valueOf","pop","VIEWER_ID","VIEWER_TYPE","fetchQueryInternal","reportMissingRequiredFields","getNetworkObservable","_options$fetchPolicy","queryNode","networkCacheConfig","fetchPolicy","readData","format","c","d","argIndex","replace","framesToPop","arrayWithoutHoles","iterableToArray","unsupportedIterableToArray","nonIterableSpread","PREFIX","localID","INLINE_DATA_FRAGMENT_SPREAD","REQUIRED_FIELD","RELAY_RESOLVER","_require3","FRAGMENT_PROP_NAME_KEY","MODULE_COMPONENT_KEY","withResolverContext","recordSource","_isMissingData","_isWithinUnmatchedTypeRefinement","_missingRequiredFields","_owner","_seenRecords","_selector","_this$_selector","isDataExpectedToBePresent","typeRecord","_maybeReportUnexpectedNull","fieldPath","action","_this$_missingRequire","path","fields","ENABLE_REQUIRED_DIRECTIVES","_readRequiredField","_readScalar","_readPluralLink","_readLink","parentIsMissingData","parentIsWithinUnmatchedTypeRefinement","_typeName","ENABLE_RELAY_RESOLVERS","_readResolverField","_createFragmentPointer","_readModuleImport","_createInlineDataOrResolverFragmentPointer","_hasExpectedData2","_readFlightField","resolverModule","__id","__fragmentOwner","__fragments","resolverResult","getDataForResolverFragment","singularReaderSelector","_resolverFragmentData","resolverFragmentData","answer","_field$alias","applicationName","reactFlightClientResponseRecordID","reactFlightClientResponseRecord","clientResponse","_field$alias2","_field$alias3","_field$alias4","linkedArray","nextIndex","prevItem","componentKey","fragmentName","fragmentPropName","fragmentSpread","fragmentPointers","fragmentSpreadOrFragment","inlineData","idOrIds","connections","handleArgs","connectionID","edgeUpdater","nodeUpdater","insertFn","singleServerEdge","_unused","_unused2","serverEdgeList","serverNode","serverNodeId","_connection$getLinked","_edge$getLinkedRecord","_serverNodes","singleServerNode","serverNodes","_payload$handleArgs","edgeTypeName","_unused3","_unused4","serverNodeList","_loop2","_step5","_iterator5","_connection$getLinked2","_edge$getLinkedRecord2","resolvedPromise","throwNext","then","len","arr2","allowArrayLike","it","F","_e","normalCompletion","didErr","step","_e2","_missingRequiredField","_ownersToPendingOperationsIdentifier","_pendingOperationsToOwnersIdentifier","_ownersIdentifierToPromise","pendingOperation","affectedOwners","pendingOperationIdentifier","newlyAffectedOwnersIdentifier","ownerIdentifier","pendingOperationsAffectingOwner","ownersAffectedByOperationIdentifier","_ownerIdentifier","_resolveOwnerResolvers","affectedOwnersIdentifier","completedOwnersIdentifier","updatedOwnersIdentifier","_ownerIdentifier2","_ownerIdentifier3","promiseEntry","getPromiseForPendingOperationsAffectingOwner","cachedPromiseEntry","promise","getNode","isFragment","FRAGMENT","isRequest","REQUEST","isInlineDataFragment","INLINE_DATA_FRAGMENT","getFragment","getPaginationFragment","refetch","getRefetchableFragment","_fragment$metadata2","getInlineDataFragment","graphql","strings","_global$ErrorUtils$ap","_global$ErrorUtils","RelayRecordSourceSelectorProxy","applyWithGuard","ErrorUtils","context","_hasStoreSnapshot","_handlerProvider","_pendingBackupRebase","_pendingData","_pendingOptimisticUpdates","_appliedOptimisticUpdates","_gcHold","revertAll","_commitData","_applyUpdates","_publishSourceFromPayload","pendingPayload","fieldPayloads","recordSourceProxy","fieldPayload","lookupSelector","getIDsMarkedForInvalidation","isStoreMarkedForInvalidation","payloadInvalidatedStore","processUpdate","storeUpdater","selectorData","recordSourceSelectorProxy","publishSource","minLen","test","Boolean","isTypeID","TYPE_SCHEMA_TYPE","parameters","requestID","cacheID","createError","messageFormat","_len","messageParams","message","taalOpcodes","stack","_len2","createWarning","_len3","CONNECTION_CALLS","surrounds","CLIENT_MUTATION_ID","inject","newConfig","isConnectionCall","UNPUBLISH_RECORD_SENTINEL","__UNPUBLISH_RECORD_SENTINEL","merged","fetchGraphQL","fetch","getUrl","method","credentials","headers","Accept","body","text","json","createEnvironment","Network","Environment","Store","RecordSource","overrides","styles","bg","color","minWidth","_hover","textDecoration","colors","transparent","black","white","grey","50","100","300","400","900","red","blue","200","500","800","orange","yellow","green","teal","fonts","heading","mono","digit","components","Button","baseStyle","fontWeight","sizes","md","fontSize","variants","defaultProps","colorScheme","Text","Checkbox","control","padding","_checked","extendTheme","init","App","children","MyLifetimeContainer","Component","pageProps","theme","flex","display","flexDirection","maxW","p","bgColor","RelayModernFragmentSpecResolver","containerName","props","rootIsQueryRenderer","NONEXISTENT","__mutator","_proxies","_invalidatedStore","_idsMarkedForInvalidation","getRoot","toPropertyKey","configurable","writable","RelayError","RelayResponseNormalizer","Executor","_incrementalPayloadsPending","_incrementalResults","_nextSubscriptionId","_operation","_operationUpdateEpochs","_optimisticUpdates","_pendingModulePayloadsCount","_state","_updater","_isClientPayload","_isSubscriptionOperation","_error2","_next","_start","_processOptimisticResponse","sub","optimisticUpdates","_completeOperationTracker","_retainDisposable","_updateActiveState","activeState","_schedule","_id2","cancellationToken","_error3","_handleNext","_maybeCompleteSubscriptionOperationTracking","_handleErrorResponse","responses","results","extensions","messages","responseWithData","_handleOptimisticResponses","_response$extensions","responsePart","_responsePart$extensi","isOptimistic","responsesWithData","x","_x$extensions","is_final","_partitionGraphQLResp","nonIncrementalResponses","incrementalResponses","label","partitionGraphQLResponses","hasNonIncrementalResponses","payloadFollowups","_processResponses","ENABLE_BATCHED_STORE_UPDATES","_updateOperationTracker","_processPayloadFollowups","_payloadFollowups","_processIncrementalResponses","_updatedOwners","ENABLE_UNIQUE_SUBSCRIPTION_ROOT","__relay_subscription_root_id","_updatedOwners2","normalizeResponse","validateOptimisticResponsePayload","_processOptimisticFollowups","incrementalPlaceholders","moduleImportPayloads","isFinal","moduleImportPayload","_processAsyncOptimisticModuleImport","moduleImportOptimisticUpdates","_processOptimisticModuleImport","_normalizeModuleImport","modulePayload","load","_this$_optimisticUpda","payloadPart","relayPayload","payloads","_processModuleImportPayload","incrementalPlaceholder","_processIncrementalPlaceholder","relayPayloads","placeholder","_processDeferResponse","nextID","_this10","_handleModuleImportPayload","_id3","decrementPendingCount","_error4","_relayPayload$fieldPa","pathKey","resultForLabel","resultForPath","pendingResponses","nextParentRecord","nextParentPayloads","parentRecord","parentPayloads","fieldID","previousParentEntry","handlePayloads","dedupePayload","stableStringify","_this11","incrementalResponse","_pathKey","_resultForPath","_placeholder","_processStreamResponse","parentEntry","_response$extensions2","handleFieldsRelayPayload","_this$_normalizeStrea","_normalizeStreamItem","itemID","itemIndex","prevIDs","currentParentRecord","currentItems","currentItem","nextItems","normalizationPath","_field$concreteType","_this$_getDataID","responseKey","finalPathEntry","parseInt","nextIDs","_response$extensions3","normalize","RelayQueryResponseCache","ttl","_responses","_size","_ttl","queryID","cacheKey","getCacheKey","cacheTimestamp","firstKey","ENABLE_VARIABLE_CONNECTION_KEY","ENABLE_RELAY_CONTAINERS_SUSPENSE","ENABLE_FRIENDLY_QUERY_NAME_GQL_URL","ENABLE_LOAD_QUERY_REQUEST_DEDUPING","ENABLE_DO_NOT_WRAP_LIVE_QUERY","arg","makeEmptyFunction","thatReturns","thatReturnsFalse","thatReturnsTrue","thatReturnsNull","thatReturnsThis","thatReturnsArgument","observeFetch","pollInterval","poll","isPromise","hostReportError","_isUncaughtThrownError","onUnhandledError","isObservable","fromObservable","fromPromise","fromValue","error2","current","both","ifEmpty","alternate","hasValue","cleanup","withClosed","doCleanup","isUncaughtThrownError","_subscribe","mapValue","mergeMap","subscriptions","_sub","timeout","clearTimeout","resolved","val","getRequestIdentifier","createRequestDescriptor","requestDescriptor","operationDescriptor","_notifiedRevision","_snapshotRevision","_subscriptionsByDataId","_staleSubscriptions","notifiedRevision","snapshotRevision","dataId","subscriptionsForDataId","prevSeenRecords","_updateSubscriptionsMap","updatedRecordId","subcriptionsForDataId","_dataId","_subscriptionsForDataId","contextStack","readFragment","fragmentInput","fragmentSelector","onNext","_responses$","_responses$$extension","_responses$extensions","handleName","fieldName","SPLIT_OPERATION","isScalarAndEqual","_stale","_callback","_context","_data","_fragments","_props","_resolvers","_rootIsQueryRenderer","setProps","disposeCallback","resolver","prop","_nextItem","setCallback","ownedSelectors","ownedSelector","SelectorListResolver","_onChange","setSelector","SelectorResolver","setVariables","_key4","_snapshot","_environment","_proto2","_getPromiseForActiveR","_proto3","disposable","LITERAL","LIST_VALUE","LOCAL_ARGUMENT","OBJECT_VALUE","OPERATION","ROOT_ARGUMENT","VARIABLE","getArgumentValue","getStableVariableValue","variableName","_value","formatStorageKey","argValues","argName","dynamicKey","filterArgs","__recordSource","_readSelector","getOperationRoot","_getRootField","getPluralRootField","_require4","_require5","_require6","_getDataId","_handleFieldPayloads","_incrementalPlaceholders","_isClientExtension","_isUnmatchedAbstractType","_moduleImportPayloads","_path","_getRecordType","_normalizeField","_typeName2","_implementsInterface","parentIsUnmatchedAbstractType","_implementsInterface2","_typeName3","_typeRecord","_normalizeDefer","_normalizeStream","isClientExtension","_normalizeFlightField","defer","stream","componentReference","_normalizePluralLink","_normalizeLink","reactFlightPayload","reactFlightID","reactFlightClientResponse","__typename","_typeName4","_field$concreteType2","_typeName5","_validateRecordType","_field$concreteType3","_validateConflictingFieldsWithIdenticalId","_validateConflictingLinkedFieldsWithIdenticalId","prevID","valueA","valueB","GraphQLTag","RelayConcreteVariables","RelayDefaultHandleKey","RelayModernOperationDescriptor","RelayModernSelector","RelayNetwork","ViewerPattern","applyOptimisticMutation","commitLocalUpdate","commitMutation","createFragmentSpecResolver","createPayloadFor3DField","createRelayContext","fetchQuery_DEPRECATED","getFragmentIdentifier","readInlineData","QueryResponseCache","Record","ReplaySubject","DefaultHandlerProvider","__internal","OperationTracker","_operationName","_references","_traversePluralLink","_traverseLink","_traverseModuleImport","_traverseFlightField","RelayRecordState","RelayMapRecordSourceMapImpl","_records","_step$value","_fragmentRef$FRAGMENT","inlineDataFragment","sort","stable","getOwnPropertyNames","property","isFrozen"],"mappings":"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","file":"static/chunks/pages/_app-60c1a61c3639b8ed56d2.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 * \n * @format\n * @emails oncall+relay\n */\n'use strict';\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction isEmptyObject(obj) {\n  for (var _key in obj) {\n    if (hasOwnProperty.call(obj, _key)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nmodule.exports = isEmptyObject;","/**\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 _require = require('./RelayModernRecord'),\n    getType = _require.getType;\n\n// Reachable (client) executable definitions encountered while server component\n// rendering\nvar REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY = 'executableDefinitions';\nvar REACT_FLIGHT_TREE_STORAGE_KEY = 'tree';\nvar REACT_FLIGHT_TYPE_NAME = 'ReactFlightComponent';\n\nfunction refineToReactFlightPayloadData(payload) {\n  if (payload == null || typeof payload !== 'object' || typeof payload.status !== 'string' || !Array.isArray(payload.tree) && payload.tree !== null || !Array.isArray(payload.queries) || !Array.isArray(payload.fragments) || !Array.isArray(payload.errors)) {\n    return null;\n  }\n\n  return payload;\n}\n\nfunction getReactFlightClientResponse(record) {\n  !(getType(record) === REACT_FLIGHT_TYPE_NAME) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'getReactFlightClientResponse(): Expected a ReactFlightComponentRecord, ' + 'got %s.', record) : invariant(false) : void 0;\n  var response = record[REACT_FLIGHT_TREE_STORAGE_KEY];\n\n  if (response != null) {\n    return response;\n  }\n\n  return null;\n}\n\nmodule.exports = {\n  REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY: REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,\n  REACT_FLIGHT_TREE_STORAGE_KEY: REACT_FLIGHT_TREE_STORAGE_KEY,\n  REACT_FLIGHT_TYPE_NAME: REACT_FLIGHT_TYPE_NAME,\n  getReactFlightClientResponse: getReactFlightClientResponse,\n  refineToReactFlightPayloadData: refineToReactFlightPayloadData\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 RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar RelayReader = require('./RelayReader');\n\nvar deepFreeze = require('../util/deepFreeze');\n\nvar hasOverlappingIDs = require('./hasOverlappingIDs');\n\nvar recycleNodesInto = require('../util/recycleNodesInto');\n\nvar RelayStoreSubscriptions = /*#__PURE__*/function () {\n  function RelayStoreSubscriptions(log) {\n    this._subscriptions = new Set();\n    this.__log = log;\n  }\n\n  var _proto = RelayStoreSubscriptions.prototype;\n\n  _proto.subscribe = function subscribe(snapshot, callback) {\n    var _this = this;\n\n    var subscription = {\n      backup: null,\n      callback: callback,\n      snapshot: snapshot,\n      stale: false\n    };\n\n    var dispose = function dispose() {\n      _this._subscriptions[\"delete\"](subscription);\n    };\n\n    this._subscriptions.add(subscription);\n\n    return {\n      dispose: dispose\n    };\n  };\n\n  _proto.snapshotSubscriptions = function snapshotSubscriptions(source) {\n    this._subscriptions.forEach(function (subscription) {\n      // Backup occurs after writing a new \"final\" payload(s) and before (re)applying\n      // optimistic changes. Each subscription's `snapshot` represents what was *last\n      // published to the subscriber*, which notably may include previous optimistic\n      // updates. Therefore a subscription can be in any of the following states:\n      // - stale=true: This subscription was restored to a different value than\n      //   `snapshot`. That means this subscription has changes relative to its base,\n      //   but its base has changed (we just applied a final payload): recompute\n      //   a backup so that we can later restore to the state the subscription\n      //   should be in.\n      // - stale=false: This subscription was restored to the same value as\n      //   `snapshot`. That means this subscription does *not* have changes relative\n      //   to its base, so the current `snapshot` is valid to use as a backup.\n      if (!subscription.stale) {\n        subscription.backup = subscription.snapshot;\n        return;\n      }\n\n      var snapshot = subscription.snapshot;\n      var backup = RelayReader.read(source, snapshot.selector);\n      var nextData = recycleNodesInto(snapshot.data, backup.data);\n      backup.data = nextData; // backup owns the snapshot and can safely mutate\n\n      subscription.backup = backup;\n    });\n  };\n\n  _proto.restoreSubscriptions = function restoreSubscriptions() {\n    this._subscriptions.forEach(function (subscription) {\n      var backup = subscription.backup;\n      subscription.backup = null;\n\n      if (backup) {\n        if (backup.data !== subscription.snapshot.data) {\n          subscription.stale = true;\n        }\n\n        subscription.snapshot = {\n          data: subscription.snapshot.data,\n          isMissingData: backup.isMissingData,\n          seenRecords: backup.seenRecords,\n          selector: backup.selector,\n          missingRequiredFields: backup.missingRequiredFields\n        };\n      } else {\n        subscription.stale = true;\n      }\n    });\n  };\n\n  _proto.updateSubscriptions = function updateSubscriptions(source, updatedRecordIDs, updatedOwners, sourceOperation) {\n    var _this2 = this;\n\n    var hasUpdatedRecords = updatedRecordIDs.size !== 0;\n\n    this._subscriptions.forEach(function (subscription) {\n      var owner = _this2._updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords, sourceOperation);\n\n      if (owner != null) {\n        updatedOwners.push(owner);\n      }\n    });\n  }\n  /**\n   * Notifies the callback for the subscription if the data for the associated\n   * snapshot has changed.\n   * Additionally, updates the subscription snapshot with the latest snapshot,\n   * and marks it as not stale.\n   * Returns the owner (RequestDescriptor) if the subscription was affected by the\n   * latest update, or null if it was not affected.\n   */\n  ;\n\n  _proto._updateSubscription = function _updateSubscription(source, subscription, updatedRecordIDs, hasUpdatedRecords, sourceOperation) {\n    var backup = subscription.backup,\n        callback = subscription.callback,\n        snapshot = subscription.snapshot,\n        stale = subscription.stale;\n    var hasOverlappingUpdates = hasUpdatedRecords && hasOverlappingIDs(snapshot.seenRecords, updatedRecordIDs);\n\n    if (!stale && !hasOverlappingUpdates) {\n      return;\n    }\n\n    var nextSnapshot = hasOverlappingUpdates || !backup ? RelayReader.read(source, snapshot.selector) : backup;\n    var nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);\n    nextSnapshot = {\n      data: nextData,\n      isMissingData: nextSnapshot.isMissingData,\n      seenRecords: nextSnapshot.seenRecords,\n      selector: nextSnapshot.selector,\n      missingRequiredFields: nextSnapshot.missingRequiredFields\n    };\n\n    if (process.env.NODE_ENV !== \"production\") {\n      deepFreeze(nextSnapshot);\n    }\n\n    subscription.snapshot = nextSnapshot;\n    subscription.stale = false;\n\n    if (nextSnapshot.data !== snapshot.data) {\n      if (this.__log && RelayFeatureFlags.ENABLE_NOTIFY_SUBSCRIPTION) {\n        this.__log({\n          name: 'store.notify.subscription',\n          sourceOperation: sourceOperation,\n          snapshot: snapshot,\n          nextSnapshot: nextSnapshot\n        });\n      }\n\n      callback(nextSnapshot);\n      return snapshot.selector.owner;\n    }\n  };\n\n  return RelayStoreSubscriptions;\n}();\n\nmodule.exports = RelayStoreSubscriptions;","import { useEffect } from 'react'\nimport { useRouter } from 'next/router'\nimport { getPageFromUrl } from '@/routes'\nimport { TRACKING_ENABLED } from '@/constant'\n\nconst NextPageTracking = () => {\n  const router = useRouter()\n  const handleRouteChange = (url: string) => {\n    // have this here as needed to form url\n    // we never use the base url\n    const page = getPageFromUrl(new URL(url, 'https://www.mylifetime.co.nz').pathname)\n    if (TRACKING_ENABLED) {\n      global.analytics.page(page)\n    }\n  }\n  useEffect(() => {\n    handleRouteChange(router.pathname)\n  }, [])\n\n  useEffect(() => {\n    router.events.on('routeChangeComplete', handleRouteChange)\n    return () => {\n      router.events.off('routeChangeComplete', handleRouteChange)\n    }\n  }, [router.events])\n  return null\n}\nexport default NextPageTracking\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 areEqual = require(\"fbjs/lib/areEqual\");\n\nvar deepFreeze = require('../util/deepFreeze');\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('./ClientID'),\n    isClientID = _require.isClientID;\n\nvar _require2 = require('./RelayStoreUtils'),\n    ID_KEY = _require2.ID_KEY,\n    REF_KEY = _require2.REF_KEY,\n    REFS_KEY = _require2.REFS_KEY,\n    TYPENAME_KEY = _require2.TYPENAME_KEY,\n    INVALIDATED_AT_KEY = _require2.INVALIDATED_AT_KEY,\n    ROOT_ID = _require2.ROOT_ID;\n\n/**\n * @public\n *\n * Low-level record manipulation methods.\n *\n * A note about perf: we use long-hand property access rather than computed\n * properties in this file for speed ie.\n *\n *    const object = {};\n *    object[KEY] = value;\n *    record[storageKey] = object;\n *\n * instead of:\n *\n *    record[storageKey] = {\n *      [KEY]: value,\n *    };\n *\n * The latter gets transformed by Babel into something like:\n *\n *    function _defineProperty(obj, key, value) {\n *      if (key in obj) {\n *        Object.defineProperty(obj, key, {\n *          value: value,\n *          enumerable: true,\n *          configurable: true,\n *          writable: true,\n *        });\n *      } else {\n *        obj[key] = value;\n *      }\n *      return obj;\n *    }\n *\n *    record[storageKey] = _defineProperty({}, KEY, value);\n *\n * A quick benchmark shows that computed property access is an order of\n * magnitude slower (times in seconds for 100,000 iterations):\n *\n *               best     avg     sd\n *    computed 0.02175 0.02292 0.00113\n *      manual 0.00110 0.00123 0.00008\n */\n\n/**\n * @public\n *\n * Clone a record.\n */\nfunction clone(record) {\n  return (0, _objectSpread2[\"default\"])({}, record);\n}\n/**\n * @public\n *\n * Copies all fields from `source` to `sink`, excluding `__id` and `__typename`.\n *\n * NOTE: This function does not treat `id` specially. To preserve the id,\n * manually reset it after calling this function. Also note that values are\n * copied by reference and not value; callers should ensure that values are\n * copied on write.\n */\n\n\nfunction copyFields(source, sink) {\n  for (var key in source) {\n    if (source.hasOwnProperty(key)) {\n      if (key !== ID_KEY && key !== TYPENAME_KEY) {\n        sink[key] = source[key];\n      }\n    }\n  }\n}\n/**\n * @public\n *\n * Create a new record.\n */\n\n\nfunction create(dataID, typeName) {\n  // See perf note above for why we aren't using computed property access.\n  var record = {};\n  record[ID_KEY] = dataID;\n  record[TYPENAME_KEY] = typeName;\n  return record;\n}\n/**\n * @public\n *\n * Get the record's `id` if available or the client-generated identifier.\n */\n\n\nfunction getDataID(record) {\n  return record[ID_KEY];\n}\n/**\n * @public\n *\n * Get the concrete type of the record.\n */\n\n\nfunction getType(record) {\n  return record[TYPENAME_KEY];\n}\n/**\n * @public\n *\n * Get a scalar (non-link) field value.\n */\n\n\nfunction getValue(record, storageKey) {\n  var value = record[storageKey];\n\n  if (value && typeof value === 'object') {\n    !(!value.hasOwnProperty(REF_KEY) && !value.hasOwnProperty(REFS_KEY)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernRecord.getValue(): Expected a scalar (non-link) value for `%s.%s` ' + 'but found %s.', record[ID_KEY], storageKey, value.hasOwnProperty(REF_KEY) ? 'a linked record' : 'plural linked records') : invariant(false) : void 0;\n  }\n\n  return value;\n}\n/**\n * @public\n *\n * Get the value of a field as a reference to another record. Throws if the\n * field has a different type.\n */\n\n\nfunction getLinkedRecordID(record, storageKey) {\n  var link = record[storageKey];\n\n  if (link == null) {\n    return link;\n  }\n\n  !(typeof link === 'object' && link && typeof link[REF_KEY] === 'string') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernRecord.getLinkedRecordID(): Expected `%s.%s` to be a linked ID, ' + 'was `%s`.', record[ID_KEY], storageKey, JSON.stringify(link)) : invariant(false) : void 0;\n  return link[REF_KEY];\n}\n/**\n * @public\n *\n * Get the value of a field as a list of references to other records. Throws if\n * the field has a different type.\n */\n\n\nfunction getLinkedRecordIDs(record, storageKey) {\n  var links = record[storageKey];\n\n  if (links == null) {\n    return links;\n  }\n\n  !(typeof links === 'object' && Array.isArray(links[REFS_KEY])) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernRecord.getLinkedRecordIDs(): Expected `%s.%s` to contain an array ' + 'of linked IDs, got `%s`.', record[ID_KEY], storageKey, JSON.stringify(links)) : invariant(false) : void 0; // assume items of the array are ids\n\n  return links[REFS_KEY];\n}\n/**\n * @public\n *\n * Returns the epoch at which the record was invalidated, if it\n * ever was; otherwise returns null;\n */\n\n\nfunction getInvalidationEpoch(record) {\n  if (record == null) {\n    return null;\n  }\n\n  var invalidatedAt = record[INVALIDATED_AT_KEY];\n\n  if (typeof invalidatedAt !== 'number') {\n    // If the record has never been invalidated, it isn't stale.\n    return null;\n  }\n\n  return invalidatedAt;\n}\n/**\n * @public\n *\n * Compares the fields of a previous and new record, returning either the\n * previous record if all fields are equal or a new record (with merged fields)\n * if any fields have changed.\n */\n\n\nfunction update(prevRecord, nextRecord) {\n  if (process.env.NODE_ENV !== \"production\") {\n    var _getType, _getType2;\n\n    var prevID = getDataID(prevRecord);\n    var nextID = getDataID(nextRecord);\n    process.env.NODE_ENV !== \"production\" ? warning(prevID === nextID, 'RelayModernRecord: Invalid record update, expected both versions of ' + 'the record to have the same id, got `%s` and `%s`.', prevID, nextID) : void 0; // note: coalesce null/undefined to null\n\n    var prevType = (_getType = getType(prevRecord)) !== null && _getType !== void 0 ? _getType : null;\n    var nextType = (_getType2 = getType(nextRecord)) !== null && _getType2 !== void 0 ? _getType2 : null;\n    process.env.NODE_ENV !== \"production\" ? warning(isClientID(nextID) && nextID !== ROOT_ID || prevType === nextType, 'RelayModernRecord: Invalid record update, expected both versions of ' + 'record `%s` to have the same `%s` but got conflicting types `%s` ' + 'and `%s`. The GraphQL server likely violated the globally unique ' + 'id requirement by returning the same id for different objects.', prevID, TYPENAME_KEY, prevType, nextType) : void 0;\n  }\n\n  var updated = null;\n  var keys = Object.keys(nextRecord);\n\n  for (var ii = 0; ii < keys.length; ii++) {\n    var key = keys[ii];\n\n    if (updated || !areEqual(prevRecord[key], nextRecord[key])) {\n      updated = updated !== null ? updated : (0, _objectSpread2[\"default\"])({}, prevRecord);\n      updated[key] = nextRecord[key];\n    }\n  }\n\n  return updated !== null ? updated : prevRecord;\n}\n/**\n * @public\n *\n * Returns a new record with the contents of the given records. Fields in the\n * second record will overwrite identical fields in the first record.\n */\n\n\nfunction merge(record1, record2) {\n  if (process.env.NODE_ENV !== \"production\") {\n    var _getType3, _getType4;\n\n    var prevID = getDataID(record1);\n    var nextID = getDataID(record2);\n    process.env.NODE_ENV !== \"production\" ? warning(prevID === nextID, 'RelayModernRecord: Invalid record merge, expected both versions of ' + 'the record to have the same id, got `%s` and `%s`.', prevID, nextID) : void 0; // note: coalesce null/undefined to null\n\n    var prevType = (_getType3 = getType(record1)) !== null && _getType3 !== void 0 ? _getType3 : null;\n    var nextType = (_getType4 = getType(record2)) !== null && _getType4 !== void 0 ? _getType4 : null;\n    process.env.NODE_ENV !== \"production\" ? warning(isClientID(nextID) && nextID !== ROOT_ID || prevType === nextType, 'RelayModernRecord: Invalid record merge, expected both versions of ' + 'record `%s` to have the same `%s` but got conflicting types `%s` ' + 'and `%s`. The GraphQL server likely violated the globally unique ' + 'id requirement by returning the same id for different objects.', prevID, TYPENAME_KEY, prevType, nextType) : void 0;\n  }\n\n  return Object.assign({}, record1, record2);\n}\n/**\n * @public\n *\n * Prevent modifications to the record. Attempts to call `set*` functions on a\n * frozen record will fatal at runtime.\n */\n\n\nfunction freeze(record) {\n  deepFreeze(record);\n}\n/**\n * @public\n *\n * Set the value of a storageKey to a scalar.\n */\n\n\nfunction setValue(record, storageKey, value) {\n  if (process.env.NODE_ENV !== \"production\") {\n    var prevID = getDataID(record);\n\n    if (storageKey === ID_KEY) {\n      process.env.NODE_ENV !== \"production\" ? warning(prevID === value, 'RelayModernRecord: Invalid field update, expected both versions of ' + 'the record to have the same id, got `%s` and `%s`.', prevID, value) : void 0;\n    } else if (storageKey === TYPENAME_KEY) {\n      var _getType5;\n\n      // note: coalesce null/undefined to null\n      var prevType = (_getType5 = getType(record)) !== null && _getType5 !== void 0 ? _getType5 : null;\n      var nextType = value !== null && value !== void 0 ? value : null;\n      process.env.NODE_ENV !== \"production\" ? warning(isClientID(getDataID(record)) && getDataID(record) !== ROOT_ID || prevType === nextType, 'RelayModernRecord: Invalid field update, expected both versions of ' + 'record `%s` to have the same `%s` but got conflicting types `%s` ' + 'and `%s`. The GraphQL server likely violated the globally unique ' + 'id requirement by returning the same id for different objects.', prevID, TYPENAME_KEY, prevType, nextType) : void 0;\n    }\n  }\n\n  record[storageKey] = value;\n}\n/**\n * @public\n *\n * Set the value of a field to a reference to another record.\n */\n\n\nfunction setLinkedRecordID(record, storageKey, linkedID) {\n  // See perf note above for why we aren't using computed property access.\n  var link = {};\n  link[REF_KEY] = linkedID;\n  record[storageKey] = link;\n}\n/**\n * @public\n *\n * Set the value of a field to a list of references other records.\n */\n\n\nfunction setLinkedRecordIDs(record, storageKey, linkedIDs) {\n  // See perf note above for why we aren't using computed property access.\n  var links = {};\n  links[REFS_KEY] = linkedIDs;\n  record[storageKey] = links;\n}\n\nmodule.exports = {\n  clone: clone,\n  copyFields: copyFields,\n  create: create,\n  freeze: freeze,\n  getDataID: getDataID,\n  getInvalidationEpoch: getInvalidationEpoch,\n  getLinkedRecordID: getLinkedRecordID,\n  getLinkedRecordIDs: getLinkedRecordIDs,\n  getType: getType,\n  getValue: getValue,\n  merge: merge,\n  setValue: setValue,\n  setLinkedRecordID: setLinkedRecordID,\n  setLinkedRecordIDs: setLinkedRecordIDs,\n  update: update\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 Observable = require('../network/RelayObservable');\n\nvar RelayReplaySubject = require('../util/RelayReplaySubject');\n\nvar invariant = require('invariant');\n\nvar WEAKMAP_SUPPORTED = typeof WeakMap === 'function';\nvar requestCachesByEnvironment = WEAKMAP_SUPPORTED ? new WeakMap() : new Map();\n/**\n * Fetches the given query and variables on the provided environment,\n * and de-dupes identical in-flight requests.\n *\n * Observing a request:\n * ====================\n * fetchQuery returns an Observable which you can call .subscribe()\n * on. subscribe() takes an Observer, which you can provide to\n * observe network events:\n *\n * ```\n * fetchQuery(environment, query, variables).subscribe({\n *   // Called when network requests starts\n *   start: (subscription) => {},\n *\n *   // Called after a payload is received and written to the local store\n *   next: (payload) => {},\n *\n *   // Called when network requests errors\n *   error: (error) => {},\n *\n *   // Called when network requests fully completes\n *   complete: () => {},\n *\n *   // Called when network request is unsubscribed\n *   unsubscribe: (subscription) => {},\n * });\n * ```\n *\n * In-flight request de-duping:\n * ============================\n * By default, calling fetchQuery multiple times with the same\n * environment, query and variables will not initiate a new request if a request\n * for those same parameters is already in flight.\n *\n * A request is marked in-flight from the moment it starts until the moment it\n * fully completes, regardless of error or successful completion.\n *\n * NOTE: If the request completes _synchronously_, calling fetchQuery\n * a second time with the same arguments in the same tick will _NOT_ de-dupe\n * the request given that it will no longer be in-flight.\n *\n *\n * Data Retention:\n * ===============\n * This function will not retain any query data outside the scope of the\n * request, which means it is not guaranteed that it won't be garbage\n * collected after the request completes.\n * If you need to retain data, you can do so manually with environment.retain().\n *\n * Cancelling requests:\n * ====================\n * If the subscription returned by subscribe is called while the\n * request is in-flight, the request will be cancelled.\n *\n * ```\n * const subscription = fetchQuery(...).subscribe(...);\n *\n * // This will cancel the request if it is in-flight.\n * subscription.unsubscribe();\n * ```\n */\n\nfunction fetchQuery(environment, operation) {\n  return fetchQueryDeduped(environment, operation.request.identifier, function () {\n    return environment.execute({\n      operation: operation\n    });\n  });\n}\n/**\n * Low-level implementation details of `fetchQuery`.\n *\n * `fetchQueryDeduped` can also be used to share a single cache for\n * requests that aren't using `fetchQuery` directly (e.g. because they don't\n * have an `OperationDescriptor` when they are called).\n */\n\n\nfunction fetchQueryDeduped(environment, identifier, fetchFn) {\n  return Observable.create(function (sink) {\n    var requestCache = getRequestCache(environment);\n    var cachedRequest = requestCache.get(identifier);\n\n    if (!cachedRequest) {\n      fetchFn()[\"finally\"](function () {\n        return requestCache[\"delete\"](identifier);\n      }).subscribe({\n        start: function start(subscription) {\n          cachedRequest = {\n            identifier: identifier,\n            subject: new RelayReplaySubject(),\n            subjectForInFlightStatus: new RelayReplaySubject(),\n            subscription: subscription\n          };\n          requestCache.set(identifier, cachedRequest);\n        },\n        next: function next(response) {\n          var cachedReq = getCachedRequest(requestCache, identifier);\n          cachedReq.subject.next(response);\n          cachedReq.subjectForInFlightStatus.next(response);\n        },\n        error: function error(_error) {\n          var cachedReq = getCachedRequest(requestCache, identifier);\n          cachedReq.subject.error(_error);\n          cachedReq.subjectForInFlightStatus.error(_error);\n        },\n        complete: function complete() {\n          var cachedReq = getCachedRequest(requestCache, identifier);\n          cachedReq.subject.complete();\n          cachedReq.subjectForInFlightStatus.complete();\n        },\n        unsubscribe: function unsubscribe(subscription) {\n          var cachedReq = getCachedRequest(requestCache, identifier);\n          cachedReq.subject.unsubscribe();\n          cachedReq.subjectForInFlightStatus.unsubscribe();\n        }\n      });\n    }\n\n    !(cachedRequest != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, '[fetchQueryInternal] fetchQueryDeduped: Expected `start` to be ' + 'called synchronously') : invariant(false) : void 0;\n    return getObservableForCachedRequest(requestCache, cachedRequest).subscribe(sink);\n  });\n}\n/**\n * @private\n */\n\n\nfunction getObservableForCachedRequest(requestCache, cachedRequest) {\n  return Observable.create(function (sink) {\n    var subscription = cachedRequest.subject.subscribe(sink);\n    return function () {\n      subscription.unsubscribe();\n      var cachedRequestInstance = requestCache.get(cachedRequest.identifier);\n\n      if (cachedRequestInstance) {\n        var requestSubscription = cachedRequestInstance.subscription;\n\n        if (requestSubscription != null && cachedRequestInstance.subject.getObserverCount() === 0) {\n          requestSubscription.unsubscribe();\n          requestCache[\"delete\"](cachedRequest.identifier);\n        }\n      }\n    };\n  });\n}\n/**\n * @private\n */\n\n\nfunction getActiveStatusObservableForCachedRequest(environment, requestCache, cachedRequest) {\n  return Observable.create(function (sink) {\n    var subscription = cachedRequest.subjectForInFlightStatus.subscribe({\n      error: sink.error,\n      next: function next(response) {\n        if (!environment.isRequestActive(cachedRequest.identifier)) {\n          sink.complete();\n          return;\n        }\n\n        sink.next();\n      },\n      complete: sink.complete,\n      unsubscribe: sink.complete\n    });\n    return function () {\n      subscription.unsubscribe();\n    };\n  });\n}\n/**\n * If a request is active for the given query, variables and environment,\n * this function will return a Promise that will resolve when that request\n * stops being active (receives a final payload), and the data has been saved\n * to the store.\n * If no request is active, null will be returned\n */\n\n\nfunction getPromiseForActiveRequest(environment, request) {\n  var requestCache = getRequestCache(environment);\n  var cachedRequest = requestCache.get(request.identifier);\n\n  if (!cachedRequest) {\n    return null;\n  }\n\n  if (!environment.isRequestActive(cachedRequest.identifier)) {\n    return null;\n  }\n\n  return new Promise(function (resolve, reject) {\n    var resolveOnNext = false;\n    getActiveStatusObservableForCachedRequest(environment, requestCache, cachedRequest).subscribe({\n      complete: resolve,\n      error: reject,\n      next: function next(response) {\n        /*\n         * The underlying `RelayReplaySubject` will synchronously replay events\n         * as soon as we subscribe, but since we want the *next* asynchronous\n         * one, we'll ignore them until the replay finishes.\n         */\n        if (resolveOnNext) {\n          resolve(response);\n        }\n      }\n    });\n    resolveOnNext = true;\n  });\n}\n/**\n * If there is a pending request for the given query, returns an Observable of\n * *all* its responses. Existing responses are published synchronously and\n * subsequent responses are published asynchronously. Returns null if there is\n * no pending request. This is similar to fetchQuery() except that it will not\n * issue a fetch if there isn't already one pending.\n */\n\n\nfunction getObservableForActiveRequest(environment, request) {\n  var requestCache = getRequestCache(environment);\n  var cachedRequest = requestCache.get(request.identifier);\n\n  if (!cachedRequest) {\n    return null;\n  }\n\n  if (!environment.isRequestActive(cachedRequest.identifier)) {\n    return null;\n  }\n\n  return getActiveStatusObservableForCachedRequest(environment, requestCache, cachedRequest);\n}\n/**\n * @private\n */\n\n\nfunction getRequestCache(environment) {\n  var cached = requestCachesByEnvironment.get(environment);\n\n  if (cached != null) {\n    return cached;\n  }\n\n  var requestCache = new Map();\n  requestCachesByEnvironment.set(environment, requestCache);\n  return requestCache;\n}\n/**\n * @private\n */\n\n\nfunction getCachedRequest(requestCache, identifier) {\n  var cached = requestCache.get(identifier);\n  !(cached != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, '[fetchQueryInternal] getCachedRequest: Expected request to be cached') : invariant(false) : void 0;\n  return cached;\n}\n\nmodule.exports = {\n  fetchQuery: fetchQuery,\n  fetchQueryDeduped: fetchQueryDeduped,\n  getPromiseForActiveRequest: getPromiseForActiveRequest,\n  getObservableForActiveRequest: getObservableForActiveRequest\n};","/**\n * Copyright (c) 2014-present, Facebook, Inc.\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'use strict';\n\nvar emptyFunction = require(\"./emptyFunction\");\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\n\nfunction printWarning(format) {\n  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    args[_key - 1] = arguments[_key];\n  }\n\n  var argIndex = 0;\n  var message = 'Warning: ' + format.replace(/%s/g, function () {\n    return args[argIndex++];\n  });\n\n  if (typeof console !== 'undefined') {\n    console.error(message);\n  }\n\n  try {\n    // --- Welcome to debugging React ---\n    // This error was thrown as a convenience so that you can use this stack\n    // to find the callsite that caused this warning to fire.\n    throw new Error(message);\n  } catch (x) {}\n}\n\nvar warning = process.env.NODE_ENV !== \"production\" ? function (condition, format) {\n  if (format === undefined) {\n    throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n  }\n\n  if (!condition) {\n    for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n      args[_key2 - 2] = arguments[_key2];\n    }\n\n    printWarning.apply(void 0, [format].concat(args));\n  }\n} : emptyFunction;\nmodule.exports = warning;","/**\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// flowlint ambiguous-object-type:error\n'use strict';\n\nvar RelayFeatureFlags = require('./RelayFeatureFlags');\n\nvar isEmptyObject = require('./isEmptyObject');\n\nvar stableCopy = require('./stableCopy');\n\nvar _require = require('../store/RelayModernSelector'),\n    getDataIDsFromFragment = _require.getDataIDsFromFragment,\n    getVariablesFromFragment = _require.getVariablesFromFragment,\n    getSelector = _require.getSelector;\n\nfunction getFragmentIdentifier(fragmentNode, fragmentRef) {\n  var selector = getSelector(fragmentNode, fragmentRef);\n  var fragmentOwnerIdentifier = selector == null ? 'null' : selector.kind === 'SingularReaderSelector' ? selector.owner.identifier : '[' + selector.selectors.map(function (sel) {\n    return sel.owner.identifier;\n  }).join(',') + ']';\n  var fragmentVariables = getVariablesFromFragment(fragmentNode, fragmentRef);\n  var dataIDs = getDataIDsFromFragment(fragmentNode, fragmentRef);\n\n  if (RelayFeatureFlags.ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION) {\n    return fragmentOwnerIdentifier + '/' + fragmentNode.name + '/' + (fragmentVariables == null || isEmptyObject(fragmentVariables) ? '{}' : JSON.stringify(stableCopy(fragmentVariables))) + '/' + (typeof dataIDs === 'undefined' ? 'missing' : dataIDs == null ? 'null' : Array.isArray(dataIDs) ? '[' + dataIDs.join(',') + ']' : dataIDs);\n  } else {\n    var _JSON$stringify;\n\n    return fragmentOwnerIdentifier + '/' + fragmentNode.name + '/' + JSON.stringify(stableCopy(fragmentVariables)) + '/' + ((_JSON$stringify = JSON.stringify(dataIDs)) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : 'missing');\n  }\n}\n\nmodule.exports = getFragmentIdentifier;","var defineProperty = require(\"./defineProperty.js\");\nfunction ownKeys(e, r) {\n  var t = Object.keys(e);\n  if (Object.getOwnPropertySymbols) {\n    var o = Object.getOwnPropertySymbols(e);\n    r && (o = o.filter(function (r) {\n      return Object.getOwnPropertyDescriptor(e, r).enumerable;\n    })), t.push.apply(t, o);\n  }\n  return t;\n}\nfunction _objectSpread2(e) {\n  for (var r = 1; r < arguments.length; r++) {\n    var t = null != arguments[r] ? arguments[r] : {};\n    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {\n      defineProperty(e, r, t[r]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {\n      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));\n    });\n  }\n  return e;\n}\nmodule.exports = _objectSpread2, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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 _require = require('../store/RelayStoreUtils'),\n    getModuleComponentKey = _require.getModuleComponentKey,\n    getModuleOperationKey = _require.getModuleOperationKey;\n\nfunction createPayloadFor3DField(name, operation, component, response) {\n  var data = (0, _objectSpread2[\"default\"])({}, response);\n  data[getModuleComponentKey(name)] = component;\n  data[getModuleOperationKey(name)] = operation;\n  return data;\n}\n\nmodule.exports = createPayloadFor3DField;","/**\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 RelayRecordSourceMapImpl = require('./RelayRecordSourceMapImpl');\n\nvar RelayRecordSource = /*#__PURE__*/function () {\n  function RelayRecordSource(records) {\n    return RelayRecordSource.create(records);\n  }\n\n  RelayRecordSource.create = function create(records) {\n    return new RelayRecordSourceMapImpl(records);\n  };\n\n  return RelayRecordSource;\n}();\n\nmodule.exports = RelayRecordSource;","/**\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 RelayObservable = require('../network/RelayObservable');\n\nvar invariant = require('invariant');\n\n/**\n * An implementation of a `ReplaySubject` for Relay Observables.\n *\n * Records events provided and synchronously plays them back to new subscribers,\n * as well as forwarding new asynchronous events.\n */\nvar RelayReplaySubject = /*#__PURE__*/function () {\n  function RelayReplaySubject() {\n    var _this = this;\n\n    (0, _defineProperty2[\"default\"])(this, \"_complete\", false);\n    (0, _defineProperty2[\"default\"])(this, \"_events\", []);\n    (0, _defineProperty2[\"default\"])(this, \"_sinks\", new Set());\n    (0, _defineProperty2[\"default\"])(this, \"_subscription\", null);\n    this._observable = RelayObservable.create(function (sink) {\n      _this._sinks.add(sink);\n\n      var events = _this._events;\n\n      for (var i = 0; i < events.length; i++) {\n        if (sink.closed) {\n          // Bail if an event made the observer unsubscribe.\n          break;\n        }\n\n        var event = events[i];\n\n        switch (event.kind) {\n          case 'complete':\n            sink.complete();\n            break;\n\n          case 'error':\n            sink.error(event.error);\n            break;\n\n          case 'next':\n            sink.next(event.data);\n            break;\n\n          default:\n            event.kind;\n            !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReplaySubject: Unknown event kind `%s`.', event.kind) : invariant(false) : void 0;\n        }\n      }\n\n      return function () {\n        _this._sinks[\"delete\"](sink);\n      };\n    });\n  }\n\n  var _proto = RelayReplaySubject.prototype;\n\n  _proto.complete = function complete() {\n    if (this._complete === true) {\n      return;\n    }\n\n    this._complete = true;\n\n    this._events.push({\n      kind: 'complete'\n    });\n\n    this._sinks.forEach(function (sink) {\n      return sink.complete();\n    });\n  };\n\n  _proto.error = function error(_error) {\n    if (this._complete === true) {\n      return;\n    }\n\n    this._complete = true;\n\n    this._events.push({\n      kind: 'error',\n      error: _error\n    });\n\n    this._sinks.forEach(function (sink) {\n      return sink.error(_error);\n    });\n  };\n\n  _proto.next = function next(data) {\n    if (this._complete === true) {\n      return;\n    }\n\n    this._events.push({\n      kind: 'next',\n      data: data\n    });\n\n    this._sinks.forEach(function (sink) {\n      return sink.next(data);\n    });\n  };\n\n  _proto.subscribe = function subscribe(observer) {\n    this._subscription = this._observable.subscribe(observer);\n    return this._subscription;\n  };\n\n  _proto.unsubscribe = function unsubscribe() {\n    if (this._subscription) {\n      this._subscription.unsubscribe();\n\n      this._subscription = null;\n    }\n  };\n\n  _proto.getObserverCount = function getObserverCount() {\n    return this._sinks.size;\n  };\n\n  return RelayReplaySubject;\n}();\n\nmodule.exports = RelayReplaySubject;","/**\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 _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\n\nvar RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');\n\nvar invariant = require('invariant');\n\nvar isRelayModernEnvironment = require('../store/isRelayModernEnvironment');\n\nvar validateMutation = require('./validateMutation');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('../query/GraphQLTag'),\n    getRequest = _require.getRequest;\n\nvar _require2 = require('../store/ClientID'),\n    generateUniqueClientID = _require2.generateUniqueClientID;\n\nvar _require3 = require('../store/RelayModernOperationDescriptor'),\n    createOperationDescriptor = _require3.createOperationDescriptor;\n\n/**\n * Higher-level helper function to execute a mutation against a specific\n * environment.\n */\nfunction commitMutation(environment, config) {\n  !isRelayModernEnvironment(environment) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'commitMutation: expected `environment` to be an instance of ' + '`RelayModernEnvironment`.') : invariant(false) : void 0;\n  var mutation = getRequest(config.mutation);\n\n  if (mutation.params.operationKind !== 'mutation') {\n    throw new Error('commitMutation: Expected mutation operation');\n  }\n\n  if (mutation.kind !== 'Request') {\n    throw new Error('commitMutation: Expected mutation to be of type request');\n  }\n\n  var optimisticResponse = config.optimisticResponse,\n      optimisticUpdater = config.optimisticUpdater,\n      updater = config.updater;\n  var configs = config.configs,\n      cacheConfig = config.cacheConfig,\n      onError = config.onError,\n      onUnsubscribe = config.onUnsubscribe,\n      variables = config.variables,\n      uploadables = config.uploadables;\n  var operation = createOperationDescriptor(mutation, variables, cacheConfig, generateUniqueClientID()); // TODO: remove this check after we fix flow.\n\n  if (typeof optimisticResponse === 'function') {\n    optimisticResponse = optimisticResponse();\n    process.env.NODE_ENV !== \"production\" ? warning(false, 'commitMutation: Expected `optimisticResponse` to be an object, ' + 'received a function.') : void 0;\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (optimisticResponse instanceof Object) {\n      validateMutation(optimisticResponse, mutation, variables);\n    }\n  }\n\n  if (configs) {\n    var _RelayDeclarativeMuta = RelayDeclarativeMutationConfig.convert(configs, mutation, optimisticUpdater, updater);\n\n    optimisticUpdater = _RelayDeclarativeMuta.optimisticUpdater;\n    updater = _RelayDeclarativeMuta.updater;\n  }\n\n  var errors = [];\n  var subscription = environment.executeMutation({\n    operation: operation,\n    optimisticResponse: optimisticResponse,\n    optimisticUpdater: optimisticUpdater,\n    updater: updater,\n    uploadables: uploadables\n  }).subscribe({\n    next: function next(payload) {\n      if (Array.isArray(payload)) {\n        payload.forEach(function (item) {\n          if (item.errors) {\n            errors.push.apply(errors, (0, _toConsumableArray2[\"default\"])(item.errors));\n          }\n        });\n      } else {\n        if (payload.errors) {\n          errors.push.apply(errors, (0, _toConsumableArray2[\"default\"])(payload.errors));\n        }\n      }\n    },\n    complete: function complete() {\n      var onCompleted = config.onCompleted;\n\n      if (onCompleted) {\n        var snapshot = environment.lookup(operation.fragment);\n        onCompleted(snapshot.data, errors.length !== 0 ? errors : null);\n      }\n    },\n    error: onError,\n    unsubscribe: onUnsubscribe\n  });\n  return {\n    dispose: subscription.unsubscribe\n  };\n}\n\nmodule.exports = commitMutation;","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _toPrimitive(input, hint) {\n  if (_typeof(input) !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (_typeof(res) !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\nmodule.exports = _toPrimitive, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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 commitLocalUpdate(environment, updater) {\n  environment.commitUpdate(updater);\n}\n\nmodule.exports = commitLocalUpdate;","/**\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 areEqual = require(\"fbjs/lib/areEqual\");\n\nvar invariant = require('invariant');\n\nvar _require = require('../util/RelayConcreteNode'),\n    LINKED_FIELD = _require.LINKED_FIELD;\n\nvar _require2 = require('./RelayStoreUtils'),\n    getHandleStorageKey = _require2.getHandleStorageKey;\n\n/**\n * @private\n *\n * Creates a clone of the supplied `handleField` by finding the original linked\n * field (on which the handle was declared) among the sibling `selections`, and\n * copying its selections into the clone.\n */\nfunction cloneRelayHandleSourceField(handleField, selections, variables) {\n  var sourceField = selections.find(function (source) {\n    return source.kind === LINKED_FIELD && source.name === handleField.name && source.alias === handleField.alias && areEqual(source.args, handleField.args);\n  });\n  !(sourceField && sourceField.kind === LINKED_FIELD) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'cloneRelayHandleSourceField: Expected a corresponding source field for ' + 'handle `%s`.', handleField.handle) : invariant(false) : void 0;\n  var handleKey = getHandleStorageKey(handleField, variables);\n  return {\n    kind: 'LinkedField',\n    alias: sourceField.alias,\n    name: handleKey,\n    storageKey: handleKey,\n    args: null,\n    concreteType: sourceField.concreteType,\n    plural: sourceField.plural,\n    selections: sourceField.selections\n  };\n}\n\nmodule.exports = cloneRelayHandleSourceField;","/**\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 relayContext;\nvar firstReact;\n\nfunction createRelayContext(react) {\n  if (!relayContext) {\n    relayContext = react.createContext(null);\n\n    if (process.env.NODE_ENV !== \"production\") {\n      relayContext.displayName = 'RelayContext';\n    }\n\n    firstReact = react;\n  }\n\n  !(react === firstReact) ? process.env.NODE_ENV !== \"production\" ? invariant(false, '[createRelayContext]: You passing a different instance of React', react.version) : invariant(false) : void 0;\n  return relayContext;\n}\n\nmodule.exports = createRelayContext;","/**\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 areEqual = require(\"fbjs/lib/areEqual\");\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('./RelayConcreteVariables'),\n    getFragmentVariables = _require.getFragmentVariables;\n\nvar _require2 = require('./RelayStoreUtils'),\n    FRAGMENT_OWNER_KEY = _require2.FRAGMENT_OWNER_KEY,\n    FRAGMENTS_KEY = _require2.FRAGMENTS_KEY,\n    ID_KEY = _require2.ID_KEY,\n    IS_WITHIN_UNMATCHED_TYPE_REFINEMENT = _require2.IS_WITHIN_UNMATCHED_TYPE_REFINEMENT;\n\n/**\n * @public\n *\n * Given the result `item` from a parent that fetched `fragment`, creates a\n * selector that can be used to read the results of that fragment for that item.\n *\n * Example:\n *\n * Given two fragments as follows:\n *\n * ```\n * fragment Parent on User {\n *   id\n *   ...Child\n * }\n * fragment Child on User {\n *   name\n * }\n * ```\n *\n * And given some object `parent` that is the results of `Parent` for id \"4\",\n * the results of `Child` can be accessed by first getting a selector and then\n * using that selector to `lookup()` the results against the environment:\n *\n * ```\n * const childSelector = getSingularSelector(queryVariables, Child, parent);\n * const childData = environment.lookup(childSelector).data;\n * ```\n */\nfunction getSingularSelector(fragment, item) {\n  !(typeof item === 'object' && item !== null && !Array.isArray(item)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernSelector: Expected value for fragment `%s` to be an object, got ' + '`%s`.', fragment.name, JSON.stringify(item)) : invariant(false) : void 0;\n  var dataID = item[ID_KEY];\n  var fragments = item[FRAGMENTS_KEY];\n  var mixedOwner = item[FRAGMENT_OWNER_KEY];\n  var isWithinUnmatchedTypeRefinement = item[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] === true;\n\n  if (typeof dataID === 'string' && typeof fragments === 'object' && fragments !== null && typeof fragments[fragment.name] === 'object' && fragments[fragment.name] !== null && typeof mixedOwner === 'object' && mixedOwner !== null) {\n    var owner = mixedOwner;\n    var argumentVariables = fragments[fragment.name];\n    var fragmentVariables = getFragmentVariables(fragment, owner.variables, argumentVariables);\n    return createReaderSelector(fragment, dataID, fragmentVariables, owner, isWithinUnmatchedTypeRefinement);\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    var stringifiedItem = JSON.stringify(item);\n\n    if (stringifiedItem.length > 499) {\n      stringifiedItem = stringifiedItem.substr(0, 498) + \"\\u2026\";\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayModernSelector: Expected object to contain data for fragment `%s`, got ' + '`%s`. Make sure that the parent operation/fragment included fragment ' + '`...%s` without `@relay(mask: false)`.', fragment.name, stringifiedItem, fragment.name) : void 0;\n  }\n\n  return null;\n}\n/**\n * @public\n *\n * Given the result `items` from a parent that fetched `fragment`, creates a\n * selector that can be used to read the results of that fragment on those\n * items. This is similar to `getSingularSelector` but for \"plural\" fragments that\n * expect an array of results and therefore return an array of selectors.\n */\n\n\nfunction getPluralSelector(fragment, items) {\n  var selectors = null;\n  items.forEach(function (item, ii) {\n    var selector = item != null ? getSingularSelector(fragment, item) : null;\n\n    if (selector != null) {\n      selectors = selectors || [];\n      selectors.push(selector);\n    }\n  });\n\n  if (selectors == null) {\n    return null;\n  } else {\n    return {\n      kind: 'PluralReaderSelector',\n      selectors: selectors\n    };\n  }\n}\n\nfunction getSelector(fragment, item) {\n  if (item == null) {\n    return item;\n  } else if (fragment.metadata && fragment.metadata.plural === true) {\n    !Array.isArray(item) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernSelector: Expected value for fragment `%s` to be an array, got `%s`. ' + 'Remove `@relay(plural: true)` from fragment `%s` to allow the prop to be an object.', fragment.name, JSON.stringify(item), fragment.name) : invariant(false) : void 0;\n    return getPluralSelector(fragment, item);\n  } else {\n    !!Array.isArray(item) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernSelector: Expected value for fragment `%s` to be an object, got `%s`. ' + 'Add `@relay(plural: true)` to fragment `%s` to allow the prop to be an array of items.', fragment.name, JSON.stringify(item), fragment.name) : invariant(false) : void 0;\n    return getSingularSelector(fragment, item);\n  }\n}\n/**\n * @public\n *\n * Given a mapping of keys -> results and a mapping of keys -> fragments,\n * extracts the selectors for those fragments from the results.\n *\n * The canonical use-case for this function is ReactRelayFragmentContainer, which\n * uses this function to convert (props, fragments) into selectors so that it\n * can read the results to pass to the inner component.\n */\n\n\nfunction getSelectorsFromObject(fragments, object) {\n  var selectors = {};\n\n  for (var _key in fragments) {\n    if (fragments.hasOwnProperty(_key)) {\n      var fragment = fragments[_key];\n      var item = object[_key];\n      selectors[_key] = getSelector(fragment, item);\n    }\n  }\n\n  return selectors;\n}\n/**\n * @public\n *\n * Given a mapping of keys -> results and a mapping of keys -> fragments,\n * extracts a mapping of keys -> id(s) of the results.\n *\n * Similar to `getSelectorsFromObject()`, this function can be useful in\n * determining the \"identity\" of the props passed to a component.\n */\n\n\nfunction getDataIDsFromObject(fragments, object) {\n  var ids = {};\n\n  for (var _key2 in fragments) {\n    if (fragments.hasOwnProperty(_key2)) {\n      var fragment = fragments[_key2];\n      var item = object[_key2];\n      ids[_key2] = getDataIDsFromFragment(fragment, item);\n    }\n  }\n\n  return ids;\n}\n\nfunction getDataIDsFromFragment(fragment, item) {\n  if (item == null) {\n    return item;\n  } else if (fragment.metadata && fragment.metadata.plural === true) {\n    !Array.isArray(item) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernSelector: Expected value for fragment `%s` to be an array, got `%s`. ' + 'Remove `@relay(plural: true)` from fragment `%s` to allow the prop to be an object.', fragment.name, JSON.stringify(item), fragment.name) : invariant(false) : void 0;\n    return getDataIDs(fragment, item);\n  } else {\n    !!Array.isArray(item) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernFragmentSpecResolver: Expected value for fragment `%s` to be an object, got `%s`. ' + 'Add `@relay(plural: true)` to fragment `%s` to allow the prop to be an array of items.', fragment.name, JSON.stringify(item), fragment.name) : invariant(false) : void 0;\n    return getDataID(fragment, item);\n  }\n}\n/**\n * @internal\n */\n\n\nfunction getDataIDs(fragment, items) {\n  var ids = null;\n  items.forEach(function (item) {\n    var id = item != null ? getDataID(fragment, item) : null;\n\n    if (id != null) {\n      ids = ids || [];\n      ids.push(id);\n    }\n  });\n  return ids;\n}\n/**\n * @internal\n */\n\n\nfunction getDataID(fragment, item) {\n  !(typeof item === 'object' && item !== null && !Array.isArray(item)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernSelector: Expected value for fragment `%s` to be an object, got ' + '`%s`.', fragment.name, JSON.stringify(item)) : invariant(false) : void 0;\n  var dataID = item[ID_KEY];\n\n  if (typeof dataID === 'string') {\n    return dataID;\n  }\n\n  process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayModernSelector: Expected object to contain data for fragment `%s`, got ' + '`%s`. Make sure that the parent operation/fragment included fragment ' + '`...%s` without `@relay(mask: false)`, or `null` is passed as the fragment ' + \"reference for `%s` if it's conditonally included and the condition isn't met.\", fragment.name, JSON.stringify(item), fragment.name, fragment.name) : void 0;\n  return null;\n}\n/**\n * @public\n *\n * Given a mapping of keys -> results and a mapping of keys -> fragments,\n * extracts the merged variables that would be in scope for those\n * fragments/results.\n *\n * This can be useful in determing what varaibles were used to fetch the data\n * for a Relay container, for example.\n */\n\n\nfunction getVariablesFromObject(fragments, object) {\n  var variables = {};\n\n  for (var _key3 in fragments) {\n    if (fragments.hasOwnProperty(_key3)) {\n      var fragment = fragments[_key3];\n      var item = object[_key3];\n      var itemVariables = getVariablesFromFragment(fragment, item);\n      Object.assign(variables, itemVariables);\n    }\n  }\n\n  return variables;\n}\n\nfunction getVariablesFromFragment(fragment, item) {\n  var _fragment$metadata;\n\n  if (item == null) {\n    return {};\n  } else if (((_fragment$metadata = fragment.metadata) === null || _fragment$metadata === void 0 ? void 0 : _fragment$metadata.plural) === true) {\n    !Array.isArray(item) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernSelector: Expected value for fragment `%s` to be an array, got `%s`. ' + 'Remove `@relay(plural: true)` from fragment `%s` to allow the prop to be an object.', fragment.name, JSON.stringify(item), fragment.name) : invariant(false) : void 0;\n    return getVariablesFromPluralFragment(fragment, item);\n  } else {\n    !!Array.isArray(item) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernFragmentSpecResolver: Expected value for fragment `%s` to be an object, got `%s`. ' + 'Add `@relay(plural: true)` to fragment `%s` to allow the prop to be an array of items.', fragment.name, JSON.stringify(item), fragment.name) : invariant(false) : void 0;\n    return getVariablesFromSingularFragment(fragment, item) || {};\n  }\n}\n\nfunction getVariablesFromSingularFragment(fragment, item) {\n  var selector = getSingularSelector(fragment, item);\n\n  if (!selector) {\n    return null;\n  }\n\n  return selector.variables;\n}\n\nfunction getVariablesFromPluralFragment(fragment, items) {\n  var variables = {};\n  items.forEach(function (value, ii) {\n    if (value != null) {\n      var itemVariables = getVariablesFromSingularFragment(fragment, value);\n\n      if (itemVariables != null) {\n        Object.assign(variables, itemVariables);\n      }\n    }\n  });\n  return variables;\n}\n/**\n * @public\n *\n * Determine if two selectors are equal (represent the same selection). Note\n * that this function returns `false` when the two queries/fragments are\n * different objects, even if they select the same fields.\n */\n\n\nfunction areEqualSelectors(thisSelector, thatSelector) {\n  return thisSelector.owner === thatSelector.owner && thisSelector.dataID === thatSelector.dataID && thisSelector.node === thatSelector.node && areEqual(thisSelector.variables, thatSelector.variables);\n}\n\nfunction createReaderSelector(fragment, dataID, variables, request) {\n  var isWithinUnmatchedTypeRefinement = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n  return {\n    kind: 'SingularReaderSelector',\n    dataID: dataID,\n    isWithinUnmatchedTypeRefinement: isWithinUnmatchedTypeRefinement,\n    node: fragment,\n    variables: variables,\n    owner: request\n  };\n}\n\nfunction createNormalizationSelector(node, dataID, variables) {\n  return {\n    dataID: dataID,\n    node: node,\n    variables: variables\n  };\n}\n\nmodule.exports = {\n  areEqualSelectors: areEqualSelectors,\n  createReaderSelector: createReaderSelector,\n  createNormalizationSelector: createNormalizationSelector,\n  getDataIDsFromFragment: getDataIDsFromFragment,\n  getDataIDsFromObject: getDataIDsFromObject,\n  getSingularSelector: getSingularSelector,\n  getPluralSelector: getPluralSelector,\n  getSelector: getSelector,\n  getSelectorsFromObject: getSelectorsFromObject,\n  getVariablesFromSingularFragment: getVariablesFromSingularFragment,\n  getVariablesFromPluralFragment: getVariablesFromPluralFragment,\n  getVariablesFromFragment: getVariablesFromFragment,\n  getVariablesFromObject: getVariablesFromObject\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 hasWeakSetDefined = typeof WeakSet !== 'undefined';\nvar hasWeakMapDefined = typeof WeakMap !== 'undefined';\n/**\n * Recycles subtrees from `prevData` by replacing equal subtrees in `nextData`.\n */\n\nfunction recycleNodesInto(prevData, nextData) {\n  if (prevData === nextData || typeof prevData !== 'object' || prevData instanceof Set || prevData instanceof Map || hasWeakSetDefined && prevData instanceof WeakSet || hasWeakMapDefined && prevData instanceof WeakMap || !prevData || typeof nextData !== 'object' || nextData instanceof Set || nextData instanceof Map || hasWeakSetDefined && nextData instanceof WeakSet || hasWeakMapDefined && nextData instanceof WeakMap || !nextData) {\n    return nextData;\n  }\n\n  var canRecycle = false; // Assign local variables to preserve Flow type refinement.\n\n  var prevArray = Array.isArray(prevData) ? prevData : null;\n  var nextArray = Array.isArray(nextData) ? nextData : null;\n\n  if (prevArray && nextArray) {\n    canRecycle = nextArray.reduce(function (wasEqual, nextItem, ii) {\n      var prevValue = prevArray[ii];\n      var nextValue = recycleNodesInto(prevValue, nextItem);\n\n      if (nextValue !== nextArray[ii]) {\n        if (process.env.NODE_ENV !== \"production\") {\n          if (!Object.isFrozen(nextArray)) {\n            nextArray[ii] = nextValue;\n          }\n        } else {\n          nextArray[ii] = nextValue;\n        }\n      }\n\n      return wasEqual && nextValue === prevArray[ii];\n    }, true) && prevArray.length === nextArray.length;\n  } else if (!prevArray && !nextArray) {\n    // Assign local variables to preserve Flow type refinement.\n    var prevObject = prevData;\n    var nextObject = nextData;\n    var prevKeys = Object.keys(prevObject);\n    var nextKeys = Object.keys(nextObject);\n    canRecycle = nextKeys.reduce(function (wasEqual, key) {\n      var prevValue = prevObject[key];\n      var nextValue = recycleNodesInto(prevValue, nextObject[key]);\n\n      if (nextValue !== nextObject[key]) {\n        if (process.env.NODE_ENV !== \"production\") {\n          if (!Object.isFrozen(nextObject)) {\n            // $FlowFixMe[cannot-write]\n            nextObject[key] = nextValue;\n          }\n        } else {\n          // $FlowFixMe[cannot-write]\n          nextObject[key] = nextValue;\n        }\n      }\n\n      return wasEqual && nextValue === prevObject[key];\n    }, true) && prevKeys.length === nextKeys.length;\n  }\n\n  return canRecycle ? prevData : nextData;\n}\n\nmodule.exports = recycleNodesInto;","/**\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 _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar DataChecker = require('./DataChecker');\n\nvar RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar RelayModernRecord = require('./RelayModernRecord');\n\nvar RelayOptimisticRecordSource = require('./RelayOptimisticRecordSource');\n\nvar RelayReader = require('./RelayReader');\n\nvar RelayReferenceMarker = require('./RelayReferenceMarker');\n\nvar RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');\n\nvar RelayStoreSubscriptions = require('./RelayStoreSubscriptions');\n\nvar RelayStoreSubscriptionsUsingMapByID = require('./RelayStoreSubscriptionsUsingMapByID');\n\nvar RelayStoreUtils = require('./RelayStoreUtils');\n\nvar deepFreeze = require('../util/deepFreeze');\n\nvar defaultGetDataID = require('./defaultGetDataID');\n\nvar invariant = require('invariant');\n\nvar resolveImmediate = require('../util/resolveImmediate');\n\nvar _require = require('./RelayStoreUtils'),\n    ROOT_ID = _require.ROOT_ID,\n    ROOT_TYPE = _require.ROOT_TYPE;\n\nvar DEFAULT_RELEASE_BUFFER_SIZE = 10;\n/**\n * @public\n *\n * An implementation of the `Store` interface defined in `RelayStoreTypes`.\n *\n * Note that a Store takes ownership of all records provided to it: other\n * objects may continue to hold a reference to such records but may not mutate\n * them. The static Relay core is architected to avoid mutating records that may have been\n * passed to a store: operations that mutate records will either create fresh\n * records or clone existing records and modify the clones. Record immutability\n * is also enforced in development mode by freezing all records passed to a store.\n */\n\nvar RelayModernStore = /*#__PURE__*/function () {\n  function RelayModernStore(source, options) {\n    var _this = this;\n\n    var _options$gcReleaseBuf, _options$gcScheduler, _options$getDataID, _options$log, _options$operationLoa;\n\n    (0, _defineProperty2[\"default\"])(this, \"_gcStep\", function () {\n      if (_this._gcRun) {\n        if (_this._gcRun.next().done) {\n          _this._gcRun = null;\n        } else {\n          _this._gcScheduler(_this._gcStep);\n        }\n      }\n    });\n\n    // Prevent mutation of a record from outside the store.\n    if (process.env.NODE_ENV !== \"production\") {\n      var storeIDs = source.getRecordIDs();\n\n      for (var ii = 0; ii < storeIDs.length; ii++) {\n        var record = source.get(storeIDs[ii]);\n\n        if (record) {\n          RelayModernRecord.freeze(record);\n        }\n      }\n    }\n\n    this._currentWriteEpoch = 0;\n    this._gcHoldCounter = 0;\n    this._gcReleaseBufferSize = (_options$gcReleaseBuf = options === null || options === void 0 ? void 0 : options.gcReleaseBufferSize) !== null && _options$gcReleaseBuf !== void 0 ? _options$gcReleaseBuf : DEFAULT_RELEASE_BUFFER_SIZE;\n    this._gcRun = null;\n    this._gcScheduler = (_options$gcScheduler = options === null || options === void 0 ? void 0 : options.gcScheduler) !== null && _options$gcScheduler !== void 0 ? _options$gcScheduler : resolveImmediate;\n    this._getDataID = (_options$getDataID = options === null || options === void 0 ? void 0 : options.getDataID) !== null && _options$getDataID !== void 0 ? _options$getDataID : defaultGetDataID;\n    this._globalInvalidationEpoch = null;\n    this._invalidationSubscriptions = new Set();\n    this._invalidatedRecordIDs = new Set();\n    this.__log = (_options$log = options === null || options === void 0 ? void 0 : options.log) !== null && _options$log !== void 0 ? _options$log : null;\n    this._queryCacheExpirationTime = options === null || options === void 0 ? void 0 : options.queryCacheExpirationTime;\n    this._operationLoader = (_options$operationLoa = options === null || options === void 0 ? void 0 : options.operationLoader) !== null && _options$operationLoa !== void 0 ? _options$operationLoa : null;\n    this._optimisticSource = null;\n    this._recordSource = source;\n    this._releaseBuffer = [];\n    this._roots = new Map();\n    this._shouldScheduleGC = false;\n    this._storeSubscriptions = RelayFeatureFlags.ENABLE_STORE_SUBSCRIPTIONS_REFACTOR === true ? new RelayStoreSubscriptionsUsingMapByID(options === null || options === void 0 ? void 0 : options.log) : new RelayStoreSubscriptions(options === null || options === void 0 ? void 0 : options.log);\n    this._updatedRecordIDs = new Set();\n    this._shouldProcessClientComponents = options === null || options === void 0 ? void 0 : options.shouldProcessClientComponents;\n    initializeRecordSource(this._recordSource);\n  }\n\n  var _proto = RelayModernStore.prototype;\n\n  _proto.getSource = function getSource() {\n    var _this$_optimisticSour;\n\n    return (_this$_optimisticSour = this._optimisticSource) !== null && _this$_optimisticSour !== void 0 ? _this$_optimisticSour : this._recordSource;\n  };\n\n  _proto.check = function check(operation, options) {\n    var _this$_optimisticSour2, _options$target, _options$handlers;\n\n    var selector = operation.root;\n    var source = (_this$_optimisticSour2 = this._optimisticSource) !== null && _this$_optimisticSour2 !== void 0 ? _this$_optimisticSour2 : this._recordSource;\n    var globalInvalidationEpoch = this._globalInvalidationEpoch;\n\n    var rootEntry = this._roots.get(operation.request.identifier);\n\n    var operationLastWrittenAt = rootEntry != null ? rootEntry.epoch : null; // Check if store has been globally invalidated\n\n    if (globalInvalidationEpoch != null) {\n      // If so, check if the operation we're checking was last written\n      // before or after invalidation occured.\n      if (operationLastWrittenAt == null || operationLastWrittenAt <= globalInvalidationEpoch) {\n        // If the operation was written /before/ global invalidation occurred,\n        // or if this operation has never been written to the store before,\n        // we will consider the data for this operation to be stale\n        // (i.e. not resolvable from the store).\n        return {\n          status: 'stale'\n        };\n      }\n    }\n\n    var target = (_options$target = options === null || options === void 0 ? void 0 : options.target) !== null && _options$target !== void 0 ? _options$target : source;\n    var handlers = (_options$handlers = options === null || options === void 0 ? void 0 : options.handlers) !== null && _options$handlers !== void 0 ? _options$handlers : [];\n    var operationAvailability = DataChecker.check(source, target, selector, handlers, this._operationLoader, this._getDataID, this._shouldProcessClientComponents);\n    return getAvailabilityStatus(operationAvailability, operationLastWrittenAt, rootEntry === null || rootEntry === void 0 ? void 0 : rootEntry.fetchTime, this._queryCacheExpirationTime);\n  };\n\n  _proto.retain = function retain(operation) {\n    var _this2 = this;\n\n    var id = operation.request.identifier;\n    var disposed = false;\n\n    var dispose = function dispose() {\n      // Ensure each retain can only dispose once\n      if (disposed) {\n        return;\n      }\n\n      disposed = true; // For Flow: guard against the entry somehow not existing\n\n      var rootEntry = _this2._roots.get(id);\n\n      if (rootEntry == null) {\n        return;\n      } // Decrement the ref count: if it becomes zero it is eligible\n      // for release.\n\n\n      rootEntry.refCount--;\n\n      if (rootEntry.refCount === 0) {\n        var _queryCacheExpirationTime = _this2._queryCacheExpirationTime;\n\n        var rootEntryIsStale = rootEntry.fetchTime != null && _queryCacheExpirationTime != null && rootEntry.fetchTime <= Date.now() - _queryCacheExpirationTime;\n\n        if (rootEntryIsStale) {\n          _this2._roots[\"delete\"](id);\n\n          _this2.scheduleGC();\n        } else {\n          _this2._releaseBuffer.push(id); // If the release buffer is now over-full, remove the least-recently\n          // added entry and schedule a GC. Note that all items in the release\n          // buffer have a refCount of 0.\n\n\n          if (_this2._releaseBuffer.length > _this2._gcReleaseBufferSize) {\n            var _id = _this2._releaseBuffer.shift();\n\n            _this2._roots[\"delete\"](_id);\n\n            _this2.scheduleGC();\n          }\n        }\n      }\n    };\n\n    var rootEntry = this._roots.get(id);\n\n    if (rootEntry != null) {\n      if (rootEntry.refCount === 0) {\n        // This entry should be in the release buffer, but it no longer belongs\n        // there since it's retained. Remove it to maintain the invariant that\n        // all release buffer entries have a refCount of 0.\n        this._releaseBuffer = this._releaseBuffer.filter(function (_id) {\n          return _id !== id;\n        });\n      } // If we've previously retained this operation, increment the refCount\n\n\n      rootEntry.refCount += 1;\n    } else {\n      // Otherwise create a new entry for the operation\n      this._roots.set(id, {\n        operation: operation,\n        refCount: 1,\n        epoch: null,\n        fetchTime: null\n      });\n    }\n\n    return {\n      dispose: dispose\n    };\n  };\n\n  _proto.lookup = function lookup(selector) {\n    var source = this.getSource();\n    var snapshot = RelayReader.read(source, selector);\n\n    if (process.env.NODE_ENV !== \"production\") {\n      deepFreeze(snapshot);\n    }\n\n    return snapshot;\n  } // This method will return a list of updated owners from the subscriptions\n  ;\n\n  _proto.notify = function notify(sourceOperation, invalidateStore) {\n    var _this3 = this;\n\n    var log = this.__log;\n\n    if (log != null) {\n      log({\n        name: 'store.notify.start',\n        sourceOperation: sourceOperation\n      });\n    } // Increment the current write when notifying after executing\n    // a set of changes to the store.\n\n\n    this._currentWriteEpoch++;\n\n    if (invalidateStore === true) {\n      this._globalInvalidationEpoch = this._currentWriteEpoch;\n    }\n\n    var source = this.getSource();\n    var updatedOwners = [];\n\n    this._storeSubscriptions.updateSubscriptions(source, this._updatedRecordIDs, updatedOwners, sourceOperation);\n\n    this._invalidationSubscriptions.forEach(function (subscription) {\n      _this3._updateInvalidationSubscription(subscription, invalidateStore === true);\n    });\n\n    if (log != null) {\n      log({\n        name: 'store.notify.complete',\n        sourceOperation: sourceOperation,\n        updatedRecordIDs: this._updatedRecordIDs,\n        invalidatedRecordIDs: this._invalidatedRecordIDs\n      });\n    }\n\n    this._updatedRecordIDs.clear();\n\n    this._invalidatedRecordIDs.clear(); // If a source operation was provided (indicating the operation\n    // that produced this update to the store), record the current epoch\n    // at which this operation was written.\n\n\n    if (sourceOperation != null) {\n      // We only track the epoch at which the operation was written if\n      // it was previously retained, to keep the size of our operation\n      // epoch map bounded. If a query wasn't retained, we assume it can\n      // may be deleted at any moment and thus is not relevant for us to track\n      // for the purposes of invalidation.\n      var id = sourceOperation.request.identifier;\n\n      var rootEntry = this._roots.get(id);\n\n      if (rootEntry != null) {\n        rootEntry.epoch = this._currentWriteEpoch;\n        rootEntry.fetchTime = Date.now();\n      } else if (sourceOperation.request.node.params.operationKind === 'query' && this._gcReleaseBufferSize > 0 && this._releaseBuffer.length < this._gcReleaseBufferSize) {\n        // The operation isn't retained but there is space in the release buffer:\n        // temporarily track this operation in case the data can be reused soon.\n        var temporaryRootEntry = {\n          operation: sourceOperation,\n          refCount: 0,\n          epoch: this._currentWriteEpoch,\n          fetchTime: Date.now()\n        };\n\n        this._releaseBuffer.push(id);\n\n        this._roots.set(id, temporaryRootEntry);\n      }\n    }\n\n    return updatedOwners;\n  };\n\n  _proto.publish = function publish(source, idsMarkedForInvalidation) {\n    var _this$_optimisticSour3;\n\n    var target = (_this$_optimisticSour3 = this._optimisticSource) !== null && _this$_optimisticSour3 !== void 0 ? _this$_optimisticSour3 : this._recordSource;\n    updateTargetFromSource(target, source, // We increment the current epoch at the end of the set of updates,\n    // in notify(). Here, we pass what will be the incremented value of\n    // the epoch to use to write to invalidated records.\n    this._currentWriteEpoch + 1, idsMarkedForInvalidation, this._updatedRecordIDs, this._invalidatedRecordIDs); // NOTE: log *after* processing the source so that even if a bad log function\n    // mutates the source, it doesn't affect Relay processing of it.\n\n    var log = this.__log;\n\n    if (log != null) {\n      log({\n        name: 'store.publish',\n        source: source,\n        optimistic: target === this._optimisticSource\n      });\n    }\n  };\n\n  _proto.subscribe = function subscribe(snapshot, callback) {\n    return this._storeSubscriptions.subscribe(snapshot, callback);\n  };\n\n  _proto.holdGC = function holdGC() {\n    var _this4 = this;\n\n    if (this._gcRun) {\n      this._gcRun = null;\n      this._shouldScheduleGC = true;\n    }\n\n    this._gcHoldCounter++;\n\n    var dispose = function dispose() {\n      if (_this4._gcHoldCounter > 0) {\n        _this4._gcHoldCounter--;\n\n        if (_this4._gcHoldCounter === 0 && _this4._shouldScheduleGC) {\n          _this4.scheduleGC();\n\n          _this4._shouldScheduleGC = false;\n        }\n      }\n    };\n\n    return {\n      dispose: dispose\n    };\n  };\n\n  _proto.toJSON = function toJSON() {\n    return 'RelayModernStore()';\n  } // Internal API\n  ;\n\n  _proto.__getUpdatedRecordIDs = function __getUpdatedRecordIDs() {\n    return this._updatedRecordIDs;\n  };\n\n  _proto.lookupInvalidationState = function lookupInvalidationState(dataIDs) {\n    var _this5 = this;\n\n    var invalidations = new Map();\n    dataIDs.forEach(function (dataID) {\n      var _RelayModernRecord$ge;\n\n      var record = _this5.getSource().get(dataID);\n\n      invalidations.set(dataID, (_RelayModernRecord$ge = RelayModernRecord.getInvalidationEpoch(record)) !== null && _RelayModernRecord$ge !== void 0 ? _RelayModernRecord$ge : null);\n    });\n    invalidations.set('global', this._globalInvalidationEpoch);\n    return {\n      dataIDs: dataIDs,\n      invalidations: invalidations\n    };\n  };\n\n  _proto.checkInvalidationState = function checkInvalidationState(prevInvalidationState) {\n    var latestInvalidationState = this.lookupInvalidationState(prevInvalidationState.dataIDs);\n    var currentInvalidations = latestInvalidationState.invalidations;\n    var prevInvalidations = prevInvalidationState.invalidations; // Check if global invalidation has changed\n\n    if (currentInvalidations.get('global') !== prevInvalidations.get('global')) {\n      return true;\n    } // Check if the invalidation state for any of the ids has changed.\n\n\n    var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(prevInvalidationState.dataIDs),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var dataID = _step.value;\n\n        if (currentInvalidations.get(dataID) !== prevInvalidations.get(dataID)) {\n          return true;\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n\n    return false;\n  };\n\n  _proto.subscribeToInvalidationState = function subscribeToInvalidationState(invalidationState, callback) {\n    var _this6 = this;\n\n    var subscription = {\n      callback: callback,\n      invalidationState: invalidationState\n    };\n\n    var dispose = function dispose() {\n      _this6._invalidationSubscriptions[\"delete\"](subscription);\n    };\n\n    this._invalidationSubscriptions.add(subscription);\n\n    return {\n      dispose: dispose\n    };\n  };\n\n  _proto._updateInvalidationSubscription = function _updateInvalidationSubscription(subscription, invalidatedStore) {\n    var _this7 = this;\n\n    var callback = subscription.callback,\n        invalidationState = subscription.invalidationState;\n    var dataIDs = invalidationState.dataIDs;\n    var isSubscribedToInvalidatedIDs = invalidatedStore || dataIDs.some(function (dataID) {\n      return _this7._invalidatedRecordIDs.has(dataID);\n    });\n\n    if (!isSubscribedToInvalidatedIDs) {\n      return;\n    }\n\n    callback();\n  };\n\n  _proto.snapshot = function snapshot() {\n    !(this._optimisticSource == null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernStore: Unexpected call to snapshot() while a previous ' + 'snapshot exists.') : invariant(false) : void 0;\n    var log = this.__log;\n\n    if (log != null) {\n      log({\n        name: 'store.snapshot'\n      });\n    }\n\n    this._storeSubscriptions.snapshotSubscriptions(this.getSource());\n\n    if (this._gcRun) {\n      this._gcRun = null;\n      this._shouldScheduleGC = true;\n    }\n\n    this._optimisticSource = RelayOptimisticRecordSource.create(this.getSource());\n  };\n\n  _proto.restore = function restore() {\n    !(this._optimisticSource != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernStore: Unexpected call to restore(), expected a snapshot ' + 'to exist (make sure to call snapshot()).') : invariant(false) : void 0;\n    var log = this.__log;\n\n    if (log != null) {\n      log({\n        name: 'store.restore'\n      });\n    }\n\n    this._optimisticSource = null;\n\n    if (this._shouldScheduleGC) {\n      this.scheduleGC();\n    }\n\n    this._storeSubscriptions.restoreSubscriptions();\n  };\n\n  _proto.scheduleGC = function scheduleGC() {\n    if (this._gcHoldCounter > 0) {\n      this._shouldScheduleGC = true;\n      return;\n    }\n\n    if (this._gcRun) {\n      return;\n    }\n\n    this._gcRun = this._collect();\n\n    this._gcScheduler(this._gcStep);\n  }\n  /**\n   * Run a full GC synchronously.\n   */\n  ;\n\n  _proto.__gc = function __gc() {\n    // Don't run GC while there are optimistic updates applied\n    if (this._optimisticSource != null) {\n      return;\n    }\n\n    var gcRun = this._collect();\n\n    while (!gcRun.next().done) {}\n  };\n\n  _proto._collect = function* _collect() {\n    /* eslint-disable no-labels */\n    top: while (true) {\n      var startEpoch = this._currentWriteEpoch;\n      var references = new Set(); // Mark all records that are traversable from a root\n\n      var _iterator2 = (0, _createForOfIteratorHelper2[\"default\"])(this._roots.values()),\n          _step2;\n\n      try {\n        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n          var operation = _step2.value.operation;\n          var selector = operation.root;\n          RelayReferenceMarker.mark(this._recordSource, selector, references, this._operationLoader, this._shouldProcessClientComponents); // Yield for other work after each operation\n\n          yield; // If the store was updated, restart\n\n          if (startEpoch !== this._currentWriteEpoch) {\n            continue top;\n          }\n        }\n      } catch (err) {\n        _iterator2.e(err);\n      } finally {\n        _iterator2.f();\n      }\n\n      var log = this.__log;\n\n      if (log != null) {\n        log({\n          name: 'store.gc',\n          references: references\n        });\n      } // Sweep records without references\n\n\n      if (references.size === 0) {\n        // Short-circuit if *nothing* is referenced\n        this._recordSource.clear();\n      } else {\n        // Evict any unreferenced nodes\n        var storeIDs = this._recordSource.getRecordIDs();\n\n        for (var ii = 0; ii < storeIDs.length; ii++) {\n          var dataID = storeIDs[ii];\n\n          if (!references.has(dataID)) {\n            this._recordSource.remove(dataID);\n          }\n        }\n      }\n\n      return;\n    }\n  };\n\n  return RelayModernStore;\n}();\n\nfunction initializeRecordSource(target) {\n  if (!target.has(ROOT_ID)) {\n    var rootRecord = RelayModernRecord.create(ROOT_ID, ROOT_TYPE);\n    target.set(ROOT_ID, rootRecord);\n  }\n}\n/**\n * Updates the target with information from source, also updating a mapping of\n * which records in the target were changed as a result.\n * Additionally, will mark records as invalidated at the current write epoch\n * given the set of record ids marked as stale in this update.\n */\n\n\nfunction updateTargetFromSource(target, source, currentWriteEpoch, idsMarkedForInvalidation, updatedRecordIDs, invalidatedRecordIDs) {\n  // First, update any records that were marked for invalidation.\n  // For each provided dataID that was invalidated, we write the\n  // INVALIDATED_AT_KEY on the record, indicating\n  // the epoch at which the record was invalidated.\n  if (idsMarkedForInvalidation) {\n    idsMarkedForInvalidation.forEach(function (dataID) {\n      var targetRecord = target.get(dataID);\n      var sourceRecord = source.get(dataID); // If record was deleted during the update (and also invalidated),\n      // we don't need to count it as an invalidated id\n\n      if (sourceRecord === null) {\n        return;\n      }\n\n      var nextRecord;\n\n      if (targetRecord != null) {\n        // If the target record exists, use it to set the epoch\n        // at which it was invalidated. This record will be updated with\n        // any changes from source in the section below\n        // where we update the target records based on the source.\n        nextRecord = RelayModernRecord.clone(targetRecord);\n      } else {\n        // If the target record doesn't exist, it means that a new record\n        // in the source was created (and also invalidated), so we use that\n        // record to set the epoch at which it was invalidated. This record\n        // will be updated with any changes from source in the section below\n        // where we update the target records based on the source.\n        nextRecord = sourceRecord != null ? RelayModernRecord.clone(sourceRecord) : null;\n      }\n\n      if (!nextRecord) {\n        return;\n      }\n\n      RelayModernRecord.setValue(nextRecord, RelayStoreUtils.INVALIDATED_AT_KEY, currentWriteEpoch);\n      invalidatedRecordIDs.add(dataID); // $FlowFixMe[incompatible-call]\n\n      target.set(dataID, nextRecord);\n    });\n  } // Update the target based on the changes present in source\n\n\n  var dataIDs = source.getRecordIDs();\n\n  for (var ii = 0; ii < dataIDs.length; ii++) {\n    var dataID = dataIDs[ii];\n    var sourceRecord = source.get(dataID);\n    var targetRecord = target.get(dataID); // Prevent mutation of a record from outside the store.\n\n    if (process.env.NODE_ENV !== \"production\") {\n      if (sourceRecord) {\n        RelayModernRecord.freeze(sourceRecord);\n      }\n    }\n\n    if (sourceRecord && targetRecord) {\n      // ReactFlightClientResponses are lazy and only materialize when readRoot\n      // is called when we read the field, so if the record is a Flight field\n      // we always use the new record's data regardless of whether\n      // it actually changed. Let React take care of reconciliation instead.\n      var nextRecord = RelayModernRecord.getType(targetRecord) === RelayStoreReactFlightUtils.REACT_FLIGHT_TYPE_NAME ? sourceRecord : RelayModernRecord.update(targetRecord, sourceRecord);\n\n      if (nextRecord !== targetRecord) {\n        // Prevent mutation of a record from outside the store.\n        if (process.env.NODE_ENV !== \"production\") {\n          RelayModernRecord.freeze(nextRecord);\n        }\n\n        updatedRecordIDs.add(dataID);\n        target.set(dataID, nextRecord);\n      }\n    } else if (sourceRecord === null) {\n      target[\"delete\"](dataID);\n\n      if (targetRecord !== null) {\n        updatedRecordIDs.add(dataID);\n      }\n    } else if (sourceRecord) {\n      target.set(dataID, sourceRecord);\n      updatedRecordIDs.add(dataID);\n    } // don't add explicit undefined\n\n  }\n}\n/**\n * Returns an OperationAvailability given the Availability returned\n * by checking an operation, and when that operation was last written to the store.\n * Specifically, the provided Availability of an operation will contain the\n * value of when a record referenced by the operation was most recently\n * invalidated; given that value, and given when this operation was last\n * written to the store, this function will return the overall\n * OperationAvailability for the operation.\n */\n\n\nfunction getAvailabilityStatus(operationAvailability, operationLastWrittenAt, operationFetchTime, queryCacheExpirationTime) {\n  var mostRecentlyInvalidatedAt = operationAvailability.mostRecentlyInvalidatedAt,\n      status = operationAvailability.status;\n\n  if (typeof mostRecentlyInvalidatedAt === 'number') {\n    // If some record referenced by this operation is stale, then the operation itself is stale\n    // if either the operation itself was never written *or* the operation was last written\n    // before the most recent invalidation of its reachable records.\n    if (operationLastWrittenAt == null || mostRecentlyInvalidatedAt > operationLastWrittenAt) {\n      return {\n        status: 'stale'\n      };\n    }\n  }\n\n  if (status === 'missing') {\n    return {\n      status: 'missing'\n    };\n  }\n\n  if (operationFetchTime != null && queryCacheExpirationTime != null) {\n    var isStale = operationFetchTime <= Date.now() - queryCacheExpirationTime;\n\n    if (isStale) {\n      return {\n        status: 'stale'\n      };\n    }\n  } // There were no invalidations of any reachable records *or* the operation is known to have\n  // been fetched after the most recent record invalidation.\n\n\n  return {\n    status: 'available',\n    fetchTime: operationFetchTime !== null && operationFetchTime !== void 0 ? operationFetchTime : null\n  };\n}\n\nmodule.exports = RelayModernStore;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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 OperationExecutor = require('./OperationExecutor');\n\nvar RelayDefaultHandlerProvider = require('../handlers/RelayDefaultHandlerProvider');\n\nvar RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar RelayObservable = require('../network/RelayObservable');\n\nvar RelayOperationTracker = require('../store/RelayOperationTracker');\n\nvar RelayPublishQueue = require('./RelayPublishQueue');\n\nvar RelayRecordSource = require('./RelayRecordSource');\n\nvar defaultGetDataID = require('./defaultGetDataID');\n\nvar defaultRequiredFieldLogger = require('./defaultRequiredFieldLogger');\n\nvar generateID = require('../util/generateID');\n\nvar invariant = require('invariant');\n\nvar RelayModernEnvironment = /*#__PURE__*/function () {\n  function RelayModernEnvironment(config) {\n    var _this = this;\n\n    var _config$log, _config$requiredField, _config$UNSTABLE_defa, _config$getDataID, _config$handlerProvid, _config$scheduler, _config$isServer, _config$operationTrac;\n\n    this.configName = config.configName;\n    this._treatMissingFieldsAsNull = config.treatMissingFieldsAsNull === true;\n    var operationLoader = config.operationLoader;\n    var reactFlightPayloadDeserializer = config.reactFlightPayloadDeserializer;\n    var reactFlightServerErrorHandler = config.reactFlightServerErrorHandler;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      if (operationLoader != null) {\n        !(typeof operationLoader === 'object' && typeof operationLoader.get === 'function' && typeof operationLoader.load === 'function') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected `operationLoader` to be an object ' + 'with get() and load() functions, got `%s`.', operationLoader) : invariant(false) : void 0;\n      }\n\n      if (reactFlightPayloadDeserializer != null) {\n        !(typeof reactFlightPayloadDeserializer === 'function') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected `reactFlightPayloadDeserializer` ' + ' to be a function, got `%s`.', reactFlightPayloadDeserializer) : invariant(false) : void 0;\n      }\n    }\n\n    this.__log = (_config$log = config.log) !== null && _config$log !== void 0 ? _config$log : emptyFunction;\n    this.requiredFieldLogger = (_config$requiredField = config.requiredFieldLogger) !== null && _config$requiredField !== void 0 ? _config$requiredField : defaultRequiredFieldLogger;\n    this._defaultRenderPolicy = ((_config$UNSTABLE_defa = config.UNSTABLE_defaultRenderPolicy) !== null && _config$UNSTABLE_defa !== void 0 ? _config$UNSTABLE_defa : RelayFeatureFlags.ENABLE_PARTIAL_RENDERING_DEFAULT === true) ? 'partial' : 'full';\n    this._operationLoader = operationLoader;\n    this._operationExecutions = new Map();\n    this._network = this.__wrapNetworkWithLogObserver(config.network);\n    this._getDataID = (_config$getDataID = config.getDataID) !== null && _config$getDataID !== void 0 ? _config$getDataID : defaultGetDataID;\n    this._publishQueue = new RelayPublishQueue(config.store, (_config$handlerProvid = config.handlerProvider) !== null && _config$handlerProvid !== void 0 ? _config$handlerProvid : RelayDefaultHandlerProvider, this._getDataID);\n    this._scheduler = (_config$scheduler = config.scheduler) !== null && _config$scheduler !== void 0 ? _config$scheduler : null;\n    this._store = config.store;\n    this.options = config.options;\n    this._isServer = (_config$isServer = config.isServer) !== null && _config$isServer !== void 0 ? _config$isServer : false;\n\n    this.__setNet = function (newNet) {\n      return _this._network = _this.__wrapNetworkWithLogObserver(newNet);\n    };\n\n    if (process.env.NODE_ENV !== \"production\") {\n      var _require = require('./StoreInspector'),\n          inspect = _require.inspect;\n\n      this.DEBUG_inspect = function (dataID) {\n        return inspect(_this, dataID);\n      };\n    } // Register this Relay Environment with Relay DevTools if it exists.\n    // Note: this must always be the last step in the constructor.\n\n\n    var _global = typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : undefined;\n\n    var devToolsHook = _global && _global.__RELAY_DEVTOOLS_HOOK__;\n\n    if (devToolsHook) {\n      devToolsHook.registerEnvironment(this);\n    }\n\n    this._missingFieldHandlers = config.missingFieldHandlers;\n    this._operationTracker = (_config$operationTrac = config.operationTracker) !== null && _config$operationTrac !== void 0 ? _config$operationTrac : new RelayOperationTracker();\n    this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;\n    this._reactFlightServerErrorHandler = reactFlightServerErrorHandler;\n    this._shouldProcessClientComponents = config.shouldProcessClientComponents;\n  }\n\n  var _proto = RelayModernEnvironment.prototype;\n\n  _proto.getStore = function getStore() {\n    return this._store;\n  };\n\n  _proto.getNetwork = function getNetwork() {\n    return this._network;\n  };\n\n  _proto.getOperationTracker = function getOperationTracker() {\n    return this._operationTracker;\n  };\n\n  _proto.isRequestActive = function isRequestActive(requestIdentifier) {\n    var activeState = this._operationExecutions.get(requestIdentifier);\n\n    return activeState === 'active';\n  };\n\n  _proto.UNSTABLE_getDefaultRenderPolicy = function UNSTABLE_getDefaultRenderPolicy() {\n    return this._defaultRenderPolicy;\n  };\n\n  _proto.applyUpdate = function applyUpdate(optimisticUpdate) {\n    var _this2 = this;\n\n    var dispose = function dispose() {\n      _this2._scheduleUpdates(function () {\n        _this2._publishQueue.revertUpdate(optimisticUpdate);\n\n        _this2._publishQueue.run();\n      });\n    };\n\n    this._scheduleUpdates(function () {\n      _this2._publishQueue.applyUpdate(optimisticUpdate);\n\n      _this2._publishQueue.run();\n    });\n\n    return {\n      dispose: dispose\n    };\n  };\n\n  _proto.revertUpdate = function revertUpdate(update) {\n    var _this3 = this;\n\n    this._scheduleUpdates(function () {\n      _this3._publishQueue.revertUpdate(update);\n\n      _this3._publishQueue.run();\n    });\n  };\n\n  _proto.replaceUpdate = function replaceUpdate(update, newUpdate) {\n    var _this4 = this;\n\n    this._scheduleUpdates(function () {\n      _this4._publishQueue.revertUpdate(update);\n\n      _this4._publishQueue.applyUpdate(newUpdate);\n\n      _this4._publishQueue.run();\n    });\n  };\n\n  _proto.applyMutation = function applyMutation(optimisticConfig) {\n    var subscription = this._execute({\n      createSource: function createSource() {\n        return RelayObservable.create(function (_sink) {});\n      },\n      isClientPayload: false,\n      operation: optimisticConfig.operation,\n      optimisticConfig: optimisticConfig,\n      updater: null\n    }).subscribe({});\n\n    return {\n      dispose: function dispose() {\n        return subscription.unsubscribe();\n      }\n    };\n  };\n\n  _proto.check = function check(operation) {\n    if (this._missingFieldHandlers == null || this._missingFieldHandlers.length === 0) {\n      return this._store.check(operation);\n    }\n\n    return this._checkSelectorAndHandleMissingFields(operation, this._missingFieldHandlers);\n  };\n\n  _proto.commitPayload = function commitPayload(operation, payload) {\n    this._execute({\n      createSource: function createSource() {\n        return RelayObservable.from({\n          data: payload\n        });\n      },\n      isClientPayload: true,\n      operation: operation,\n      optimisticConfig: null,\n      updater: null\n    }).subscribe({});\n  };\n\n  _proto.commitUpdate = function commitUpdate(updater) {\n    var _this5 = this;\n\n    this._scheduleUpdates(function () {\n      _this5._publishQueue.commitUpdate(updater);\n\n      _this5._publishQueue.run();\n    });\n  };\n\n  _proto.lookup = function lookup(readSelector) {\n    return this._store.lookup(readSelector);\n  };\n\n  _proto.subscribe = function subscribe(snapshot, callback) {\n    return this._store.subscribe(snapshot, callback);\n  };\n\n  _proto.retain = function retain(operation) {\n    return this._store.retain(operation);\n  };\n\n  _proto.isServer = function isServer() {\n    return this._isServer;\n  };\n\n  _proto._checkSelectorAndHandleMissingFields = function _checkSelectorAndHandleMissingFields(operation, handlers) {\n    var _this6 = this;\n\n    var target = RelayRecordSource.create();\n\n    var result = this._store.check(operation, {\n      target: target,\n      handlers: handlers\n    });\n\n    if (target.size() > 0) {\n      this._scheduleUpdates(function () {\n        _this6._publishQueue.commitSource(target);\n\n        _this6._publishQueue.run();\n      });\n    }\n\n    return result;\n  };\n\n  _proto._scheduleUpdates = function _scheduleUpdates(task) {\n    var scheduler = this._scheduler;\n\n    if (scheduler != null) {\n      scheduler.schedule(task);\n    } else {\n      task();\n    }\n  }\n  /**\n   * Returns an Observable of GraphQLResponse resulting from executing the\n   * provided Query or Subscription operation, each result of which is then\n   * normalized and committed to the publish queue.\n   *\n   * Note: Observables are lazy, so calling this method will do nothing until\n   * the result is subscribed to: environment.execute({...}).subscribe({...}).\n   */\n  ;\n\n  _proto.execute = function execute(_ref) {\n    var _this7 = this;\n\n    var operation = _ref.operation,\n        updater = _ref.updater;\n    return this._execute({\n      createSource: function createSource() {\n        return _this7._network.execute(operation.request.node.params, operation.request.variables, operation.request.cacheConfig || {}, null);\n      },\n      isClientPayload: false,\n      operation: operation,\n      optimisticConfig: null,\n      updater: updater\n    });\n  }\n  /**\n   * Returns an Observable of GraphQLResponse resulting from executing the\n   * provided Mutation operation, the result of which is then normalized and\n   * committed to the publish queue along with an optional optimistic response\n   * or updater.\n   *\n   * Note: Observables are lazy, so calling this method will do nothing until\n   * the result is subscribed to:\n   * environment.executeMutation({...}).subscribe({...}).\n   */\n  ;\n\n  _proto.executeMutation = function executeMutation(_ref2) {\n    var _this8 = this;\n\n    var operation = _ref2.operation,\n        optimisticResponse = _ref2.optimisticResponse,\n        optimisticUpdater = _ref2.optimisticUpdater,\n        updater = _ref2.updater,\n        uploadables = _ref2.uploadables;\n    var optimisticConfig;\n\n    if (optimisticResponse || optimisticUpdater) {\n      optimisticConfig = {\n        operation: operation,\n        response: optimisticResponse,\n        updater: optimisticUpdater\n      };\n    }\n\n    return this._execute({\n      createSource: function createSource() {\n        return _this8._network.execute(operation.request.node.params, operation.request.variables, (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, operation.request.cacheConfig), {}, {\n          force: true\n        }), uploadables);\n      },\n      isClientPayload: false,\n      operation: operation,\n      optimisticConfig: optimisticConfig,\n      updater: updater\n    });\n  }\n  /**\n   * Returns an Observable of GraphQLResponse resulting from executing the\n   * provided Query or Subscription operation responses, the result of which is\n   * then normalized and comitted to the publish queue.\n   *\n   * Note: Observables are lazy, so calling this method will do nothing until\n   * the result is subscribed to:\n   * environment.executeWithSource({...}).subscribe({...}).\n   */\n  ;\n\n  _proto.executeWithSource = function executeWithSource(_ref3) {\n    var operation = _ref3.operation,\n        source = _ref3.source;\n    return this._execute({\n      createSource: function createSource() {\n        return source;\n      },\n      isClientPayload: false,\n      operation: operation,\n      optimisticConfig: null,\n      updater: null\n    });\n  };\n\n  _proto.toJSON = function toJSON() {\n    var _this$configName;\n\n    return \"RelayModernEnvironment(\".concat((_this$configName = this.configName) !== null && _this$configName !== void 0 ? _this$configName : '', \")\");\n  };\n\n  _proto._execute = function _execute(_ref4) {\n    var _this9 = this;\n\n    var createSource = _ref4.createSource,\n        isClientPayload = _ref4.isClientPayload,\n        operation = _ref4.operation,\n        optimisticConfig = _ref4.optimisticConfig,\n        updater = _ref4.updater;\n    return RelayObservable.create(function (sink) {\n      var executor = OperationExecutor.execute({\n        getDataID: _this9._getDataID,\n        isClientPayload: isClientPayload,\n        operation: operation,\n        operationExecutions: _this9._operationExecutions,\n        operationLoader: _this9._operationLoader,\n        operationTracker: _this9._operationTracker,\n        optimisticConfig: optimisticConfig,\n        publishQueue: _this9._publishQueue,\n        reactFlightPayloadDeserializer: _this9._reactFlightPayloadDeserializer,\n        reactFlightServerErrorHandler: _this9._reactFlightServerErrorHandler,\n        scheduler: _this9._scheduler,\n        shouldProcessClientComponents: _this9._shouldProcessClientComponents,\n        sink: sink,\n        // NOTE: Some product tests expect `Network.execute` to be called only\n        //       when the Observable is executed.\n        source: createSource(),\n        store: _this9._store,\n        treatMissingFieldsAsNull: _this9._treatMissingFieldsAsNull,\n        updater: updater\n      });\n      return function () {\n        return executor.cancel();\n      };\n    });\n  }\n  /**\n   * Wraps the network with logging to ensure that network requests are\n   * always logged. Relying on each network callsite to be wrapped is\n   * untenable and will eventually lead to holes in the logging.\n   */\n  ;\n\n  _proto.__wrapNetworkWithLogObserver = function __wrapNetworkWithLogObserver(network) {\n    var that = this;\n    return {\n      execute: function execute(params, variables, cacheConfig, uploadables) {\n        var transactionID = generateID();\n        var log = that.__log;\n        var logObserver = {\n          start: function start(subscription) {\n            log({\n              name: 'network.start',\n              transactionID: transactionID,\n              params: params,\n              variables: variables,\n              cacheConfig: cacheConfig\n            });\n          },\n          next: function next(response) {\n            log({\n              name: 'network.next',\n              transactionID: transactionID,\n              response: response\n            });\n          },\n          error: function error(_error) {\n            log({\n              name: 'network.error',\n              transactionID: transactionID,\n              error: _error\n            });\n          },\n          complete: function complete() {\n            log({\n              name: 'network.complete',\n              transactionID: transactionID\n            });\n          },\n          unsubscribe: function unsubscribe() {\n            log({\n              name: 'network.unsubscribe',\n              transactionID: transactionID\n            });\n          }\n        };\n\n        var logRequestInfo = function logRequestInfo(info) {\n          log({\n            name: 'network.info',\n            transactionID: transactionID,\n            info: info\n          });\n        };\n\n        return network.execute(params, variables, cacheConfig, uploadables, logRequestInfo)[\"do\"](logObserver);\n      }\n    };\n  };\n\n  return RelayModernEnvironment;\n}(); // Add a sigil for detection by `isRelayModernEnvironment()` to avoid a\n// realm-specific instanceof check, and to aid in module tree-shaking to\n// avoid requiring all of RelayRuntime just to detect its environment.\n\n\nRelayModernEnvironment.prototype['@@RelayModernEnvironment'] = true;\n\nfunction emptyFunction() {}\n\nmodule.exports = RelayModernEnvironment;","/**\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 PreloadableQueryRegistry = /*#__PURE__*/function () {\n  function PreloadableQueryRegistry() {\n    this._preloadableQueries = new Map();\n    this._callbacks = new Map();\n  }\n\n  var _proto = PreloadableQueryRegistry.prototype;\n\n  _proto.set = function set(key, value) {\n    this._preloadableQueries.set(key, value);\n\n    var callbacks = this._callbacks.get(key);\n\n    if (callbacks != null) {\n      callbacks.forEach(function (cb) {\n        try {\n          cb(value);\n        } catch (e) {\n          // We do *not* want to throw in this tick, as this callback is executed\n          // while a query is required for the very first time.\n          setTimeout(function () {\n            throw e;\n          }, 0);\n        }\n      });\n    }\n  };\n\n  _proto.get = function get(key) {\n    return this._preloadableQueries.get(key);\n  };\n\n  _proto.onLoad = function onLoad(key, callback) {\n    var _this$_callbacks$get;\n\n    var callbacks = (_this$_callbacks$get = this._callbacks.get(key)) !== null && _this$_callbacks$get !== void 0 ? _this$_callbacks$get : new Set();\n    callbacks.add(callback);\n\n    var dispose = function dispose() {\n      callbacks[\"delete\"](callback);\n    };\n\n    this._callbacks.set(key, callbacks);\n\n    return {\n      dispose: dispose\n    };\n  };\n\n  _proto.clear = function clear() {\n    this._preloadableQueries.clear();\n  };\n\n  return PreloadableQueryRegistry;\n}();\n\nvar preloadableQueryRegistry = new PreloadableQueryRegistry();\nmodule.exports = preloadableQueryRegistry;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nmodule.exports = _iterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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 id = 100000;\n\nfunction generateID() {\n  return id++;\n}\n\nmodule.exports = generateID;","/**\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 profileHandlersByName = {};\nvar defaultProfiler = {\n  stop: function stop() {}\n};\n/**\n * @public\n *\n * Instruments methods to allow profiling various parts of Relay. Profiling code\n * in Relay consists of three steps:\n *\n *  - Instrument the function to be profiled.\n *  - Attach handlers to the instrumented function.\n *  - Run the code which triggers the handlers.\n *\n * Handlers attached to instrumented methods are called with an instrumentation\n * name and a callback that must be synchronously executed:\n *\n *   instrumentedMethod.attachHandler(function(name, callback) {\n *     const start = performance.now();\n *     callback();\n *     console.log('Duration', performance.now() - start);\n *   });\n *\n * Handlers for profiles are callbacks that return a stop method:\n *\n *   RelayProfiler.attachProfileHandler('profileName', (name, state) => {\n *     const start = performance.now();\n *     return function stop(name, state) {\n *       console.log(`Duration (${name})`, performance.now() - start);\n *     }\n *   });\n */\n\nvar RelayProfiler = {\n  /**\n   * Instruments profiling for arbitrarily asynchronous code by a name.\n   *\n   *   const timerProfiler = RelayProfiler.profile('timeout');\n   *   setTimeout(function() {\n   *     timerProfiler.stop();\n   *   }, 1000);\n   *\n   *   RelayProfiler.attachProfileHandler('timeout', ...);\n   *\n   * Arbitrary state can also be passed into `profile` as a second argument. The\n   * attached profile handlers will receive this as the second argument.\n   */\n  profile: function profile(name, state) {\n    var handlers = profileHandlersByName[name];\n\n    if (handlers && handlers.length > 0) {\n      var stopHandlers = [];\n\n      for (var ii = handlers.length - 1; ii >= 0; ii--) {\n        var stopHandler = handlers[ii](name, state);\n        stopHandlers.unshift(stopHandler);\n      }\n\n      return {\n        stop: function stop(error) {\n          stopHandlers.forEach(function (stopHandler) {\n            return stopHandler(error);\n          });\n        }\n      };\n    }\n\n    return defaultProfiler;\n  },\n\n  /**\n   * Attaches a handler to profiles with the supplied name.\n   */\n  attachProfileHandler: function attachProfileHandler(name, handler) {\n    if (!profileHandlersByName.hasOwnProperty(name)) {\n      profileHandlersByName[name] = [];\n    }\n\n    profileHandlersByName[name].push(handler);\n  },\n\n  /**\n   * Detaches a handler attached via `attachProfileHandler`.\n   */\n  detachProfileHandler: function detachProfileHandler(name, handler) {\n    if (profileHandlersByName.hasOwnProperty(name)) {\n      removeFromArray(profileHandlersByName[name], handler);\n    }\n  }\n};\n\nfunction removeFromArray(array, element) {\n  var index = array.indexOf(element);\n\n  if (index !== -1) {\n    array.splice(index, 1);\n  }\n}\n\nmodule.exports = RelayProfiler;","/**\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 ITERATOR_KEY = Symbol.iterator;\n\nfunction hasOverlappingIDs(seenRecords, updatedRecordIDs) {\n  // $FlowFixMe: Set is an iterable type, accessing its iterator is allowed.\n  var iterator = seenRecords[ITERATOR_KEY]();\n  var next = iterator.next();\n\n  while (!next.done) {\n    var key = next.value;\n\n    if (updatedRecordIDs.has(key)) {\n      return true;\n    }\n\n    next = iterator.next();\n  }\n\n  return false;\n}\n\nmodule.exports = hasOverlappingIDs;","/**\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 ConnectionInterface = require('./ConnectionInterface');\n\nvar getRelayHandleKey = require('../../util/getRelayHandleKey');\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('../../store/ClientID'),\n    generateClientID = _require.generateClientID;\n\nvar _require2 = require('../../store/RelayStoreUtils'),\n    getStableStorageKey = _require2.getStableStorageKey;\n\nvar CONNECTION = 'connection'; // Per-instance incrementing index used to generate unique edge IDs\n\nvar NEXT_EDGE_INDEX = '__connection_next_edge_index';\n/**\n * @public\n *\n * A default runtime handler for connection fields that appends newly fetched\n * edges onto the end of a connection, regardless of the arguments used to fetch\n * those edges.\n */\n\nfunction update(store, payload) {\n  var record = store.get(payload.dataID);\n\n  if (!record) {\n    return;\n  }\n\n  var _ConnectionInterface$ = ConnectionInterface.get(),\n      EDGES = _ConnectionInterface$.EDGES,\n      END_CURSOR = _ConnectionInterface$.END_CURSOR,\n      HAS_NEXT_PAGE = _ConnectionInterface$.HAS_NEXT_PAGE,\n      HAS_PREV_PAGE = _ConnectionInterface$.HAS_PREV_PAGE,\n      PAGE_INFO = _ConnectionInterface$.PAGE_INFO,\n      PAGE_INFO_TYPE = _ConnectionInterface$.PAGE_INFO_TYPE,\n      START_CURSOR = _ConnectionInterface$.START_CURSOR;\n\n  var serverConnection = record.getLinkedRecord(payload.fieldKey);\n  var serverPageInfo = serverConnection && serverConnection.getLinkedRecord(PAGE_INFO);\n\n  if (!serverConnection) {\n    record.setValue(null, payload.handleKey);\n    return;\n  } // In rare cases the handleKey field may be unset even though the client\n  // connection record exists, in this case new edges should still be merged\n  // into the existing client connection record (and the field reset to point\n  // to that record).\n\n\n  var clientConnectionID = generateClientID(record.getDataID(), payload.handleKey);\n  var clientConnectionField = record.getLinkedRecord(payload.handleKey);\n  var clientConnection = clientConnectionField !== null && clientConnectionField !== void 0 ? clientConnectionField : store.get(clientConnectionID);\n  var clientPageInfo = clientConnection && clientConnection.getLinkedRecord(PAGE_INFO);\n\n  if (!clientConnection) {\n    // Initial fetch with data: copy fields from the server record\n    var connection = store.create(clientConnectionID, serverConnection.getType());\n    connection.setValue(0, NEXT_EDGE_INDEX);\n    connection.copyFieldsFrom(serverConnection);\n    var serverEdges = serverConnection.getLinkedRecords(EDGES);\n\n    if (serverEdges) {\n      serverEdges = serverEdges.map(function (edge) {\n        return buildConnectionEdge(store, connection, edge);\n      });\n      connection.setLinkedRecords(serverEdges, EDGES);\n    }\n\n    record.setLinkedRecord(connection, payload.handleKey);\n    clientPageInfo = store.create(generateClientID(connection.getDataID(), PAGE_INFO), PAGE_INFO_TYPE);\n    clientPageInfo.setValue(false, HAS_NEXT_PAGE);\n    clientPageInfo.setValue(false, HAS_PREV_PAGE);\n    clientPageInfo.setValue(null, END_CURSOR);\n    clientPageInfo.setValue(null, START_CURSOR);\n\n    if (serverPageInfo) {\n      clientPageInfo.copyFieldsFrom(serverPageInfo);\n    }\n\n    connection.setLinkedRecord(clientPageInfo, PAGE_INFO);\n  } else {\n    if (clientConnectionField == null) {\n      // If the handleKey field was unset but the client connection record\n      // existed, update the field to point to the record\n      record.setLinkedRecord(clientConnection, payload.handleKey);\n    }\n\n    var _connection = clientConnection; // Subsequent fetches:\n    // - updated fields on the connection\n    // - merge prev/next edges, de-duplicating by node id\n    // - synthesize page info fields\n\n    var _serverEdges = serverConnection.getLinkedRecords(EDGES);\n\n    if (_serverEdges) {\n      _serverEdges = _serverEdges.map(function (edge) {\n        return buildConnectionEdge(store, _connection, edge);\n      });\n    }\n\n    var prevEdges = _connection.getLinkedRecords(EDGES);\n\n    var prevPageInfo = _connection.getLinkedRecord(PAGE_INFO);\n\n    _connection.copyFieldsFrom(serverConnection); // Reset EDGES and PAGE_INFO fields\n\n\n    if (prevEdges) {\n      _connection.setLinkedRecords(prevEdges, EDGES);\n    }\n\n    if (prevPageInfo) {\n      _connection.setLinkedRecord(prevPageInfo, PAGE_INFO);\n    }\n\n    var nextEdges = [];\n    var args = payload.args;\n\n    if (prevEdges && _serverEdges) {\n      // $FlowFixMe[prop-missing]\n      if (args.after != null) {\n        // Forward pagination from the end of the connection: append edges\n        if (clientPageInfo && // $FlowFixMe[prop-missing]\n        args.after === clientPageInfo.getValue(END_CURSOR)) {\n          var nodeIDs = new Set();\n          mergeEdges(prevEdges, nextEdges, nodeIDs);\n          mergeEdges(_serverEdges, nextEdges, nodeIDs);\n        } else {\n          process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Unexpected after cursor `%s`, edges must ' + 'be fetched from the end of the list (`%s`).', args.after, clientPageInfo && clientPageInfo.getValue(END_CURSOR)) : void 0;\n          return;\n        } // $FlowFixMe[prop-missing]\n\n      } else if (args.before != null) {\n        // Backward pagination from the start of the connection: prepend edges\n        if (clientPageInfo && // $FlowFixMe[prop-missing]\n        args.before === clientPageInfo.getValue(START_CURSOR)) {\n          var _nodeIDs = new Set();\n\n          mergeEdges(_serverEdges, nextEdges, _nodeIDs);\n          mergeEdges(prevEdges, nextEdges, _nodeIDs);\n        } else {\n          process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Unexpected before cursor `%s`, edges must ' + 'be fetched from the beginning of the list (`%s`).', args.before, clientPageInfo && clientPageInfo.getValue(START_CURSOR)) : void 0;\n          return;\n        }\n      } else {\n        // The connection was refetched from the beginning/end: replace edges\n        nextEdges = _serverEdges;\n      }\n    } else if (_serverEdges) {\n      nextEdges = _serverEdges;\n    } else {\n      nextEdges = prevEdges;\n    } // Update edges only if they were updated, the null check is\n    // for Flow (prevEdges could be null).\n\n\n    if (nextEdges != null && nextEdges !== prevEdges) {\n      _connection.setLinkedRecords(nextEdges, EDGES);\n    } // Page info should be updated even if no new edge were returned.\n\n\n    if (clientPageInfo && serverPageInfo) {\n      // $FlowFixMe[prop-missing]\n      if (args.after == null && args.before == null) {\n        // The connection was refetched from the beginning/end: replace\n        // page_info\n        clientPageInfo.copyFieldsFrom(serverPageInfo); // $FlowFixMe[prop-missing]\n      } else if (args.before != null || args.after == null && args.last) {\n        clientPageInfo.setValue(!!serverPageInfo.getValue(HAS_PREV_PAGE), HAS_PREV_PAGE);\n        var startCursor = serverPageInfo.getValue(START_CURSOR);\n\n        if (typeof startCursor === 'string') {\n          clientPageInfo.setValue(startCursor, START_CURSOR);\n        } // $FlowFixMe[prop-missing]\n\n      } else if (args.after != null || args.before == null && args.first) {\n        clientPageInfo.setValue(!!serverPageInfo.getValue(HAS_NEXT_PAGE), HAS_NEXT_PAGE);\n        var endCursor = serverPageInfo.getValue(END_CURSOR);\n\n        if (typeof endCursor === 'string') {\n          clientPageInfo.setValue(endCursor, END_CURSOR);\n        }\n      }\n    }\n  }\n}\n/**\n * @public\n *\n * Given a record and the name of the schema field for which a connection was\n * fetched, returns the linked connection record.\n *\n * Example:\n *\n * Given that data has already been fetched on some user `<id>` on the `friends`\n * field:\n *\n * ```\n * fragment FriendsFragment on User {\n *   friends(first: 10) @connection(key: \"FriendsFragment_friends\") {\n *    edges {\n *      node {\n *        id\n *        }\n *      }\n *   }\n * }\n * ```\n *\n * The `friends` connection record can be accessed with:\n *\n * ```\n * store => {\n *   const user = store.get('<id>');\n *   const friends = ConnectionHandler.getConnection(user, 'FriendsFragment_friends');\n *   // Access fields on the connection:\n *   const edges = friends.getLinkedRecords('edges');\n * }\n * ```\n *\n * TODO: t15733312\n * Currently we haven't run into this case yet, but we need to add a `getConnections`\n * that returns an array of the connections under the same `key` regardless of the variables.\n */\n\n\nfunction getConnection(record, key, filters) {\n  var handleKey = getRelayHandleKey(CONNECTION, key, null);\n  return record.getLinkedRecord(handleKey, filters);\n}\n/**\n * @public\n *\n * Given a record ID, the key of a connection field, and optional filters used\n * to identify the connection, returns the connection ID.\n *\n * Example:\n *\n * Given that data has already been fetched on some user `<user-id>` on the `friends`\n * field:\n *\n * ```\n * fragment FriendsFragment on User {\n *   friends(first: 10) @connection(key: \"FriendsFragment_friends\") {\n *     edges {\n *       node {\n *         id\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * The ID of the `friends` connection record can be accessed with:\n *\n * ```\n * store => {\n *   const connectionID = ConnectionHandler.getConnectionID('<user-id>', 'FriendsFragment_friends');\n * }\n * ```\n */\n\n\nfunction getConnectionID(recordID, key, filters) {\n  var handleKey = getRelayHandleKey(CONNECTION, key, null);\n  var storageKey = getStableStorageKey(handleKey, filters);\n  return generateClientID(recordID, storageKey);\n}\n/**\n * @public\n *\n * Inserts an edge after the given cursor, or at the end of the list if no\n * cursor is provided.\n *\n * Example:\n *\n * Given that data has already been fetched on some user `<id>` on the `friends`\n * field:\n *\n * ```\n * fragment FriendsFragment on User {\n *   friends(first: 10) @connection(key: \"FriendsFragment_friends\") {\n *    edges {\n *      node {\n *        id\n *        }\n *      }\n *   }\n * }\n * ```\n *\n * An edge can be appended with:\n *\n * ```\n * store => {\n *   const user = store.get('<id>');\n *   const friends = ConnectionHandler.getConnection(user, 'FriendsFragment_friends');\n *   const edge = store.create('<edge-id>', 'FriendsEdge');\n *   ConnectionHandler.insertEdgeAfter(friends, edge);\n * }\n * ```\n */\n\n\nfunction insertEdgeAfter(record, newEdge, cursor) {\n  var _ConnectionInterface$2 = ConnectionInterface.get(),\n      CURSOR = _ConnectionInterface$2.CURSOR,\n      EDGES = _ConnectionInterface$2.EDGES;\n\n  var edges = record.getLinkedRecords(EDGES);\n\n  if (!edges) {\n    record.setLinkedRecords([newEdge], EDGES);\n    return;\n  }\n\n  var nextEdges;\n\n  if (cursor == null) {\n    nextEdges = edges.concat(newEdge);\n  } else {\n    nextEdges = [];\n    var foundCursor = false;\n\n    for (var ii = 0; ii < edges.length; ii++) {\n      var edge = edges[ii];\n      nextEdges.push(edge);\n\n      if (edge == null) {\n        continue;\n      }\n\n      var edgeCursor = edge.getValue(CURSOR);\n\n      if (cursor === edgeCursor) {\n        nextEdges.push(newEdge);\n        foundCursor = true;\n      }\n    }\n\n    if (!foundCursor) {\n      nextEdges.push(newEdge);\n    }\n  }\n\n  record.setLinkedRecords(nextEdges, EDGES);\n}\n/**\n * @public\n *\n * Creates an edge for a connection record, given a node and edge type.\n */\n\n\nfunction createEdge(store, record, node, edgeType) {\n  var _ConnectionInterface$3 = ConnectionInterface.get(),\n      NODE = _ConnectionInterface$3.NODE; // An index-based client ID could easily conflict (unless it was\n  // auto-incrementing, but there is nowhere to the store the id)\n  // Instead, construct a client ID based on the connection ID and node ID,\n  // which will only conflict if the same node is added to the same connection\n  // twice. This is acceptable since the `insertEdge*` functions ignore\n  // duplicates.\n\n\n  var edgeID = generateClientID(record.getDataID(), node.getDataID());\n  var edge = store.get(edgeID);\n\n  if (!edge) {\n    edge = store.create(edgeID, edgeType);\n  }\n\n  edge.setLinkedRecord(node, NODE);\n\n  if (edge.getValue('cursor') == null) {\n    // Always use null instead of undefined value for cursor\n    // to avoid considering it as missing data\n    edge.setValue(null, 'cursor');\n  }\n\n  return edge;\n}\n/**\n * @public\n *\n * Inserts an edge before the given cursor, or at the beginning of the list if\n * no cursor is provided.\n *\n * Example:\n *\n * Given that data has already been fetched on some user `<id>` on the `friends`\n * field:\n *\n * ```\n * fragment FriendsFragment on User {\n *   friends(first: 10) @connection(key: \"FriendsFragment_friends\") {\n *    edges {\n *      node {\n *        id\n *        }\n *      }\n *   }\n * }\n * ```\n *\n * An edge can be prepended with:\n *\n * ```\n * store => {\n *   const user = store.get('<id>');\n *   const friends = ConnectionHandler.getConnection(user, 'FriendsFragment_friends');\n *   const edge = store.create('<edge-id>', 'FriendsEdge');\n *   ConnectionHandler.insertEdgeBefore(friends, edge);\n * }\n * ```\n */\n\n\nfunction insertEdgeBefore(record, newEdge, cursor) {\n  var _ConnectionInterface$4 = ConnectionInterface.get(),\n      CURSOR = _ConnectionInterface$4.CURSOR,\n      EDGES = _ConnectionInterface$4.EDGES;\n\n  var edges = record.getLinkedRecords(EDGES);\n\n  if (!edges) {\n    record.setLinkedRecords([newEdge], EDGES);\n    return;\n  }\n\n  var nextEdges;\n\n  if (cursor == null) {\n    nextEdges = [newEdge].concat(edges);\n  } else {\n    nextEdges = [];\n    var foundCursor = false;\n\n    for (var ii = 0; ii < edges.length; ii++) {\n      var edge = edges[ii];\n\n      if (edge != null) {\n        var edgeCursor = edge.getValue(CURSOR);\n\n        if (cursor === edgeCursor) {\n          nextEdges.push(newEdge);\n          foundCursor = true;\n        }\n      }\n\n      nextEdges.push(edge);\n    }\n\n    if (!foundCursor) {\n      nextEdges.unshift(newEdge);\n    }\n  }\n\n  record.setLinkedRecords(nextEdges, EDGES);\n}\n/**\n * @public\n *\n * Remove any edges whose `node.id` matches the given id.\n */\n\n\nfunction deleteNode(record, nodeID) {\n  var _ConnectionInterface$5 = ConnectionInterface.get(),\n      EDGES = _ConnectionInterface$5.EDGES,\n      NODE = _ConnectionInterface$5.NODE;\n\n  var edges = record.getLinkedRecords(EDGES);\n\n  if (!edges) {\n    return;\n  }\n\n  var nextEdges;\n\n  for (var ii = 0; ii < edges.length; ii++) {\n    var edge = edges[ii];\n    var node = edge && edge.getLinkedRecord(NODE);\n\n    if (node != null && node.getDataID() === nodeID) {\n      if (nextEdges === undefined) {\n        nextEdges = edges.slice(0, ii);\n      }\n    } else if (nextEdges !== undefined) {\n      nextEdges.push(edge);\n    }\n  }\n\n  if (nextEdges !== undefined) {\n    record.setLinkedRecords(nextEdges, EDGES);\n  }\n}\n/**\n * @internal\n *\n * Creates a copy of an edge with a unique ID based on per-connection-instance\n * incrementing edge index. This is necessary to avoid collisions between edges,\n * which can occur because (edge) client IDs are assigned deterministically\n * based on the path from the nearest node with an id.\n *\n * Example: if the first N edges of the same connection are refetched, the edges\n * from the second fetch will be assigned the same IDs as the first fetch, even\n * though the nodes they point to may be different (or the same and in different\n * order).\n */\n\n\nfunction buildConnectionEdge(store, connection, edge) {\n  if (edge == null) {\n    return edge;\n  }\n\n  var _ConnectionInterface$6 = ConnectionInterface.get(),\n      EDGES = _ConnectionInterface$6.EDGES;\n\n  var edgeIndex = connection.getValue(NEXT_EDGE_INDEX);\n  !(typeof edgeIndex === 'number') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'ConnectionHandler: Expected %s to be a number, got `%s`.', NEXT_EDGE_INDEX, edgeIndex) : invariant(false) : void 0;\n  var edgeID = generateClientID(connection.getDataID(), EDGES, edgeIndex);\n  var connectionEdge = store.create(edgeID, edge.getType());\n  connectionEdge.copyFieldsFrom(edge);\n\n  if (connectionEdge.getValue('cursor') == null) {\n    // Always use null instead of undefined value for cursor\n    // to avoid considering it as missing data\n    connectionEdge.setValue(null, 'cursor');\n  }\n\n  connection.setValue(edgeIndex + 1, NEXT_EDGE_INDEX);\n  return connectionEdge;\n}\n/**\n * @internal\n *\n * Adds the source edges to the target edges, skipping edges with\n * duplicate node ids.\n */\n\n\nfunction mergeEdges(sourceEdges, targetEdges, nodeIDs) {\n  var _ConnectionInterface$7 = ConnectionInterface.get(),\n      NODE = _ConnectionInterface$7.NODE;\n\n  for (var ii = 0; ii < sourceEdges.length; ii++) {\n    var edge = sourceEdges[ii];\n\n    if (!edge) {\n      continue;\n    }\n\n    var node = edge.getLinkedRecord(NODE);\n    var nodeID = node && node.getDataID();\n\n    if (nodeID) {\n      if (nodeIDs.has(nodeID)) {\n        continue;\n      }\n\n      nodeIDs.add(nodeID);\n    }\n\n    targetEdges.push(edge);\n  }\n}\n\nmodule.exports = {\n  buildConnectionEdge: buildConnectionEdge,\n  createEdge: createEdge,\n  deleteNode: deleteNode,\n  getConnection: getConnection,\n  getConnectionID: getConnectionID,\n  insertEdgeAfter: insertEdgeAfter,\n  insertEdgeBefore: insertEdgeBefore,\n  update: update\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 _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar ConnectionHandler = require('../handlers/connection/ConnectionHandler');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar MutationTypes = Object.freeze({\n  RANGE_ADD: 'RANGE_ADD',\n  RANGE_DELETE: 'RANGE_DELETE',\n  NODE_DELETE: 'NODE_DELETE'\n});\nvar RangeOperations = Object.freeze({\n  APPEND: 'append',\n  PREPEND: 'prepend'\n});\n\nfunction convert(configs, request, optimisticUpdater, updater) {\n  var configOptimisticUpdates = optimisticUpdater ? [optimisticUpdater] : [];\n  var configUpdates = updater ? [updater] : [];\n  configs.forEach(function (config) {\n    switch (config.type) {\n      case 'NODE_DELETE':\n        var nodeDeleteResult = nodeDelete(config, request);\n\n        if (nodeDeleteResult) {\n          configOptimisticUpdates.push(nodeDeleteResult);\n          configUpdates.push(nodeDeleteResult);\n        }\n\n        break;\n\n      case 'RANGE_ADD':\n        var rangeAddResult = rangeAdd(config, request);\n\n        if (rangeAddResult) {\n          configOptimisticUpdates.push(rangeAddResult);\n          configUpdates.push(rangeAddResult);\n        }\n\n        break;\n\n      case 'RANGE_DELETE':\n        var rangeDeleteResult = rangeDelete(config, request);\n\n        if (rangeDeleteResult) {\n          configOptimisticUpdates.push(rangeDeleteResult);\n          configUpdates.push(rangeDeleteResult);\n        }\n\n        break;\n    }\n  });\n  return {\n    optimisticUpdater: function optimisticUpdater(store, data) {\n      configOptimisticUpdates.forEach(function (eachOptimisticUpdater) {\n        eachOptimisticUpdater(store, data);\n      });\n    },\n    updater: function updater(store, data) {\n      configUpdates.forEach(function (eachUpdater) {\n        eachUpdater(store, data);\n      });\n    }\n  };\n}\n\nfunction nodeDelete(config, request) {\n  var deletedIDFieldName = config.deletedIDFieldName;\n  var rootField = getRootField(request);\n\n  if (!rootField) {\n    return null;\n  }\n\n  return function (store, data) {\n    var payload = store.getRootField(rootField);\n\n    if (!payload) {\n      return;\n    }\n\n    var deleteID = payload.getValue(deletedIDFieldName);\n    var deleteIDs = Array.isArray(deleteID) ? deleteID : [deleteID];\n    deleteIDs.forEach(function (id) {\n      if (id && typeof id === 'string') {\n        store[\"delete\"](id);\n      }\n    });\n  };\n}\n\nfunction rangeAdd(config, request) {\n  var parentID = config.parentID,\n      connectionInfo = config.connectionInfo,\n      edgeName = config.edgeName;\n\n  if (!parentID) {\n    process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayDeclarativeMutationConfig: For mutation config RANGE_ADD ' + 'to work you must include a parentID') : void 0;\n    return null;\n  }\n\n  var rootField = getRootField(request);\n\n  if (!connectionInfo || !rootField) {\n    return null;\n  }\n\n  return function (store, data) {\n    var parent = store.get(parentID);\n\n    if (!parent) {\n      return;\n    }\n\n    var payload = store.getRootField(rootField);\n\n    if (!payload) {\n      return;\n    }\n\n    var serverEdge = payload.getLinkedRecord(edgeName);\n\n    var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(connectionInfo),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var info = _step.value;\n\n        if (!serverEdge) {\n          continue;\n        }\n\n        var connection = ConnectionHandler.getConnection(parent, info.key, info.filters);\n\n        if (!connection) {\n          continue;\n        }\n\n        var clientEdge = ConnectionHandler.buildConnectionEdge(store, connection, serverEdge);\n\n        if (!clientEdge) {\n          continue;\n        }\n\n        switch (info.rangeBehavior) {\n          case 'append':\n            ConnectionHandler.insertEdgeAfter(connection, clientEdge);\n            break;\n\n          case 'prepend':\n            ConnectionHandler.insertEdgeBefore(connection, clientEdge);\n            break;\n\n          default:\n            process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayDeclarativeMutationConfig: RANGE_ADD range behavior `%s` ' + 'will not work as expected in RelayModern, supported range ' + \"behaviors are 'append', 'prepend'.\", info.rangeBehavior) : void 0;\n            break;\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n  };\n}\n\nfunction rangeDelete(config, request) {\n  var parentID = config.parentID,\n      connectionKeys = config.connectionKeys,\n      pathToConnection = config.pathToConnection,\n      deletedIDFieldName = config.deletedIDFieldName;\n\n  if (!parentID) {\n    process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayDeclarativeMutationConfig: For mutation config RANGE_DELETE ' + 'to work you must include a parentID') : void 0;\n    return null;\n  }\n\n  var rootField = getRootField(request);\n\n  if (!rootField) {\n    return null;\n  }\n\n  return function (store, data) {\n    if (!data) {\n      return;\n    }\n\n    var deleteIDs = [];\n    var deletedIDField = data[rootField];\n\n    if (deletedIDField && Array.isArray(deletedIDFieldName)) {\n      var _iterator2 = (0, _createForOfIteratorHelper2[\"default\"])(deletedIDFieldName),\n          _step2;\n\n      try {\n        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n          var eachField = _step2.value;\n\n          if (deletedIDField && typeof deletedIDField === 'object') {\n            deletedIDField = deletedIDField[eachField];\n          }\n        }\n      } catch (err) {\n        _iterator2.e(err);\n      } finally {\n        _iterator2.f();\n      }\n\n      if (Array.isArray(deletedIDField)) {\n        deletedIDField.forEach(function (idObject) {\n          if (idObject && idObject.id && typeof idObject === 'object' && typeof idObject.id === 'string') {\n            deleteIDs.push(idObject.id);\n          }\n        });\n      } else if (deletedIDField && deletedIDField.id && typeof deletedIDField.id === 'string') {\n        deleteIDs.push(deletedIDField.id);\n      }\n    } else if (deletedIDField && typeof deletedIDFieldName === 'string' && typeof deletedIDField === 'object') {\n      deletedIDField = deletedIDField[deletedIDFieldName];\n\n      if (typeof deletedIDField === 'string') {\n        deleteIDs.push(deletedIDField);\n      } else if (Array.isArray(deletedIDField)) {\n        deletedIDField.forEach(function (id) {\n          if (typeof id === 'string') {\n            deleteIDs.push(id);\n          }\n        });\n      }\n    }\n\n    deleteNode(parentID, connectionKeys, pathToConnection, store, deleteIDs);\n  };\n}\n\nfunction deleteNode(parentID, connectionKeys, pathToConnection, store, deleteIDs) {\n  process.env.NODE_ENV !== \"production\" ? warning(connectionKeys != null, 'RelayDeclarativeMutationConfig: RANGE_DELETE must provide a ' + 'connectionKeys') : void 0;\n  var parent = store.get(parentID);\n\n  if (!parent) {\n    return;\n  }\n\n  if (pathToConnection.length < 2) {\n    process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayDeclarativeMutationConfig: RANGE_DELETE ' + 'pathToConnection must include at least parent and connection') : void 0;\n    return;\n  }\n\n  var recordProxy = parent;\n\n  for (var i = 1; i < pathToConnection.length - 1; i++) {\n    if (recordProxy) {\n      recordProxy = recordProxy.getLinkedRecord(pathToConnection[i]);\n    }\n  } // Should never enter loop except edge cases\n\n\n  if (!connectionKeys || !recordProxy) {\n    process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayDeclarativeMutationConfig: RANGE_DELETE ' + 'pathToConnection is incorrect. Unable to find connection with ' + 'parentID: %s and path: %s', parentID, pathToConnection.toString()) : void 0;\n    return;\n  }\n\n  var _iterator3 = (0, _createForOfIteratorHelper2[\"default\"])(connectionKeys),\n      _step3;\n\n  try {\n    var _loop = function _loop() {\n      var key = _step3.value;\n      var connection = ConnectionHandler.getConnection(recordProxy, key.key, key.filters);\n\n      if (connection) {\n        deleteIDs.forEach(function (deleteID) {\n          ConnectionHandler.deleteNode(connection, deleteID);\n        });\n      }\n    };\n\n    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n      _loop();\n    }\n  } catch (err) {\n    _iterator3.e(err);\n  } finally {\n    _iterator3.f();\n  }\n}\n\nfunction getRootField(request) {\n  if (request.fragment.selections && request.fragment.selections.length > 0 && request.fragment.selections[0].kind === 'LinkedField') {\n    return request.fragment.selections[0].name;\n  }\n\n  return null;\n}\n\nmodule.exports = {\n  MutationTypes: MutationTypes,\n  RangeOperations: RangeOperations,\n  convert: convert\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 _require = require('../store/RelayModernOperationDescriptor'),\n    createOperationDescriptor = _require.createOperationDescriptor;\n\nvar _require2 = require('./GraphQLTag'),\n    getRequest = _require2.getRequest;\n\n/**\n * A helper function to fetch the results of a query. Note that results for\n * fragment spreads are masked: fields must be explicitly listed in the query in\n * order to be accessible in the result object.\n */\nfunction fetchQuery_DEPRECATED(environment, taggedNode, variables, cacheConfig) {\n  var query = getRequest(taggedNode);\n\n  if (query.params.operationKind !== 'query') {\n    throw new Error('fetchQuery: Expected query operation');\n  }\n\n  var operation = createOperationDescriptor(query, variables, cacheConfig);\n  return environment.execute({\n    operation: operation\n  }).map(function () {\n    return environment.lookup(operation.fragment).data;\n  }).toPromise();\n}\n\nmodule.exports = fetchQuery_DEPRECATED;","/**\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 _require = require('../store/ClientID'),\n    generateClientID = _require.generateClientID;\n\nvar _require2 = require('../store/RelayStoreUtils'),\n    getStableStorageKey = _require2.getStableStorageKey;\n\n/**\n * @internal\n *\n * A helper class for manipulating a given record from a record source via an\n * imperative/OO-style API.\n */\nvar RelayRecordProxy = /*#__PURE__*/function () {\n  function RelayRecordProxy(source, mutator, dataID) {\n    this._dataID = dataID;\n    this._mutator = mutator;\n    this._source = source;\n  }\n\n  var _proto = RelayRecordProxy.prototype;\n\n  _proto.copyFieldsFrom = function copyFieldsFrom(source) {\n    this._mutator.copyFields(source.getDataID(), this._dataID);\n  };\n\n  _proto.getDataID = function getDataID() {\n    return this._dataID;\n  };\n\n  _proto.getType = function getType() {\n    var type = this._mutator.getType(this._dataID);\n\n    !(type != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordProxy: Cannot get the type of deleted record `%s`.', this._dataID) : invariant(false) : void 0;\n    return type;\n  };\n\n  _proto.getValue = function getValue(name, args) {\n    var storageKey = getStableStorageKey(name, args);\n    return this._mutator.getValue(this._dataID, storageKey);\n  };\n\n  _proto.setValue = function setValue(value, name, args) {\n    !isValidLeafValue(value) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordProxy#setValue(): Expected a scalar or array of scalars, ' + 'got `%s`.', JSON.stringify(value)) : invariant(false) : void 0;\n    var storageKey = getStableStorageKey(name, args);\n\n    this._mutator.setValue(this._dataID, storageKey, value);\n\n    return this;\n  };\n\n  _proto.getLinkedRecord = function getLinkedRecord(name, args) {\n    var storageKey = getStableStorageKey(name, args);\n\n    var linkedID = this._mutator.getLinkedRecordID(this._dataID, storageKey);\n\n    return linkedID != null ? this._source.get(linkedID) : linkedID;\n  };\n\n  _proto.setLinkedRecord = function setLinkedRecord(record, name, args) {\n    !(record instanceof RelayRecordProxy) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordProxy#setLinkedRecord(): Expected a record, got `%s`.', record) : invariant(false) : void 0;\n    var storageKey = getStableStorageKey(name, args);\n    var linkedID = record.getDataID();\n\n    this._mutator.setLinkedRecordID(this._dataID, storageKey, linkedID);\n\n    return this;\n  };\n\n  _proto.getOrCreateLinkedRecord = function getOrCreateLinkedRecord(name, typeName, args) {\n    var linkedRecord = this.getLinkedRecord(name, args);\n\n    if (!linkedRecord) {\n      var _this$_source$get;\n\n      var storageKey = getStableStorageKey(name, args);\n      var clientID = generateClientID(this.getDataID(), storageKey); // NOTE: it's possible that a client record for this field exists\n      // but the field itself was unset.\n\n      linkedRecord = (_this$_source$get = this._source.get(clientID)) !== null && _this$_source$get !== void 0 ? _this$_source$get : this._source.create(clientID, typeName);\n      this.setLinkedRecord(linkedRecord, name, args);\n    }\n\n    return linkedRecord;\n  };\n\n  _proto.getLinkedRecords = function getLinkedRecords(name, args) {\n    var _this = this;\n\n    var storageKey = getStableStorageKey(name, args);\n\n    var linkedIDs = this._mutator.getLinkedRecordIDs(this._dataID, storageKey);\n\n    if (linkedIDs == null) {\n      return linkedIDs;\n    }\n\n    return linkedIDs.map(function (linkedID) {\n      return linkedID != null ? _this._source.get(linkedID) : linkedID;\n    });\n  };\n\n  _proto.setLinkedRecords = function setLinkedRecords(records, name, args) {\n    !Array.isArray(records) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordProxy#setLinkedRecords(): Expected records to be an array, got `%s`.', records) : invariant(false) : void 0;\n    var storageKey = getStableStorageKey(name, args);\n    var linkedIDs = records.map(function (record) {\n      return record && record.getDataID();\n    });\n\n    this._mutator.setLinkedRecordIDs(this._dataID, storageKey, linkedIDs);\n\n    return this;\n  };\n\n  _proto.invalidateRecord = function invalidateRecord() {\n    this._source.markIDForInvalidation(this._dataID);\n  };\n\n  return RelayRecordProxy;\n}();\n\nfunction isValidLeafValue(value) {\n  return value == null || typeof value !== 'object' || Array.isArray(value) && value.every(isValidLeafValue);\n}\n\nmodule.exports = RelayRecordProxy;","/**\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 invariant = require('invariant');\n\n/**\n * Determines the variables that are in scope for a fragment given the variables\n * in scope at the root query as well as any arguments applied at the fragment\n * spread via `@arguments`.\n *\n * Note that this is analagous to determining function arguments given a function call.\n */\nfunction getFragmentVariables(fragment, rootVariables, argumentVariables) {\n  var variables;\n  fragment.argumentDefinitions.forEach(function (definition) {\n    if (argumentVariables.hasOwnProperty(definition.name)) {\n      return;\n    } // $FlowFixMe[cannot-spread-interface]\n\n\n    variables = variables || (0, _objectSpread2[\"default\"])({}, argumentVariables);\n\n    switch (definition.kind) {\n      case 'LocalArgument':\n        variables[definition.name] = definition.defaultValue;\n        break;\n\n      case 'RootArgument':\n        if (!rootVariables.hasOwnProperty(definition.name)) {\n          /*\n           * Global variables passed as values of @arguments are not required to\n           * be declared unless they are used by the callee fragment or a\n           * descendant. In this case, the root variable may not be defined when\n           * resolving the callee's variables. The value is explicitly set to\n           * undefined to conform to the check in\n           * RelayStoreUtils.getStableVariableValue() that variable keys are all\n           * present.\n           */\n          // $FlowFixMe[incompatible-use]\n          variables[definition.name] = undefined;\n          break;\n        } // $FlowFixMe[incompatible-use]\n        // $FlowFixMe[cannot-write]\n\n\n        variables[definition.name] = rootVariables[definition.name];\n        break;\n\n      default:\n        definition;\n        !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayConcreteVariables: Unexpected node kind `%s` in fragment `%s`.', definition.kind, fragment.name) : invariant(false) : void 0;\n    }\n  });\n  return variables || argumentVariables;\n}\n/**\n * Determines the variables that are in scope for a given operation given values\n * for some/all of its arguments. Extraneous input variables are filtered from\n * the output, and missing variables are set to default values (if given in the\n * operation's definition).\n */\n\n\nfunction getOperationVariables(operation, variables) {\n  var operationVariables = {};\n  operation.argumentDefinitions.forEach(function (def) {\n    var value = def.defaultValue; // $FlowFixMe[cannot-write]\n\n    if (variables[def.name] != null) {\n      value = variables[def.name];\n    }\n\n    operationVariables[def.name] = value;\n  });\n  return operationVariables;\n}\n\nmodule.exports = {\n  getFragmentVariables: getFragmentVariables,\n  getOperationVariables: getOperationVariables\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 ConnectionHandler = require('./connection/ConnectionHandler');\n\nvar MutationHandlers = require('./connection/MutationHandlers');\n\nvar invariant = require('invariant');\n\nfunction RelayDefaultHandlerProvider(handle) {\n  switch (handle) {\n    case 'connection':\n      return ConnectionHandler;\n\n    case 'deleteRecord':\n      return MutationHandlers.DeleteRecordHandler;\n\n    case 'deleteEdge':\n      return MutationHandlers.DeleteEdgeHandler;\n\n    case 'appendEdge':\n      return MutationHandlers.AppendEdgeHandler;\n\n    case 'prependEdge':\n      return MutationHandlers.PrependEdgeHandler;\n\n    case 'appendNode':\n      return MutationHandlers.AppendNodeHandler;\n\n    case 'prependNode':\n      return MutationHandlers.PrependNodeHandler;\n  }\n\n  !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayDefaultHandlerProvider: No handler provided for `%s`.', handle) : invariant(false) : void 0;\n}\n\nmodule.exports = RelayDefaultHandlerProvider;","/**\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// 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 RelayConcreteNode = require('../util/RelayConcreteNode');\n\nvar RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar RelayModernRecord = require('./RelayModernRecord');\n\nvar RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');\n\nvar RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');\n\nvar RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');\n\nvar RelayStoreUtils = require('./RelayStoreUtils');\n\nvar cloneRelayHandleSourceField = require('./cloneRelayHandleSourceField');\n\nvar cloneRelayScalarHandleSourceField = require('./cloneRelayScalarHandleSourceField');\n\nvar getOperation = require('../util/getOperation');\n\nvar invariant = require('invariant');\n\nvar _require = require('./ClientID'),\n    isClientID = _require.isClientID;\n\nvar _require2 = require('./RelayRecordState'),\n    EXISTENT = _require2.EXISTENT,\n    UNKNOWN = _require2.UNKNOWN;\n\nvar _require3 = require('./TypeID'),\n    generateTypeID = _require3.generateTypeID;\n\nvar CONDITION = RelayConcreteNode.CONDITION,\n    CLIENT_COMPONENT = RelayConcreteNode.CLIENT_COMPONENT,\n    CLIENT_EXTENSION = RelayConcreteNode.CLIENT_EXTENSION,\n    DEFER = RelayConcreteNode.DEFER,\n    FLIGHT_FIELD = RelayConcreteNode.FLIGHT_FIELD,\n    FRAGMENT_SPREAD = RelayConcreteNode.FRAGMENT_SPREAD,\n    INLINE_FRAGMENT = RelayConcreteNode.INLINE_FRAGMENT,\n    LINKED_FIELD = RelayConcreteNode.LINKED_FIELD,\n    LINKED_HANDLE = RelayConcreteNode.LINKED_HANDLE,\n    MODULE_IMPORT = RelayConcreteNode.MODULE_IMPORT,\n    SCALAR_FIELD = RelayConcreteNode.SCALAR_FIELD,\n    SCALAR_HANDLE = RelayConcreteNode.SCALAR_HANDLE,\n    STREAM = RelayConcreteNode.STREAM,\n    TYPE_DISCRIMINATOR = RelayConcreteNode.TYPE_DISCRIMINATOR;\nvar ROOT_ID = RelayStoreUtils.ROOT_ID,\n    getModuleOperationKey = RelayStoreUtils.getModuleOperationKey,\n    getStorageKey = RelayStoreUtils.getStorageKey,\n    getArgumentValues = RelayStoreUtils.getArgumentValues;\n/**\n * Synchronously check whether the records required to fulfill the given\n * `selector` are present in `source`.\n *\n * If a field is missing, it uses the provided handlers to attempt to substitute\n * data. The `target` will store all records that are modified because of a\n * successful substitution.\n *\n * If all records are present, returns `true`, otherwise `false`.\n */\n\nfunction check(source, target, selector, handlers, operationLoader, getDataID, shouldProcessClientComponents) {\n  var dataID = selector.dataID,\n      node = selector.node,\n      variables = selector.variables;\n  var checker = new DataChecker(source, target, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents);\n  return checker.check(node, dataID);\n}\n/**\n * @private\n */\n\n\nvar DataChecker = /*#__PURE__*/function () {\n  function DataChecker(source, target, variables, handlers, operationLoader, getDataID, shouldProcessClientComponents) {\n    var mutator = new RelayRecordSourceMutator(source, target);\n    this._mostRecentlyInvalidatedAt = null;\n    this._handlers = handlers;\n    this._mutator = mutator;\n    this._operationLoader = operationLoader !== null && operationLoader !== void 0 ? operationLoader : null;\n    this._recordSourceProxy = new RelayRecordSourceProxy(mutator, getDataID);\n    this._recordWasMissing = false;\n    this._source = source;\n    this._variables = variables;\n    this._shouldProcessClientComponents = shouldProcessClientComponents;\n  }\n\n  var _proto = DataChecker.prototype;\n\n  _proto.check = function check(node, dataID) {\n    this._traverse(node, dataID);\n\n    return this._recordWasMissing === true ? {\n      status: 'missing',\n      mostRecentlyInvalidatedAt: this._mostRecentlyInvalidatedAt\n    } : {\n      status: 'available',\n      mostRecentlyInvalidatedAt: this._mostRecentlyInvalidatedAt\n    };\n  };\n\n  _proto._getVariableValue = function _getVariableValue(name) {\n    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayAsyncLoader(): Undefined variable `%s`.', name) : invariant(false) : void 0; // $FlowFixMe[cannot-write]\n\n    return this._variables[name];\n  };\n\n  _proto._handleMissing = function _handleMissing() {\n    this._recordWasMissing = true;\n  };\n\n  _proto._getDataForHandlers = function _getDataForHandlers(field, dataID) {\n    return {\n      args: field.args ? getArgumentValues(field.args, this._variables) : {},\n      // Getting a snapshot of the record state is potentially expensive since\n      // we will need to merge the sink and source records. Since we do not create\n      // any new records in this process, it is probably reasonable to provide\n      // handlers with a copy of the source record.\n      // The only thing that the provided record will not contain is fields\n      // added by previous handlers.\n      record: this._source.get(dataID)\n    };\n  };\n\n  _proto._handleMissingScalarField = function _handleMissingScalarField(field, dataID) {\n    if (field.name === 'id' && field.alias == null && isClientID(dataID)) {\n      return undefined;\n    }\n\n    var _this$_getDataForHand = this._getDataForHandlers(field, dataID),\n        args = _this$_getDataForHand.args,\n        record = _this$_getDataForHand.record;\n\n    var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(this._handlers),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var handler = _step.value;\n\n        if (handler.kind === 'scalar') {\n          var newValue = handler.handle(field, record, args, this._recordSourceProxy);\n\n          if (newValue !== undefined) {\n            return newValue;\n          }\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n\n    this._handleMissing();\n  };\n\n  _proto._handleMissingLinkField = function _handleMissingLinkField(field, dataID) {\n    var _this$_getDataForHand2 = this._getDataForHandlers(field, dataID),\n        args = _this$_getDataForHand2.args,\n        record = _this$_getDataForHand2.record;\n\n    var _iterator2 = (0, _createForOfIteratorHelper2[\"default\"])(this._handlers),\n        _step2;\n\n    try {\n      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n        var handler = _step2.value;\n\n        if (handler.kind === 'linked') {\n          var newValue = handler.handle(field, record, args, this._recordSourceProxy);\n\n          if (newValue !== undefined && (newValue === null || this._mutator.getStatus(newValue) === EXISTENT)) {\n            return newValue;\n          }\n        }\n      }\n    } catch (err) {\n      _iterator2.e(err);\n    } finally {\n      _iterator2.f();\n    }\n\n    this._handleMissing();\n  };\n\n  _proto._handleMissingPluralLinkField = function _handleMissingPluralLinkField(field, dataID) {\n    var _this = this;\n\n    var _this$_getDataForHand3 = this._getDataForHandlers(field, dataID),\n        args = _this$_getDataForHand3.args,\n        record = _this$_getDataForHand3.record;\n\n    var _iterator3 = (0, _createForOfIteratorHelper2[\"default\"])(this._handlers),\n        _step3;\n\n    try {\n      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n        var handler = _step3.value;\n\n        if (handler.kind === 'pluralLinked') {\n          var newValue = handler.handle(field, record, args, this._recordSourceProxy);\n\n          if (newValue != null) {\n            var allItemsKnown = newValue.every(function (linkedID) {\n              return linkedID != null && _this._mutator.getStatus(linkedID) === EXISTENT;\n            });\n\n            if (allItemsKnown) {\n              return newValue;\n            }\n          } else if (newValue === null) {\n            return null;\n          }\n        }\n      }\n    } catch (err) {\n      _iterator3.e(err);\n    } finally {\n      _iterator3.f();\n    }\n\n    this._handleMissing();\n  };\n\n  _proto._traverse = function _traverse(node, dataID) {\n    var status = this._mutator.getStatus(dataID);\n\n    if (status === UNKNOWN) {\n      this._handleMissing();\n    }\n\n    if (status === EXISTENT) {\n      var record = this._source.get(dataID);\n\n      var invalidatedAt = RelayModernRecord.getInvalidationEpoch(record);\n\n      if (invalidatedAt != null) {\n        this._mostRecentlyInvalidatedAt = this._mostRecentlyInvalidatedAt != null ? Math.max(this._mostRecentlyInvalidatedAt, invalidatedAt) : invalidatedAt;\n      }\n\n      this._traverseSelections(node.selections, dataID);\n    }\n  };\n\n  _proto._traverseSelections = function _traverseSelections(selections, dataID) {\n    var _this2 = this;\n\n    selections.forEach(function (selection) {\n      switch (selection.kind) {\n        case SCALAR_FIELD:\n          _this2._checkScalar(selection, dataID);\n\n          break;\n\n        case LINKED_FIELD:\n          if (selection.plural) {\n            _this2._checkPluralLink(selection, dataID);\n          } else {\n            _this2._checkLink(selection, dataID);\n          }\n\n          break;\n\n        case CONDITION:\n          var conditionValue = _this2._getVariableValue(selection.condition);\n\n          if (conditionValue === selection.passingValue) {\n            _this2._traverseSelections(selection.selections, dataID);\n          }\n\n          break;\n\n        case INLINE_FRAGMENT:\n          {\n            var abstractKey = selection.abstractKey;\n\n            if (abstractKey == null) {\n              // concrete type refinement: only check data if the type exactly matches\n              var typeName = _this2._mutator.getType(dataID);\n\n              if (typeName === selection.type) {\n                _this2._traverseSelections(selection.selections, dataID);\n              }\n            } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {\n              // Abstract refinement: check data depending on whether the type\n              // conforms to the interface/union or not:\n              // - Type known to _not_ implement the interface: don't check the selections.\n              // - Type is known _to_ implement the interface: check selections.\n              // - Unknown whether the type implements the interface: don't check the selections\n              //   and treat the data as missing; we do this because the Relay Compiler\n              //   guarantees that the type discriminator will always be fetched.\n              var recordType = _this2._mutator.getType(dataID);\n\n              !(recordType != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'DataChecker: Expected record `%s` to have a known type', dataID) : invariant(false) : void 0;\n              var typeID = generateTypeID(recordType);\n\n              var implementsInterface = _this2._mutator.getValue(typeID, abstractKey);\n\n              if (implementsInterface === true) {\n                _this2._traverseSelections(selection.selections, dataID);\n              } else if (implementsInterface == null) {\n                // unsure if the type implements the interface: data is\n                // missing so don't bother reading the fragment\n                _this2._handleMissing();\n              } // else false: known to not implement the interface\n\n            } else {\n              // legacy behavior for abstract refinements: always check even\n              // if the type doesn't conform\n              _this2._traverseSelections(selection.selections, dataID);\n            }\n\n            break;\n          }\n\n        case LINKED_HANDLE:\n          {\n            // Handles have no selections themselves; traverse the original field\n            // where the handle was set-up instead.\n            var handleField = cloneRelayHandleSourceField(selection, selections, _this2._variables);\n\n            if (handleField.plural) {\n              _this2._checkPluralLink(handleField, dataID);\n            } else {\n              _this2._checkLink(handleField, dataID);\n            }\n\n            break;\n          }\n\n        case SCALAR_HANDLE:\n          {\n            var _handleField = cloneRelayScalarHandleSourceField(selection, selections, _this2._variables);\n\n            _this2._checkScalar(_handleField, dataID);\n\n            break;\n          }\n\n        case MODULE_IMPORT:\n          _this2._checkModuleImport(selection, dataID);\n\n          break;\n\n        case DEFER:\n        case STREAM:\n          _this2._traverseSelections(selection.selections, dataID);\n\n          break;\n        // $FlowFixMe[incompatible-type]\n\n        case FRAGMENT_SPREAD:\n          _this2._traverseSelections(selection.fragment.selections, dataID);\n\n          break;\n\n        case CLIENT_EXTENSION:\n          var recordWasMissing = _this2._recordWasMissing;\n\n          _this2._traverseSelections(selection.selections, dataID);\n\n          _this2._recordWasMissing = recordWasMissing;\n          break;\n\n        case TYPE_DISCRIMINATOR:\n          if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {\n            var _abstractKey = selection.abstractKey;\n\n            var _recordType = _this2._mutator.getType(dataID);\n\n            !(_recordType != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'DataChecker: Expected record `%s` to have a known type', dataID) : invariant(false) : void 0;\n\n            var _typeID = generateTypeID(_recordType);\n\n            var _implementsInterface = _this2._mutator.getValue(_typeID, _abstractKey);\n\n            if (_implementsInterface == null) {\n              // unsure if the type implements the interface: data is\n              // missing\n              _this2._handleMissing();\n            } // else: if it does or doesn't implement, we don't need to check or skip anything else\n\n          }\n\n          break;\n\n        case FLIGHT_FIELD:\n          if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {\n            _this2._checkFlightField(selection, dataID);\n          } else {\n            throw new Error('Flight fields are not yet supported.');\n          }\n\n          break;\n\n        case CLIENT_COMPONENT:\n          if (_this2._shouldProcessClientComponents === false) {\n            break;\n          }\n\n          _this2._traverseSelections(selection.fragment.selections, dataID);\n\n          break;\n\n        default:\n          selection;\n          !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayAsyncLoader(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;\n      }\n    });\n  };\n\n  _proto._checkModuleImport = function _checkModuleImport(moduleImport, dataID) {\n    var operationLoader = this._operationLoader;\n    !(operationLoader !== null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'DataChecker: Expected an operationLoader to be configured when using `@module`.') : invariant(false) : void 0;\n    var operationKey = getModuleOperationKey(moduleImport.documentName);\n\n    var operationReference = this._mutator.getValue(dataID, operationKey);\n\n    if (operationReference == null) {\n      if (operationReference === undefined) {\n        this._handleMissing();\n      }\n\n      return;\n    }\n\n    var normalizationRootNode = operationLoader.get(operationReference);\n\n    if (normalizationRootNode != null) {\n      var operation = getOperation(normalizationRootNode);\n\n      this._traverse(operation, dataID);\n    } else {\n      // If the fragment is not available, we assume that the data cannot have been\n      // processed yet and must therefore be missing.\n      this._handleMissing();\n    }\n  };\n\n  _proto._checkScalar = function _checkScalar(field, dataID) {\n    var storageKey = getStorageKey(field, this._variables);\n\n    var fieldValue = this._mutator.getValue(dataID, storageKey);\n\n    if (fieldValue === undefined) {\n      fieldValue = this._handleMissingScalarField(field, dataID);\n\n      if (fieldValue !== undefined) {\n        this._mutator.setValue(dataID, storageKey, fieldValue);\n      }\n    }\n  };\n\n  _proto._checkLink = function _checkLink(field, dataID) {\n    var storageKey = getStorageKey(field, this._variables);\n\n    var linkedID = this._mutator.getLinkedRecordID(dataID, storageKey);\n\n    if (linkedID === undefined) {\n      linkedID = this._handleMissingLinkField(field, dataID);\n\n      if (linkedID != null) {\n        this._mutator.setLinkedRecordID(dataID, storageKey, linkedID);\n      } else if (linkedID === null) {\n        this._mutator.setValue(dataID, storageKey, null);\n      }\n    }\n\n    if (linkedID != null) {\n      this._traverse(field, linkedID);\n    }\n  };\n\n  _proto._checkPluralLink = function _checkPluralLink(field, dataID) {\n    var _this3 = this;\n\n    var storageKey = getStorageKey(field, this._variables);\n\n    var linkedIDs = this._mutator.getLinkedRecordIDs(dataID, storageKey);\n\n    if (linkedIDs === undefined) {\n      linkedIDs = this._handleMissingPluralLinkField(field, dataID);\n\n      if (linkedIDs != null) {\n        this._mutator.setLinkedRecordIDs(dataID, storageKey, linkedIDs);\n      } else if (linkedIDs === null) {\n        this._mutator.setValue(dataID, storageKey, null);\n      }\n    }\n\n    if (linkedIDs) {\n      linkedIDs.forEach(function (linkedID) {\n        if (linkedID != null) {\n          _this3._traverse(field, linkedID);\n        }\n      });\n    }\n  };\n\n  _proto._checkFlightField = function _checkFlightField(field, dataID) {\n    var storageKey = getStorageKey(field, this._variables);\n\n    var linkedID = this._mutator.getLinkedRecordID(dataID, storageKey);\n\n    if (linkedID == null) {\n      if (linkedID === undefined) {\n        this._handleMissing();\n\n        return;\n      }\n\n      return;\n    }\n\n    var tree = this._mutator.getValue(linkedID, RelayStoreReactFlightUtils.REACT_FLIGHT_TREE_STORAGE_KEY);\n\n    var reachableExecutableDefinitions = this._mutator.getValue(linkedID, RelayStoreReactFlightUtils.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY);\n\n    if (tree == null || !Array.isArray(reachableExecutableDefinitions)) {\n      this._handleMissing();\n\n      return;\n    }\n\n    var operationLoader = this._operationLoader;\n    !(operationLoader !== null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'DataChecker: Expected an operationLoader to be configured when using ' + 'React Flight.') : invariant(false) : void 0; // In Flight, the variables that are in scope for reachable executable\n    // definitions aren't the same as what's in scope for the outer query.\n\n    var prevVariables = this._variables; // $FlowFixMe[incompatible-cast]\n\n    var _iterator4 = (0, _createForOfIteratorHelper2[\"default\"])(reachableExecutableDefinitions),\n        _step4;\n\n    try {\n      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n        var definition = _step4.value;\n        this._variables = definition.variables;\n        var normalizationRootNode = operationLoader.get(definition.module);\n\n        if (normalizationRootNode != null) {\n          var operation = getOperation(normalizationRootNode);\n\n          this._traverseSelections(operation.selections, ROOT_ID);\n        } else {\n          // If the fragment is not available, we assume that the data cannot have\n          // been processed yet and must therefore be missing.\n          this._handleMissing();\n        }\n      }\n    } catch (err) {\n      _iterator4.e(err);\n    } finally {\n      _iterator4.f();\n    }\n\n    this._variables = prevVariables;\n  };\n\n  return DataChecker;\n}();\n\nmodule.exports = {\n  check: check\n};","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\nmodule.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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 RelayModernRecord = require('../store/RelayModernRecord');\n\nvar invariant = require('invariant');\n\nvar _require = require('../store/RelayRecordState'),\n    EXISTENT = _require.EXISTENT;\n\n/**\n * @internal\n *\n * Wrapper API that is an amalgam of the `RelayModernRecord` API and\n * `MutableRecordSource` interface, implementing copy-on-write semantics for records\n * in a record source.\n *\n * Modifications are applied to fresh copies of records:\n * - Records in `base` are never modified.\n * - Modifications cause a fresh version of a record to be created in `sink`.\n *   These sink records contain only modified fields.\n */\nvar RelayRecordSourceMutator = /*#__PURE__*/function () {\n  function RelayRecordSourceMutator(base, sink) {\n    this.__sources = [sink, base];\n    this._base = base;\n    this._sink = sink;\n  }\n  /**\n   * **UNSTABLE**\n   * This method is likely to be removed in an upcoming release\n   * and should not be relied upon.\n   * TODO T41593196: Remove unstable_getRawRecordWithChanges\n   */\n\n\n  var _proto = RelayRecordSourceMutator.prototype;\n\n  _proto.unstable_getRawRecordWithChanges = function unstable_getRawRecordWithChanges(dataID) {\n    var baseRecord = this._base.get(dataID);\n\n    var sinkRecord = this._sink.get(dataID);\n\n    if (sinkRecord === undefined) {\n      if (baseRecord == null) {\n        return baseRecord;\n      }\n\n      var nextRecord = RelayModernRecord.clone(baseRecord);\n\n      if (process.env.NODE_ENV !== \"production\") {\n        // Prevent mutation of a record from outside the store.\n        RelayModernRecord.freeze(nextRecord);\n      }\n\n      return nextRecord;\n    } else if (sinkRecord === null) {\n      return null;\n    } else if (baseRecord != null) {\n      var _nextRecord = RelayModernRecord.update(baseRecord, sinkRecord);\n\n      if (process.env.NODE_ENV !== \"production\") {\n        if (_nextRecord !== baseRecord) {\n          // Prevent mutation of a record from outside the store.\n          RelayModernRecord.freeze(_nextRecord);\n        }\n      }\n\n      return _nextRecord;\n    } else {\n      var _nextRecord2 = RelayModernRecord.clone(sinkRecord);\n\n      if (process.env.NODE_ENV !== \"production\") {\n        // Prevent mutation of a record from outside the store.\n        RelayModernRecord.freeze(_nextRecord2);\n      }\n\n      return _nextRecord2;\n    }\n  };\n\n  _proto._getSinkRecord = function _getSinkRecord(dataID) {\n    var sinkRecord = this._sink.get(dataID);\n\n    if (!sinkRecord) {\n      var baseRecord = this._base.get(dataID);\n\n      !baseRecord ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordSourceMutator: Cannot modify non-existent record `%s`.', dataID) : invariant(false) : void 0;\n      sinkRecord = RelayModernRecord.create(dataID, RelayModernRecord.getType(baseRecord));\n\n      this._sink.set(dataID, sinkRecord);\n    }\n\n    return sinkRecord;\n  };\n\n  _proto.copyFields = function copyFields(sourceID, sinkID) {\n    var sinkSource = this._sink.get(sourceID);\n\n    var baseSource = this._base.get(sourceID);\n\n    !(sinkSource || baseSource) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordSourceMutator#copyFields(): Cannot copy fields from ' + 'non-existent record `%s`.', sourceID) : invariant(false) : void 0;\n\n    var sink = this._getSinkRecord(sinkID);\n\n    if (baseSource) {\n      RelayModernRecord.copyFields(baseSource, sink);\n    }\n\n    if (sinkSource) {\n      RelayModernRecord.copyFields(sinkSource, sink);\n    }\n  };\n\n  _proto.copyFieldsFromRecord = function copyFieldsFromRecord(record, sinkID) {\n    var sink = this._getSinkRecord(sinkID);\n\n    RelayModernRecord.copyFields(record, sink);\n  };\n\n  _proto.create = function create(dataID, typeName) {\n    !(this._base.getStatus(dataID) !== EXISTENT && this._sink.getStatus(dataID) !== EXISTENT) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordSourceMutator#create(): Cannot create a record with id ' + '`%s`, this record already exists.', dataID) : invariant(false) : void 0;\n    var record = RelayModernRecord.create(dataID, typeName);\n\n    this._sink.set(dataID, record);\n  };\n\n  _proto[\"delete\"] = function _delete(dataID) {\n    this._sink[\"delete\"](dataID);\n  };\n\n  _proto.getStatus = function getStatus(dataID) {\n    return this._sink.has(dataID) ? this._sink.getStatus(dataID) : this._base.getStatus(dataID);\n  };\n\n  _proto.getType = function getType(dataID) {\n    for (var ii = 0; ii < this.__sources.length; ii++) {\n      var record = this.__sources[ii].get(dataID);\n\n      if (record) {\n        return RelayModernRecord.getType(record);\n      } else if (record === null) {\n        return null;\n      }\n    }\n  };\n\n  _proto.getValue = function getValue(dataID, storageKey) {\n    for (var ii = 0; ii < this.__sources.length; ii++) {\n      var record = this.__sources[ii].get(dataID);\n\n      if (record) {\n        var value = RelayModernRecord.getValue(record, storageKey);\n\n        if (value !== undefined) {\n          return value;\n        }\n      } else if (record === null) {\n        return null;\n      }\n    }\n  };\n\n  _proto.setValue = function setValue(dataID, storageKey, value) {\n    var sinkRecord = this._getSinkRecord(dataID);\n\n    RelayModernRecord.setValue(sinkRecord, storageKey, value);\n  };\n\n  _proto.getLinkedRecordID = function getLinkedRecordID(dataID, storageKey) {\n    for (var ii = 0; ii < this.__sources.length; ii++) {\n      var record = this.__sources[ii].get(dataID);\n\n      if (record) {\n        var linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);\n\n        if (linkedID !== undefined) {\n          return linkedID;\n        }\n      } else if (record === null) {\n        return null;\n      }\n    }\n  };\n\n  _proto.setLinkedRecordID = function setLinkedRecordID(dataID, storageKey, linkedID) {\n    var sinkRecord = this._getSinkRecord(dataID);\n\n    RelayModernRecord.setLinkedRecordID(sinkRecord, storageKey, linkedID);\n  };\n\n  _proto.getLinkedRecordIDs = function getLinkedRecordIDs(dataID, storageKey) {\n    for (var ii = 0; ii < this.__sources.length; ii++) {\n      var record = this.__sources[ii].get(dataID);\n\n      if (record) {\n        var linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);\n\n        if (linkedIDs !== undefined) {\n          return linkedIDs;\n        }\n      } else if (record === null) {\n        return null;\n      }\n    }\n  };\n\n  _proto.setLinkedRecordIDs = function setLinkedRecordIDs(dataID, storageKey, linkedIDs) {\n    var sinkRecord = this._getSinkRecord(dataID);\n\n    RelayModernRecord.setLinkedRecordIDs(sinkRecord, storageKey, linkedIDs);\n  };\n\n  return RelayRecordSourceMutator;\n}();\n\nmodule.exports = RelayRecordSourceMutator;","/**\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\nmodule.exports = {\n  DEFAULT_HANDLE_KEY: ''\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 RelayObservable = require('./RelayObservable');\n\n/**\n * Converts a FetchFunction into an ExecuteFunction for use by RelayNetwork.\n */\nfunction convertFetch(fn) {\n  return function fetch(request, variables, cacheConfig, uploadables, logRequestInfo) {\n    var result = fn(request, variables, cacheConfig, uploadables, logRequestInfo); // Note: We allow FetchFunction to directly return Error to indicate\n    // a failure to fetch. To avoid handling this special case throughout the\n    // Relay codebase, it is explicitly handled here.\n\n    if (result instanceof Error) {\n      return RelayObservable.create(function (sink) {\n        return sink.error(result);\n      });\n    }\n\n    return RelayObservable.from(result);\n  };\n}\n\nmodule.exports = {\n  convertFetch: convertFetch\n};","\n    (window.__NEXT_P = window.__NEXT_P || []).push([\n      \"/_app\",\n      function () {\n        return require(\"private-next-pages/_app.tsx\");\n      }\n    ]);\n  ","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\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 */\nvar aStackPool = [];\nvar bStackPool = [];\n/**\n * Checks if two values are equal. Values may be primitives, arrays, or objects.\n * Returns true if both arguments have the same keys and values.\n *\n * @see http://underscorejs.org\n * @copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.\n * @license MIT\n */\n\nfunction areEqual(a, b) {\n  var aStack = aStackPool.length ? aStackPool.pop() : [];\n  var bStack = bStackPool.length ? bStackPool.pop() : [];\n  var result = eq(a, b, aStack, bStack);\n  aStack.length = 0;\n  bStack.length = 0;\n  aStackPool.push(aStack);\n  bStackPool.push(bStack);\n  return result;\n}\n\nfunction eq(a, b, aStack, bStack) {\n  if (a === b) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    return a !== 0 || 1 / a == 1 / b;\n  }\n\n  if (a == null || b == null) {\n    // a or b can be `null` or `undefined`\n    return false;\n  }\n\n  if (typeof a != 'object' || typeof b != 'object') {\n    return false;\n  }\n\n  var objToStr = Object.prototype.toString;\n  var className = objToStr.call(a);\n\n  if (className != objToStr.call(b)) {\n    return false;\n  }\n\n  switch (className) {\n    case '[object String]':\n      return a == String(b);\n\n    case '[object Number]':\n      return isNaN(a) || isNaN(b) ? false : a == Number(b);\n\n    case '[object Date]':\n    case '[object Boolean]':\n      return +a == +b;\n\n    case '[object RegExp]':\n      return a.source == b.source && a.global == b.global && a.multiline == b.multiline && a.ignoreCase == b.ignoreCase;\n  } // Assume equality for cyclic structures.\n\n\n  var length = aStack.length;\n\n  while (length--) {\n    if (aStack[length] == a) {\n      return bStack[length] == b;\n    }\n  }\n\n  aStack.push(a);\n  bStack.push(b);\n  var size = 0; // Recursively compare objects and arrays.\n\n  if (className === '[object Array]') {\n    size = a.length;\n\n    if (size !== b.length) {\n      return false;\n    } // Deep compare the contents, ignoring non-numeric properties.\n\n\n    while (size--) {\n      if (!eq(a[size], b[size], aStack, bStack)) {\n        return false;\n      }\n    }\n  } else {\n    if (a.constructor !== b.constructor) {\n      return false;\n    }\n\n    if (a.hasOwnProperty('valueOf') && b.hasOwnProperty('valueOf')) {\n      return a.valueOf() == b.valueOf();\n    }\n\n    var keys = Object.keys(a);\n\n    if (keys.length != Object.keys(b).length) {\n      return false;\n    }\n\n    for (var i = 0; i < keys.length; i++) {\n      if (!eq(a[keys[i]], b[keys[i]], aStack, bStack)) {\n        return false;\n      }\n    }\n  }\n\n  aStack.pop();\n  bStack.pop();\n  return true;\n}\n\nmodule.exports = areEqual;","/**\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 _require = require('./ClientID'),\n    generateClientID = _require.generateClientID;\n\nvar _require2 = require('./RelayStoreUtils'),\n    ROOT_ID = _require2.ROOT_ID;\n\nvar VIEWER_ID = generateClientID(ROOT_ID, 'viewer');\nvar VIEWER_TYPE = 'Viewer';\nmodule.exports = {\n  VIEWER_ID: VIEWER_ID,\n  VIEWER_TYPE: VIEWER_TYPE\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 warning = require(\"fbjs/lib/warning\");\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar _require = require('../util/RelayConcreteNode'),\n    CONDITION = _require.CONDITION,\n    CLIENT_COMPONENT = _require.CLIENT_COMPONENT,\n    CLIENT_EXTENSION = _require.CLIENT_EXTENSION,\n    DEFER = _require.DEFER,\n    FLIGHT_FIELD = _require.FLIGHT_FIELD,\n    FRAGMENT_SPREAD = _require.FRAGMENT_SPREAD,\n    INLINE_FRAGMENT = _require.INLINE_FRAGMENT,\n    LINKED_FIELD = _require.LINKED_FIELD,\n    LINKED_HANDLE = _require.LINKED_HANDLE,\n    MODULE_IMPORT = _require.MODULE_IMPORT,\n    SCALAR_FIELD = _require.SCALAR_FIELD,\n    SCALAR_HANDLE = _require.SCALAR_HANDLE,\n    STREAM = _require.STREAM,\n    TYPE_DISCRIMINATOR = _require.TYPE_DISCRIMINATOR;\n\nvar validateMutation = function validateMutation() {};\n\nif (process.env.NODE_ENV !== \"production\") {\n  var addFieldToDiff = function addFieldToDiff(path, diff, isScalar) {\n    var deepLoc = diff;\n    path.split('.').forEach(function (key, index, arr) {\n      if (deepLoc[key] == null) {\n        deepLoc[key] = {};\n      }\n\n      if (isScalar && index === arr.length - 1) {\n        deepLoc[key] = '<scalar>';\n      }\n\n      deepLoc = deepLoc[key];\n    });\n  };\n\n  validateMutation = function validateMutation(optimisticResponse, mutation, variables) {\n    var operationName = mutation.operation.name;\n    var context = {\n      path: 'ROOT',\n      visitedPaths: new Set(),\n      variables: variables || {},\n      missingDiff: {},\n      extraDiff: {},\n      moduleImportPaths: new Set()\n    };\n    validateSelections(optimisticResponse, mutation.operation.selections, context);\n    validateOptimisticResponse(optimisticResponse, context);\n    process.env.NODE_ENV !== \"production\" ? warning(context.missingDiff.ROOT == null, 'Expected `optimisticResponse` to match structure of server response for mutation `%s`, please define fields for all of\\n%s', operationName, JSON.stringify(context.missingDiff.ROOT, null, 2)) : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(context.extraDiff.ROOT == null, 'Expected `optimisticResponse` to match structure of server response for mutation `%s`, please remove all fields of\\n%s', operationName, JSON.stringify(context.extraDiff.ROOT, null, 2)) : void 0;\n  };\n\n  var validateSelections = function validateSelections(optimisticResponse, selections, context) {\n    selections.forEach(function (selection) {\n      return validateSelection(optimisticResponse, selection, context);\n    });\n  };\n\n  var validateSelection = function validateSelection(optimisticResponse, selection, context) {\n    switch (selection.kind) {\n      case CONDITION:\n        validateSelections(optimisticResponse, selection.selections, context);\n        return;\n\n      case CLIENT_COMPONENT:\n      case FRAGMENT_SPREAD:\n        validateSelections(optimisticResponse, selection.fragment.selections, context);\n        return;\n\n      case SCALAR_FIELD:\n      case LINKED_FIELD:\n      case FLIGHT_FIELD:\n        return validateField(optimisticResponse, selection, context);\n\n      case INLINE_FRAGMENT:\n        var type = selection.type;\n        var isConcreteType = selection.abstractKey == null;\n        selection.selections.forEach(function (subselection) {\n          if (isConcreteType && optimisticResponse.__typename !== type) {\n            return;\n          }\n\n          validateSelection(optimisticResponse, subselection, context);\n        });\n        return;\n\n      case CLIENT_EXTENSION:\n        selection.selections.forEach(function (subselection) {\n          validateSelection(optimisticResponse, subselection, context);\n        });\n        return;\n\n      case MODULE_IMPORT:\n        return validateModuleImport(context);\n\n      case LINKED_HANDLE:\n      case SCALAR_HANDLE:\n      case DEFER:\n      case STREAM:\n      case TYPE_DISCRIMINATOR:\n        {\n          // TODO(T35864292) - Add missing validations for these types\n          return;\n        }\n\n      default:\n        selection;\n        return;\n    }\n  };\n\n  var validateModuleImport = function validateModuleImport(context) {\n    context.moduleImportPaths.add(context.path);\n  };\n\n  var validateField = function validateField(optimisticResponse, field, context) {\n    var fieldName = field.alias || field.name;\n    var path = \"\".concat(context.path, \".\").concat(fieldName);\n    context.visitedPaths.add(path);\n\n    switch (field.kind) {\n      case SCALAR_FIELD:\n        if (hasOwnProperty.call(optimisticResponse, fieldName) === false) {\n          addFieldToDiff(path, context.missingDiff, true);\n        }\n\n        return;\n\n      case LINKED_FIELD:\n        var selections = field.selections;\n\n        if (optimisticResponse[fieldName] === null || hasOwnProperty.call(optimisticResponse, fieldName) && optimisticResponse[fieldName] === undefined) {\n          return;\n        }\n\n        if (field.plural) {\n          if (Array.isArray(optimisticResponse[fieldName])) {\n            optimisticResponse[fieldName].forEach(function (r) {\n              if (r !== null) {\n                validateSelections(r, selections, (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, context), {}, {\n                  path: path\n                }));\n              }\n            });\n            return;\n          } else {\n            addFieldToDiff(path, context.missingDiff);\n            return;\n          }\n        } else {\n          if (optimisticResponse[fieldName] instanceof Object) {\n            validateSelections(optimisticResponse[fieldName], selections, (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, context), {}, {\n              path: path\n            }));\n            return;\n          } else {\n            addFieldToDiff(path, context.missingDiff);\n            return;\n          }\n        }\n\n      case FLIGHT_FIELD:\n        if (optimisticResponse[fieldName] === null || hasOwnProperty.call(optimisticResponse, fieldName) && optimisticResponse[fieldName] === undefined) {\n          return;\n        }\n\n        throw new Error('validateMutation: Flight fields are not compatible with ' + 'optimistic updates, as React does not have the component code ' + 'necessary to process new data on the client. Instead, you ' + 'should update your code to require a full refetch of the Flight ' + 'field so your UI can be updated.');\n    }\n  };\n\n  var validateOptimisticResponse = function validateOptimisticResponse(optimisticResponse, context) {\n    if (Array.isArray(optimisticResponse)) {\n      optimisticResponse.forEach(function (r) {\n        if (r instanceof Object) {\n          validateOptimisticResponse(r, context);\n        }\n      });\n      return;\n    }\n\n    Object.keys(optimisticResponse).forEach(function (key) {\n      var value = optimisticResponse[key];\n      var path = \"\".concat(context.path, \".\").concat(key); // if it's a module import path we don't have an ast so we cannot validate it\n\n      if (context.moduleImportPaths.has(path)) {\n        return;\n      }\n\n      if (!context.visitedPaths.has(path)) {\n        addFieldToDiff(path, context.extraDiff);\n        return;\n      }\n\n      if (value instanceof Object) {\n        validateOptimisticResponse(value, (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, context), {}, {\n          path: path\n        }));\n      }\n    });\n  };\n}\n\nmodule.exports = validateMutation;","/**\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 RelayObservable = require('../network/RelayObservable');\n\nvar fetchQueryInternal = require('./fetchQueryInternal');\n\nvar invariant = require('invariant');\n\nvar reportMissingRequiredFields = require('../util/reportMissingRequiredFields');\n\nvar _require = require('../store/RelayModernOperationDescriptor'),\n    createOperationDescriptor = _require.createOperationDescriptor;\n\nvar _require2 = require('./GraphQLTag'),\n    getRequest = _require2.getRequest;\n\n/**\n * Fetches the given query and variables on the provided environment,\n * and de-dupes identical in-flight requests.\n *\n * Observing a request:\n * ====================\n * fetchQuery returns an Observable which you can call .subscribe()\n * on. Subscribe optionally takes an Observer, which you can provide to\n * observe network events:\n *\n * ```\n * fetchQuery(environment, query, variables).subscribe({\n *   // Called when network requests starts\n *   start: (subsctiption) => {},\n *\n *   // Called after a payload is received and written to the local store\n *   next: (payload) => {},\n *\n *   // Called when network requests errors\n *   error: (error) => {},\n *\n *   // Called when network requests fully completes\n *   complete: () => {},\n *\n *   // Called when network request is unsubscribed\n *   unsubscribe: (subscription) => {},\n * });\n * ```\n *\n * Request Promise:\n * ================\n * The obervable can be converted to a Promise with .toPromise(), which will\n * resolve to a snapshot of the query data when the first response is received\n * from the server.\n *\n * ```\n * fetchQuery(environment, query, variables).toPromise().then((data) => {\n *   // ...\n * });\n * ```\n *\n * In-flight request de-duping:\n * ============================\n * By default, calling fetchQuery multiple times with the same\n * environment, query and variables will not initiate a new request if a request\n * for those same parameters is already in flight.\n *\n * A request is marked in-flight from the moment it starts until the moment it\n * fully completes, regardless of error or successful completion.\n *\n * NOTE: If the request completes _synchronously_, calling fetchQuery\n * a second time with the same arguments in the same tick will _NOT_ de-dupe\n * the request given that it will no longer be in-flight.\n *\n *\n * Data Retention:\n * ===============\n * This function will NOT retain query data, meaning that it is not guaranteed\n * that the fetched data will remain in the Relay store after the request has\n * completed.\n * If you need to retain the query data outside of the network request,\n * you need to use `environment.retain()`.\n *\n *\n * Cancelling requests:\n * ====================\n * If the disposable returned by subscribe is called while the\n * request is in-flight, the request will be cancelled.\n *\n * ```\n * const disposable = fetchQuery(...).subscribe(...);\n *\n * // This will cancel the request if it is in-flight.\n * disposable.dispose();\n * ```\n * NOTE: When using .toPromise(), the request cannot be cancelled.\n */\nfunction fetchQuery(environment, query, variables, options) {\n  var _options$fetchPolicy;\n\n  var queryNode = getRequest(query);\n  !(queryNode.params.operationKind === 'query') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'fetchQuery: Expected query operation') : invariant(false) : void 0;\n  var networkCacheConfig = (0, _objectSpread2[\"default\"])({\n    force: true\n  }, options === null || options === void 0 ? void 0 : options.networkCacheConfig);\n  var operation = createOperationDescriptor(queryNode, variables, networkCacheConfig);\n  var fetchPolicy = (_options$fetchPolicy = options === null || options === void 0 ? void 0 : options.fetchPolicy) !== null && _options$fetchPolicy !== void 0 ? _options$fetchPolicy : 'network-only';\n\n  function readData(snapshot) {\n    if (snapshot.missingRequiredFields != null) {\n      reportMissingRequiredFields(environment, snapshot.missingRequiredFields);\n    }\n\n    return snapshot.data;\n  }\n\n  switch (fetchPolicy) {\n    case 'network-only':\n      {\n        return getNetworkObservable(environment, operation).map(readData);\n      }\n\n    case 'store-or-network':\n      {\n        if (environment.check(operation).status === 'available') {\n          return RelayObservable.from(environment.lookup(operation.fragment)).map(readData);\n        }\n\n        return getNetworkObservable(environment, operation).map(readData);\n      }\n\n    default:\n      fetchPolicy;\n      throw new Error('fetchQuery: Invalid fetchPolicy ' + fetchPolicy);\n  }\n}\n\nfunction getNetworkObservable(environment, operation) {\n  return fetchQueryInternal.fetchQuery(environment, operation).map(function () {\n    return environment.lookup(operation.fragment);\n  });\n}\n\nmodule.exports = fetchQuery;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\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'use strict';\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  }\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error(\n        'Minified exception occurred; use the non-minified dev environment ' +\n        'for the full error message and additional helpful warnings.'\n      );\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(\n        format.replace(/%s/g, function() { return args[argIndex++]; })\n      );\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n    throw error;\n  }\n};\n\nmodule.exports = invariant;\n","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\nvar iterableToArray = require(\"./iterableToArray.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\nmodule.exports = _toConsumableArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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 PREFIX = 'client:';\n\nfunction generateClientID(id, storageKey, index) {\n  var key = id + ':' + storageKey;\n\n  if (index != null) {\n    key += ':' + index;\n  }\n\n  if (key.indexOf(PREFIX) !== 0) {\n    key = PREFIX + key;\n  }\n\n  return key;\n}\n\nfunction isClientID(id) {\n  return id.indexOf(PREFIX) === 0;\n}\n\nvar localID = 0;\n\nfunction generateUniqueClientID() {\n  return \"\".concat(PREFIX, \"local:\").concat(localID++);\n}\n\nmodule.exports = {\n  generateClientID: generateClientID,\n  generateUniqueClientID: generateUniqueClientID,\n  isClientID: isClientID\n};","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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 RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar RelayModernRecord = require('./RelayModernRecord');\n\nvar invariant = require('invariant');\n\nvar _require = require('../util/RelayConcreteNode'),\n    CLIENT_EXTENSION = _require.CLIENT_EXTENSION,\n    CONDITION = _require.CONDITION,\n    DEFER = _require.DEFER,\n    FLIGHT_FIELD = _require.FLIGHT_FIELD,\n    FRAGMENT_SPREAD = _require.FRAGMENT_SPREAD,\n    INLINE_DATA_FRAGMENT_SPREAD = _require.INLINE_DATA_FRAGMENT_SPREAD,\n    INLINE_FRAGMENT = _require.INLINE_FRAGMENT,\n    LINKED_FIELD = _require.LINKED_FIELD,\n    MODULE_IMPORT = _require.MODULE_IMPORT,\n    REQUIRED_FIELD = _require.REQUIRED_FIELD,\n    RELAY_RESOLVER = _require.RELAY_RESOLVER,\n    SCALAR_FIELD = _require.SCALAR_FIELD,\n    STREAM = _require.STREAM;\n\nvar _require2 = require('./RelayStoreReactFlightUtils'),\n    getReactFlightClientResponse = _require2.getReactFlightClientResponse;\n\nvar _require3 = require('./RelayStoreUtils'),\n    FRAGMENTS_KEY = _require3.FRAGMENTS_KEY,\n    FRAGMENT_OWNER_KEY = _require3.FRAGMENT_OWNER_KEY,\n    FRAGMENT_PROP_NAME_KEY = _require3.FRAGMENT_PROP_NAME_KEY,\n    ID_KEY = _require3.ID_KEY,\n    IS_WITHIN_UNMATCHED_TYPE_REFINEMENT = _require3.IS_WITHIN_UNMATCHED_TYPE_REFINEMENT,\n    MODULE_COMPONENT_KEY = _require3.MODULE_COMPONENT_KEY,\n    ROOT_ID = _require3.ROOT_ID,\n    getArgumentValues = _require3.getArgumentValues,\n    getStorageKey = _require3.getStorageKey,\n    getModuleComponentKey = _require3.getModuleComponentKey;\n\nvar _require4 = require('./ResolverFragments'),\n    withResolverContext = _require4.withResolverContext;\n\nvar _require5 = require('./TypeID'),\n    generateTypeID = _require5.generateTypeID;\n\nfunction read(recordSource, selector) {\n  var reader = new RelayReader(recordSource, selector);\n  return reader.read();\n}\n/**\n * @private\n */\n\n\nvar RelayReader = /*#__PURE__*/function () {\n  function RelayReader(recordSource, selector) {\n    this._isMissingData = false;\n    this._isWithinUnmatchedTypeRefinement = false;\n    this._missingRequiredFields = null;\n    this._owner = selector.owner;\n    this._recordSource = recordSource;\n    this._seenRecords = new Set();\n    this._selector = selector;\n    this._variables = selector.variables;\n  }\n\n  var _proto = RelayReader.prototype;\n\n  _proto.read = function read() {\n    var _this$_selector = this._selector,\n        node = _this$_selector.node,\n        dataID = _this$_selector.dataID,\n        isWithinUnmatchedTypeRefinement = _this$_selector.isWithinUnmatchedTypeRefinement;\n    var abstractKey = node.abstractKey;\n\n    var record = this._recordSource.get(dataID); // Relay historically allowed child fragments to be read even if the root object\n    // did not match the type of the fragment: either the root object has a different\n    // concrete type than the fragment (for concrete fragments) or the root object does\n    // not conform to the interface/union for abstract fragments.\n    // For suspense purposes, however, we want to accurately compute whether any data\n    // is missing: but if the fragment type doesn't match (or a parent type didn't\n    // match), then no data is expected to be present.\n    // By default data is expected to be present unless this selector was read out\n    // from within a non-matching type refinement in a parent fragment:\n\n\n    var isDataExpectedToBePresent = !isWithinUnmatchedTypeRefinement; // If this is a concrete fragment and the concrete type of the record does not\n    // match, then no data is expected to be present.\n\n    if (isDataExpectedToBePresent && abstractKey == null && record != null) {\n      var recordType = RelayModernRecord.getType(record);\n\n      if (recordType !== node.type && dataID !== ROOT_ID) {\n        isDataExpectedToBePresent = false;\n      }\n    } // If this is an abstract fragment (and the precise refinement GK is enabled)\n    // then data is only expected to be present if the record type is known to\n    // implement the interface. If we aren't sure whether the record implements\n    // the interface, that itself constitutes \"expected\" data being missing.\n\n\n    if (isDataExpectedToBePresent && abstractKey != null && record != null && RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {\n      var _recordType = RelayModernRecord.getType(record);\n\n      var typeID = generateTypeID(_recordType);\n\n      var typeRecord = this._recordSource.get(typeID);\n\n      var implementsInterface = typeRecord != null ? RelayModernRecord.getValue(typeRecord, abstractKey) : null;\n\n      if (implementsInterface === false) {\n        // Type known to not implement the interface\n        isDataExpectedToBePresent = false;\n      } else if (implementsInterface == null) {\n        // Don't know if the type implements the interface or not\n        this._isMissingData = true;\n      }\n    }\n\n    this._isWithinUnmatchedTypeRefinement = !isDataExpectedToBePresent;\n\n    var data = this._traverse(node, dataID, null);\n\n    return {\n      data: data,\n      isMissingData: this._isMissingData && isDataExpectedToBePresent,\n      seenRecords: this._seenRecords,\n      selector: this._selector,\n      missingRequiredFields: this._missingRequiredFields\n    };\n  };\n\n  _proto._traverse = function _traverse(node, dataID, prevData) {\n    var record = this._recordSource.get(dataID);\n\n    this._seenRecords.add(dataID);\n\n    if (record == null) {\n      if (record === undefined) {\n        this._isMissingData = true;\n      }\n\n      return record;\n    }\n\n    var data = prevData || {};\n\n    var hadRequiredData = this._traverseSelections(node.selections, record, data);\n\n    return hadRequiredData ? data : null;\n  };\n\n  _proto._getVariableValue = function _getVariableValue(name) {\n    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReader(): Undefined variable `%s`.', name) : invariant(false) : void 0; // $FlowFixMe[cannot-write]\n\n    return this._variables[name];\n  };\n\n  _proto._maybeReportUnexpectedNull = function _maybeReportUnexpectedNull(fieldPath, action, record) {\n    var _this$_missingRequire;\n\n    if (((_this$_missingRequire = this._missingRequiredFields) === null || _this$_missingRequire === void 0 ? void 0 : _this$_missingRequire.action) === 'THROW') {\n      // Chained @required directives may cause a parent `@required(action:\n      // THROW)` field to become null, so the first missing field we\n      // encounter is likely to be the root cause of the error.\n      return;\n    }\n\n    var owner = this._selector.node.name;\n\n    switch (action) {\n      case 'THROW':\n        this._missingRequiredFields = {\n          action: action,\n          field: {\n            path: fieldPath,\n            owner: owner\n          }\n        };\n        return;\n\n      case 'LOG':\n        if (this._missingRequiredFields == null) {\n          this._missingRequiredFields = {\n            action: action,\n            fields: []\n          };\n        }\n\n        this._missingRequiredFields.fields.push({\n          path: fieldPath,\n          owner: owner\n        });\n\n        return;\n\n      default:\n        action;\n    }\n  };\n\n  _proto._traverseSelections = function _traverseSelections(selections, record, data)\n  /* had all expected data */\n  {\n    for (var i = 0; i < selections.length; i++) {\n      var selection = selections[i];\n\n      switch (selection.kind) {\n        case REQUIRED_FIELD:\n          !RelayFeatureFlags.ENABLE_REQUIRED_DIRECTIVES ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReader(): Encountered a `@required` directive at path \"%s\" in `%s` without the `ENABLE_REQUIRED_DIRECTIVES` feature flag enabled.', selection.path, this._selector.node.name) : invariant(false) : void 0;\n\n          var fieldValue = this._readRequiredField(selection, record, data);\n\n          if (fieldValue == null) {\n            var action = selection.action;\n\n            if (action !== 'NONE') {\n              this._maybeReportUnexpectedNull(selection.path, action, record);\n            } // We are going to throw, or our parent is going to get nulled out.\n            // Either way, sibling values are going to be ignored, so we can\n            // bail early here as an optimization.\n\n\n            return false;\n          }\n\n          break;\n\n        case SCALAR_FIELD:\n          this._readScalar(selection, record, data);\n\n          break;\n\n        case LINKED_FIELD:\n          if (selection.plural) {\n            this._readPluralLink(selection, record, data);\n          } else {\n            this._readLink(selection, record, data);\n          }\n\n          break;\n\n        case CONDITION:\n          var conditionValue = this._getVariableValue(selection.condition);\n\n          if (conditionValue === selection.passingValue) {\n            var hasExpectedData = this._traverseSelections(selection.selections, record, data);\n\n            if (!hasExpectedData) {\n              return false;\n            }\n          }\n\n          break;\n\n        case INLINE_FRAGMENT:\n          {\n            var abstractKey = selection.abstractKey;\n\n            if (abstractKey == null) {\n              // concrete type refinement: only read data if the type exactly matches\n              var typeName = RelayModernRecord.getType(record);\n\n              if (typeName != null && typeName === selection.type) {\n                var _hasExpectedData = this._traverseSelections(selection.selections, record, data);\n\n                if (!_hasExpectedData) {\n                  return false;\n                }\n              }\n            } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {\n              // Similar to the logic in read(): data is only expected to be present\n              // if the record is known to conform to the interface. If we don't know\n              // whether the type conforms or not, that constitutes missing data.\n              // store flags to reset after reading\n              var parentIsMissingData = this._isMissingData;\n              var parentIsWithinUnmatchedTypeRefinement = this._isWithinUnmatchedTypeRefinement;\n\n              var _typeName = RelayModernRecord.getType(record);\n\n              var typeID = generateTypeID(_typeName);\n\n              var typeRecord = this._recordSource.get(typeID);\n\n              var implementsInterface = typeRecord != null ? RelayModernRecord.getValue(typeRecord, abstractKey) : null;\n              this._isWithinUnmatchedTypeRefinement = parentIsWithinUnmatchedTypeRefinement || implementsInterface === false;\n\n              this._traverseSelections(selection.selections, record, data);\n\n              this._isWithinUnmatchedTypeRefinement = parentIsWithinUnmatchedTypeRefinement;\n\n              if (implementsInterface === false) {\n                // Type known to not implement the interface, no data expected\n                this._isMissingData = parentIsMissingData;\n              } else if (implementsInterface == null) {\n                // Don't know if the type implements the interface or not\n                this._isMissingData = true;\n              }\n            } else {\n              // legacy behavior for abstract refinements: always read even\n              // if the type doesn't conform and don't reset isMissingData\n              this._traverseSelections(selection.selections, record, data);\n            }\n\n            break;\n          }\n\n        case RELAY_RESOLVER:\n          {\n            if (!RelayFeatureFlags.ENABLE_RELAY_RESOLVERS) {\n              throw new Error('Relay Resolver fields are not yet supported.');\n            }\n\n            this._readResolverField(selection, record, data);\n\n            break;\n          }\n\n        case FRAGMENT_SPREAD:\n          this._createFragmentPointer(selection, record, data);\n\n          break;\n\n        case MODULE_IMPORT:\n          this._readModuleImport(selection, record, data);\n\n          break;\n\n        case INLINE_DATA_FRAGMENT_SPREAD:\n          this._createInlineDataOrResolverFragmentPointer(selection, record, data);\n\n          break;\n\n        case DEFER:\n        case CLIENT_EXTENSION:\n          {\n            var isMissingData = this._isMissingData;\n\n            var _hasExpectedData2 = this._traverseSelections(selection.selections, record, data);\n\n            this._isMissingData = isMissingData;\n\n            if (!_hasExpectedData2) {\n              return false;\n            }\n\n            break;\n          }\n\n        case STREAM:\n          {\n            var _hasExpectedData3 = this._traverseSelections(selection.selections, record, data);\n\n            if (!_hasExpectedData3) {\n              return false;\n            }\n\n            break;\n          }\n\n        case FLIGHT_FIELD:\n          if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {\n            this._readFlightField(selection, record, data);\n          } else {\n            throw new Error('Flight fields are not yet supported.');\n          }\n\n          break;\n\n        default:\n          selection;\n          !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReader(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;\n      }\n    }\n\n    return true;\n  };\n\n  _proto._readRequiredField = function _readRequiredField(selection, record, data) {\n    switch (selection.field.kind) {\n      case SCALAR_FIELD:\n        return this._readScalar(selection.field, record, data);\n\n      case LINKED_FIELD:\n        if (selection.field.plural) {\n          return this._readPluralLink(selection.field, record, data);\n        } else {\n          return this._readLink(selection.field, record, data);\n        }\n\n      default:\n        selection.field.kind;\n        !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReader(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;\n    }\n  };\n\n  _proto._readResolverField = function _readResolverField(selection, record, data) {\n    var _this = this;\n\n    var name = selection.name,\n        alias = selection.alias,\n        resolverModule = selection.resolverModule,\n        fragment = selection.fragment;\n    var key = {\n      __id: RelayModernRecord.getDataID(record),\n      __fragmentOwner: this._owner,\n      __fragments: (0, _defineProperty2[\"default\"])({}, fragment.name, {})\n    };\n    var resolverContext = {\n      getDataForResolverFragment: function getDataForResolverFragment(singularReaderSelector) {\n        var _resolverFragmentData;\n\n        var resolverFragmentData = {};\n\n        _this._createInlineDataOrResolverFragmentPointer(singularReaderSelector.node, record, resolverFragmentData);\n\n        var answer = (_resolverFragmentData = resolverFragmentData[FRAGMENTS_KEY]) === null || _resolverFragmentData === void 0 ? void 0 : _resolverFragmentData[fragment.name];\n        !(typeof answer === 'object' && answer !== null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Expected reader data to contain a __fragments property with a property for the fragment named \".concat(fragment.name, \", but it is missing.\")) : invariant(false) : void 0;\n        return answer;\n      }\n    };\n    var resolverResult = withResolverContext(resolverContext, function () {\n      return (// $FlowFixMe[prop-missing] - resolver module's type signature is a lie\n        resolverModule(key)\n      );\n    });\n    data[alias !== null && alias !== void 0 ? alias : name] = resolverResult;\n    return resolverResult;\n  };\n\n  _proto._readFlightField = function _readFlightField(field, record, data) {\n    var _field$alias;\n\n    var applicationName = (_field$alias = field.alias) !== null && _field$alias !== void 0 ? _field$alias : field.name;\n    var storageKey = getStorageKey(field, this._variables);\n    var reactFlightClientResponseRecordID = RelayModernRecord.getLinkedRecordID(record, storageKey);\n\n    if (reactFlightClientResponseRecordID == null) {\n      data[applicationName] = reactFlightClientResponseRecordID;\n\n      if (reactFlightClientResponseRecordID === undefined) {\n        this._isMissingData = true;\n      }\n\n      return reactFlightClientResponseRecordID;\n    }\n\n    var reactFlightClientResponseRecord = this._recordSource.get(reactFlightClientResponseRecordID);\n\n    this._seenRecords.add(reactFlightClientResponseRecordID);\n\n    if (reactFlightClientResponseRecord == null) {\n      data[applicationName] = reactFlightClientResponseRecord;\n\n      if (reactFlightClientResponseRecord === undefined) {\n        this._isMissingData = true;\n      }\n\n      return reactFlightClientResponseRecord;\n    }\n\n    var clientResponse = getReactFlightClientResponse(reactFlightClientResponseRecord);\n    data[applicationName] = clientResponse;\n    return clientResponse;\n  };\n\n  _proto._readScalar = function _readScalar(field, record, data) {\n    var _field$alias2;\n\n    var applicationName = (_field$alias2 = field.alias) !== null && _field$alias2 !== void 0 ? _field$alias2 : field.name;\n    var storageKey = getStorageKey(field, this._variables);\n    var value = RelayModernRecord.getValue(record, storageKey);\n\n    if (value === undefined) {\n      this._isMissingData = true;\n    }\n\n    data[applicationName] = value;\n    return value;\n  };\n\n  _proto._readLink = function _readLink(field, record, data) {\n    var _field$alias3;\n\n    var applicationName = (_field$alias3 = field.alias) !== null && _field$alias3 !== void 0 ? _field$alias3 : field.name;\n    var storageKey = getStorageKey(field, this._variables);\n    var linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);\n\n    if (linkedID == null) {\n      data[applicationName] = linkedID;\n\n      if (linkedID === undefined) {\n        this._isMissingData = true;\n      }\n\n      return linkedID;\n    }\n\n    var prevData = data[applicationName];\n    !(prevData == null || typeof prevData === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReader(): Expected data for field `%s` on record `%s` ' + 'to be an object, got `%s`.', applicationName, RelayModernRecord.getDataID(record), prevData) : invariant(false) : void 0; // $FlowFixMe[incompatible-variance]\n\n    var value = this._traverse(field, linkedID, prevData);\n\n    data[applicationName] = value;\n    return value;\n  };\n\n  _proto._readPluralLink = function _readPluralLink(field, record, data) {\n    var _this2 = this;\n\n    var _field$alias4;\n\n    var applicationName = (_field$alias4 = field.alias) !== null && _field$alias4 !== void 0 ? _field$alias4 : field.name;\n    var storageKey = getStorageKey(field, this._variables);\n    var linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);\n\n    if (linkedIDs == null) {\n      data[applicationName] = linkedIDs;\n\n      if (linkedIDs === undefined) {\n        this._isMissingData = true;\n      }\n\n      return linkedIDs;\n    }\n\n    var prevData = data[applicationName];\n    !(prevData == null || Array.isArray(prevData)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReader(): Expected data for field `%s` on record `%s` ' + 'to be an array, got `%s`.', applicationName, RelayModernRecord.getDataID(record), prevData) : invariant(false) : void 0;\n    var linkedArray = prevData || [];\n    linkedIDs.forEach(function (linkedID, nextIndex) {\n      if (linkedID == null) {\n        if (linkedID === undefined) {\n          _this2._isMissingData = true;\n        } // $FlowFixMe[cannot-write]\n\n\n        linkedArray[nextIndex] = linkedID;\n        return;\n      }\n\n      var prevItem = linkedArray[nextIndex];\n      !(prevItem == null || typeof prevItem === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReader(): Expected data for field `%s` on record `%s` ' + 'to be an object, got `%s`.', applicationName, RelayModernRecord.getDataID(record), prevItem) : invariant(false) : void 0; // $FlowFixMe[cannot-write]\n      // $FlowFixMe[incompatible-variance]\n\n      linkedArray[nextIndex] = _this2._traverse(field, linkedID, prevItem);\n    });\n    data[applicationName] = linkedArray;\n    return linkedArray;\n  }\n  /**\n   * Reads a ReaderModuleImport, which was generated from using the @module\n   * directive.\n   */\n  ;\n\n  _proto._readModuleImport = function _readModuleImport(moduleImport, record, data) {\n    // Determine the component module from the store: if the field is missing\n    // it means we don't know what component to render the match with.\n    var componentKey = getModuleComponentKey(moduleImport.documentName);\n    var component = RelayModernRecord.getValue(record, componentKey);\n\n    if (component == null) {\n      if (component === undefined) {\n        this._isMissingData = true;\n      }\n\n      return;\n    } // Otherwise, read the fragment and module associated to the concrete\n    // type, and put that data with the result:\n    // - For the matched fragment, create the relevant fragment pointer and add\n    //   the expected fragmentPropName\n    // - For the matched module, create a reference to the module\n\n\n    this._createFragmentPointer({\n      kind: 'FragmentSpread',\n      name: moduleImport.fragmentName,\n      args: null\n    }, record, data);\n\n    data[FRAGMENT_PROP_NAME_KEY] = moduleImport.fragmentPropName;\n    data[MODULE_COMPONENT_KEY] = component;\n  };\n\n  _proto._createFragmentPointer = function _createFragmentPointer(fragmentSpread, record, data) {\n    var fragmentPointers = data[FRAGMENTS_KEY];\n\n    if (fragmentPointers == null) {\n      fragmentPointers = data[FRAGMENTS_KEY] = {};\n    }\n\n    !(typeof fragmentPointers === 'object' && fragmentPointers != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReader: Expected fragment spread data to be an object, got `%s`.', fragmentPointers) : invariant(false) : void 0;\n\n    if (data[ID_KEY] == null) {\n      data[ID_KEY] = RelayModernRecord.getDataID(record);\n    } // $FlowFixMe[cannot-write] - writing into read-only field\n\n\n    fragmentPointers[fragmentSpread.name] = fragmentSpread.args ? getArgumentValues(fragmentSpread.args, this._variables) : {};\n    data[FRAGMENT_OWNER_KEY] = this._owner;\n\n    if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {\n      data[IS_WITHIN_UNMATCHED_TYPE_REFINEMENT] = this._isWithinUnmatchedTypeRefinement;\n    }\n  };\n\n  _proto._createInlineDataOrResolverFragmentPointer = function _createInlineDataOrResolverFragmentPointer(fragmentSpreadOrFragment, record, data) {\n    var fragmentPointers = data[FRAGMENTS_KEY];\n\n    if (fragmentPointers == null) {\n      fragmentPointers = data[FRAGMENTS_KEY] = {};\n    }\n\n    !(typeof fragmentPointers === 'object' && fragmentPointers != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReader: Expected fragment spread data to be an object, got `%s`.', fragmentPointers) : invariant(false) : void 0;\n\n    if (data[ID_KEY] == null) {\n      data[ID_KEY] = RelayModernRecord.getDataID(record);\n    }\n\n    var inlineData = {};\n\n    this._traverseSelections(fragmentSpreadOrFragment.selections, record, inlineData); // $FlowFixMe[cannot-write] - writing into read-only field\n\n\n    fragmentPointers[fragmentSpreadOrFragment.name] = inlineData;\n  };\n\n  return RelayReader;\n}();\n\nmodule.exports = {\n  read: read\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 _require = require('./ViewerPattern'),\n    VIEWER_ID = _require.VIEWER_ID,\n    VIEWER_TYPE = _require.VIEWER_TYPE;\n\nfunction defaultGetDataID(fieldValue, typeName) {\n  if (typeName === VIEWER_TYPE) {\n    // $FlowFixMe[prop-missing]\n    return fieldValue.id == null ? VIEWER_ID : fieldValue.id;\n  } // $FlowFixMe[prop-missing]\n\n\n  return fieldValue.id;\n}\n\nmodule.exports = defaultGetDataID;","/**\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 _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar ConnectionHandler = require('./ConnectionHandler');\n\nvar ConnectionInterface = require('./ConnectionInterface');\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar DeleteRecordHandler = {\n  update: function update(store, payload) {\n    var record = store.get(payload.dataID);\n\n    if (record != null) {\n      var idOrIds = record.getValue(payload.fieldKey);\n\n      if (typeof idOrIds === 'string') {\n        store[\"delete\"](idOrIds);\n      } else if (Array.isArray(idOrIds)) {\n        idOrIds.forEach(function (id) {\n          if (typeof id === 'string') {\n            store[\"delete\"](id);\n          }\n        });\n      }\n    }\n  }\n};\nvar DeleteEdgeHandler = {\n  update: function update(store, payload) {\n    var record = store.get(payload.dataID);\n\n    if (record == null) {\n      return;\n    } // $FlowFixMe[prop-missing]\n\n\n    var connections = payload.handleArgs.connections;\n    !(connections != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'MutationHandlers: Expected connection IDs to be specified.') : invariant(false) : void 0;\n    var idOrIds = record.getValue(payload.fieldKey);\n    var idList = Array.isArray(idOrIds) ? idOrIds : [idOrIds];\n    idList.forEach(function (id) {\n      if (typeof id === 'string') {\n        var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(connections),\n            _step;\n\n        try {\n          for (_iterator.s(); !(_step = _iterator.n()).done;) {\n            var connectionID = _step.value;\n            var connection = store.get(connectionID);\n\n            if (connection == null) {\n              process.env.NODE_ENV !== \"production\" ? warning(false, \"[Relay][Mutation] The connection with id '\".concat(connectionID, \"' doesn't exist.\")) : void 0;\n              continue;\n            }\n\n            ConnectionHandler.deleteNode(connection, id);\n          }\n        } catch (err) {\n          _iterator.e(err);\n        } finally {\n          _iterator.f();\n        }\n      }\n    });\n  }\n};\nvar AppendEdgeHandler = {\n  update: edgeUpdater(ConnectionHandler.insertEdgeAfter)\n};\nvar PrependEdgeHandler = {\n  update: edgeUpdater(ConnectionHandler.insertEdgeBefore)\n};\nvar AppendNodeHandler = {\n  update: nodeUpdater(ConnectionHandler.insertEdgeAfter)\n};\nvar PrependNodeHandler = {\n  update: nodeUpdater(ConnectionHandler.insertEdgeBefore)\n};\n\nfunction edgeUpdater(insertFn) {\n  return function (store, payload) {\n    var _serverEdges;\n\n    var record = store.get(payload.dataID);\n\n    if (record == null) {\n      return;\n    } // $FlowFixMe[prop-missing]\n\n\n    var connections = payload.handleArgs.connections;\n    !(connections != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'MutationHandlers: Expected connection IDs to be specified.') : invariant(false) : void 0;\n    var singleServerEdge, serverEdges;\n\n    try {\n      singleServerEdge = record.getLinkedRecord(payload.fieldKey, payload.args);\n    } catch (_unused) {}\n\n    if (!singleServerEdge) {\n      try {\n        serverEdges = record.getLinkedRecords(payload.fieldKey, payload.args);\n      } catch (_unused2) {}\n    }\n\n    if (singleServerEdge == null && serverEdges == null) {\n      process.env.NODE_ENV !== \"production\" ? warning(false, 'MutationHandlers: Expected the server edge to be non-null.') : void 0;\n      return;\n    }\n\n    var _ConnectionInterface$ = ConnectionInterface.get(),\n        NODE = _ConnectionInterface$.NODE,\n        EDGES = _ConnectionInterface$.EDGES;\n\n    var serverEdgeList = (_serverEdges = serverEdges) !== null && _serverEdges !== void 0 ? _serverEdges : [singleServerEdge];\n\n    var _iterator2 = (0, _createForOfIteratorHelper2[\"default\"])(serverEdgeList),\n        _step2;\n\n    try {\n      var _loop = function _loop() {\n        var serverEdge = _step2.value;\n\n        if (serverEdge == null) {\n          return \"continue\";\n        }\n\n        var serverNode = serverEdge.getLinkedRecord('node');\n\n        if (!serverNode) {\n          return \"continue\";\n        }\n\n        var serverNodeId = serverNode.getDataID();\n\n        var _iterator3 = (0, _createForOfIteratorHelper2[\"default\"])(connections),\n            _step3;\n\n        try {\n          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n            var connectionID = _step3.value;\n            var connection = store.get(connectionID);\n\n            if (connection == null) {\n              process.env.NODE_ENV !== \"production\" ? warning(false, \"[Relay][Mutation] The connection with id '\".concat(connectionID, \"' doesn't exist.\")) : void 0;\n              continue;\n            }\n\n            var nodeAlreadyExistsInConnection = (_connection$getLinked = connection.getLinkedRecords(EDGES)) === null || _connection$getLinked === void 0 ? void 0 : _connection$getLinked.some(function (edge) {\n              var _edge$getLinkedRecord;\n\n              return (edge === null || edge === void 0 ? void 0 : (_edge$getLinkedRecord = edge.getLinkedRecord(NODE)) === null || _edge$getLinkedRecord === void 0 ? void 0 : _edge$getLinkedRecord.getDataID()) === serverNodeId;\n            });\n\n            if (nodeAlreadyExistsInConnection) {\n              continue;\n            }\n\n            var clientEdge = ConnectionHandler.buildConnectionEdge(store, connection, serverEdge);\n            !(clientEdge != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'MutationHandlers: Failed to build the edge.') : invariant(false) : void 0;\n            insertFn(connection, clientEdge);\n          }\n        } catch (err) {\n          _iterator3.e(err);\n        } finally {\n          _iterator3.f();\n        }\n      };\n\n      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n        var _connection$getLinked;\n\n        var _ret = _loop();\n\n        if (_ret === \"continue\") continue;\n      }\n    } catch (err) {\n      _iterator2.e(err);\n    } finally {\n      _iterator2.f();\n    }\n  };\n}\n\nfunction nodeUpdater(insertFn) {\n  return function (store, payload) {\n    var _serverNodes;\n\n    var record = store.get(payload.dataID);\n\n    if (record == null) {\n      return;\n    } // $FlowFixMe[prop-missing]\n\n\n    var _payload$handleArgs = payload.handleArgs,\n        connections = _payload$handleArgs.connections,\n        edgeTypeName = _payload$handleArgs.edgeTypeName;\n    !(connections != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'MutationHandlers: Expected connection IDs to be specified.') : invariant(false) : void 0;\n    !(edgeTypeName != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'MutationHandlers: Expected edge typename to be specified.') : invariant(false) : void 0;\n    var singleServerNode;\n    var serverNodes;\n\n    try {\n      singleServerNode = record.getLinkedRecord(payload.fieldKey, payload.args);\n    } catch (_unused3) {}\n\n    if (!singleServerNode) {\n      try {\n        serverNodes = record.getLinkedRecords(payload.fieldKey, payload.args);\n      } catch (_unused4) {}\n    }\n\n    if (singleServerNode == null && serverNodes == null) {\n      process.env.NODE_ENV !== \"production\" ? warning(false, 'MutationHandlers: Expected target node to exist.') : void 0;\n      return;\n    }\n\n    var _ConnectionInterface$2 = ConnectionInterface.get(),\n        NODE = _ConnectionInterface$2.NODE,\n        EDGES = _ConnectionInterface$2.EDGES;\n\n    var serverNodeList = (_serverNodes = serverNodes) !== null && _serverNodes !== void 0 ? _serverNodes : [singleServerNode];\n\n    var _iterator4 = (0, _createForOfIteratorHelper2[\"default\"])(serverNodeList),\n        _step4;\n\n    try {\n      var _loop2 = function _loop2() {\n        var serverNode = _step4.value;\n\n        if (serverNode == null) {\n          return \"continue\";\n        }\n\n        var serverNodeId = serverNode.getDataID();\n\n        var _iterator5 = (0, _createForOfIteratorHelper2[\"default\"])(connections),\n            _step5;\n\n        try {\n          for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {\n            var connectionID = _step5.value;\n            var connection = store.get(connectionID);\n\n            if (connection == null) {\n              process.env.NODE_ENV !== \"production\" ? warning(false, \"[Relay][Mutation] The connection with id '\".concat(connectionID, \"' doesn't exist.\")) : void 0;\n              continue;\n            }\n\n            var nodeAlreadyExistsInConnection = (_connection$getLinked2 = connection.getLinkedRecords(EDGES)) === null || _connection$getLinked2 === void 0 ? void 0 : _connection$getLinked2.some(function (edge) {\n              var _edge$getLinkedRecord2;\n\n              return (edge === null || edge === void 0 ? void 0 : (_edge$getLinkedRecord2 = edge.getLinkedRecord(NODE)) === null || _edge$getLinkedRecord2 === void 0 ? void 0 : _edge$getLinkedRecord2.getDataID()) === serverNodeId;\n            });\n\n            if (nodeAlreadyExistsInConnection) {\n              continue;\n            }\n\n            var clientEdge = ConnectionHandler.createEdge(store, connection, serverNode, edgeTypeName);\n            !(clientEdge != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'MutationHandlers: Failed to build the edge.') : invariant(false) : void 0;\n            insertFn(connection, clientEdge);\n          }\n        } catch (err) {\n          _iterator5.e(err);\n        } finally {\n          _iterator5.f();\n        }\n      };\n\n      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n        var _connection$getLinked2;\n\n        var _ret2 = _loop2();\n\n        if (_ret2 === \"continue\") continue;\n      }\n    } catch (err) {\n      _iterator4.e(err);\n    } finally {\n      _iterator4.f();\n    }\n  };\n}\n\nmodule.exports = {\n  AppendEdgeHandler: AppendEdgeHandler,\n  DeleteRecordHandler: DeleteRecordHandler,\n  PrependEdgeHandler: PrependEdgeHandler,\n  AppendNodeHandler: AppendNodeHandler,\n  PrependNodeHandler: PrependNodeHandler,\n  DeleteEdgeHandler: DeleteEdgeHandler\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 resolvedPromise = Promise.resolve();\n/**\n * An alternative to setImmediate based on Promise.\n */\n\nfunction resolveImmediate(callback) {\n  resolvedPromise.then(callback)[\"catch\"](throwNext);\n}\n\nfunction throwNext(error) {\n  setTimeout(function () {\n    throw error;\n  }, 0);\n}\n\nmodule.exports = resolveImmediate;","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}\nmodule.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nfunction _createForOfIteratorHelper(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (!it) {\n    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n      var F = function F() {};\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n  var normalCompletion = true,\n    didErr = false,\n    err;\n  return {\n    s: function s() {\n      it = it.call(o);\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}\nmodule.exports = _createForOfIteratorHelper, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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'use strict';\n\nfunction reportMissingRequiredFields(environment, missingRequiredFields) {\n  switch (missingRequiredFields.action) {\n    case 'THROW':\n      {\n        var _missingRequiredField = missingRequiredFields.field,\n            path = _missingRequiredField.path,\n            owner = _missingRequiredField.owner; // This gives the consumer the chance to throw their own error if they so wish.\n\n        environment.requiredFieldLogger({\n          kind: 'missing_field.throw',\n          owner: owner,\n          fieldPath: path\n        });\n        throw new Error(\"Relay: Missing @required value at path '\".concat(path, \"' in '\").concat(owner, \"'.\"));\n      }\n\n    case 'LOG':\n      missingRequiredFields.fields.forEach(function (_ref) {\n        var path = _ref.path,\n            owner = _ref.owner;\n        environment.requiredFieldLogger({\n          kind: 'missing_field.log',\n          owner: owner,\n          fieldPath: path\n        });\n      });\n      break;\n\n    default:\n      {\n        missingRequiredFields.action;\n      }\n  }\n}\n\nmodule.exports = reportMissingRequiredFields;","/**\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 _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar invariant = require('invariant');\n\nvar RelayOperationTracker = /*#__PURE__*/function () {\n  function RelayOperationTracker() {\n    this._ownersToPendingOperationsIdentifier = new Map();\n    this._pendingOperationsToOwnersIdentifier = new Map();\n    this._ownersIdentifierToPromise = new Map();\n  }\n  /**\n   * Update the map of current processing operations with the set of\n   * affected owners and notify subscribers\n   */\n\n\n  var _proto = RelayOperationTracker.prototype;\n\n  _proto.update = function update(pendingOperation, affectedOwners) {\n    if (affectedOwners.size === 0) {\n      return;\n    }\n\n    var pendingOperationIdentifier = pendingOperation.identifier;\n    var newlyAffectedOwnersIdentifier = new Set();\n\n    var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(affectedOwners),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var owner = _step.value;\n        var ownerIdentifier = owner.identifier;\n\n        var pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(ownerIdentifier);\n\n        if (pendingOperationsAffectingOwner != null) {\n          // In this case the `ownerIdentifier` already affected by some operations\n          // We just need to detect, is it the same operation that we already\n          // have in the list, or it's a new operation\n          if (!pendingOperationsAffectingOwner.has(pendingOperationIdentifier)) {\n            pendingOperationsAffectingOwner.add(pendingOperationIdentifier);\n            newlyAffectedOwnersIdentifier.add(ownerIdentifier);\n          }\n        } else {\n          // This is a new `ownerIdentifier` that is affected by the operation\n          this._ownersToPendingOperationsIdentifier.set(ownerIdentifier, new Set([pendingOperationIdentifier]));\n\n          newlyAffectedOwnersIdentifier.add(ownerIdentifier);\n        }\n      } // No new owners were affected by this operation, we may stop here\n\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n\n    if (newlyAffectedOwnersIdentifier.size === 0) {\n      return;\n    } // But, if some owners were affected we need to add them to\n    // the `_pendingOperationsToOwnersIdentifier` set\n\n\n    var ownersAffectedByOperationIdentifier = this._pendingOperationsToOwnersIdentifier.get(pendingOperationIdentifier) || new Set();\n\n    var _iterator2 = (0, _createForOfIteratorHelper2[\"default\"])(newlyAffectedOwnersIdentifier),\n        _step2;\n\n    try {\n      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n        var _ownerIdentifier = _step2.value;\n\n        this._resolveOwnerResolvers(_ownerIdentifier);\n\n        ownersAffectedByOperationIdentifier.add(_ownerIdentifier);\n      }\n    } catch (err) {\n      _iterator2.e(err);\n    } finally {\n      _iterator2.f();\n    }\n\n    this._pendingOperationsToOwnersIdentifier.set(pendingOperationIdentifier, ownersAffectedByOperationIdentifier);\n  }\n  /**\n   * Once pending operation is completed we need to remove it\n   * from all tracking maps\n   */\n  ;\n\n  _proto.complete = function complete(pendingOperation) {\n    var pendingOperationIdentifier = pendingOperation.identifier;\n\n    var affectedOwnersIdentifier = this._pendingOperationsToOwnersIdentifier.get(pendingOperationIdentifier);\n\n    if (affectedOwnersIdentifier == null) {\n      return;\n    } // These were the owners affected only by `pendingOperationIdentifier`\n\n\n    var completedOwnersIdentifier = new Set(); // These were the owners affected by `pendingOperationIdentifier`\n    // and some other operations\n\n    var updatedOwnersIdentifier = new Set();\n\n    var _iterator3 = (0, _createForOfIteratorHelper2[\"default\"])(affectedOwnersIdentifier),\n        _step3;\n\n    try {\n      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n        var ownerIdentifier = _step3.value;\n\n        var pendingOperationsAffectingOwner = this._ownersToPendingOperationsIdentifier.get(ownerIdentifier);\n\n        if (!pendingOperationsAffectingOwner) {\n          continue;\n        }\n\n        pendingOperationsAffectingOwner[\"delete\"](pendingOperationIdentifier);\n\n        if (pendingOperationsAffectingOwner.size > 0) {\n          updatedOwnersIdentifier.add(ownerIdentifier);\n        } else {\n          completedOwnersIdentifier.add(ownerIdentifier);\n        }\n      } // Complete subscriptions for all owners, affected by `pendingOperationIdentifier`\n\n    } catch (err) {\n      _iterator3.e(err);\n    } finally {\n      _iterator3.f();\n    }\n\n    var _iterator4 = (0, _createForOfIteratorHelper2[\"default\"])(completedOwnersIdentifier),\n        _step4;\n\n    try {\n      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n        var _ownerIdentifier2 = _step4.value;\n\n        this._resolveOwnerResolvers(_ownerIdentifier2);\n\n        this._ownersToPendingOperationsIdentifier[\"delete\"](_ownerIdentifier2);\n      } // Update all ownerIdentifier that were updated by `pendingOperationIdentifier` but still\n      // are affected by other operations\n\n    } catch (err) {\n      _iterator4.e(err);\n    } finally {\n      _iterator4.f();\n    }\n\n    var _iterator5 = (0, _createForOfIteratorHelper2[\"default\"])(updatedOwnersIdentifier),\n        _step5;\n\n    try {\n      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {\n        var _ownerIdentifier3 = _step5.value;\n\n        this._resolveOwnerResolvers(_ownerIdentifier3);\n      } // Finally, remove pending operation identifier\n\n    } catch (err) {\n      _iterator5.e(err);\n    } finally {\n      _iterator5.f();\n    }\n\n    this._pendingOperationsToOwnersIdentifier[\"delete\"](pendingOperationIdentifier);\n  };\n\n  _proto._resolveOwnerResolvers = function _resolveOwnerResolvers(ownerIdentifier) {\n    var promiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);\n\n    if (promiseEntry != null) {\n      promiseEntry.resolve();\n    }\n\n    this._ownersIdentifierToPromise[\"delete\"](ownerIdentifier);\n  };\n\n  _proto.getPromiseForPendingOperationsAffectingOwner = function getPromiseForPendingOperationsAffectingOwner(owner) {\n    var ownerIdentifier = owner.identifier;\n\n    if (!this._ownersToPendingOperationsIdentifier.has(ownerIdentifier)) {\n      return null;\n    }\n\n    var cachedPromiseEntry = this._ownersIdentifierToPromise.get(ownerIdentifier);\n\n    if (cachedPromiseEntry != null) {\n      return cachedPromiseEntry.promise;\n    }\n\n    var resolve;\n    var promise = new Promise(function (r) {\n      resolve = r;\n    });\n    !(resolve != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayOperationTracker: Expected resolver to be defined. If you' + 'are seeing this, it is likely a bug in Relay.') : invariant(false) : void 0;\n\n    this._ownersIdentifierToPromise.set(ownerIdentifier, {\n      promise: promise,\n      resolve: resolve\n    });\n\n    return promise;\n  };\n\n  return RelayOperationTracker;\n}();\n\nmodule.exports = RelayOperationTracker;","/**\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 RelayConcreteNode = require('../util/RelayConcreteNode');\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\n/**\n * Runtime function to correspond to the `graphql` tagged template function.\n * All calls to this function should be transformed by the plugin.\n */\nfunction graphql(strings) {\n  !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'graphql: Unexpected invocation at runtime. Either the Babel transform ' + 'was not set up, or it failed to identify this call site. Make sure it ' + 'is being used verbatim as `graphql`. Note also that there cannot be ' + 'a space between graphql and the backtick that follows.') : invariant(false) : void 0;\n}\n\nfunction getNode(taggedNode) {\n  var node = taggedNode;\n\n  if (typeof node === 'function') {\n    node = node();\n    process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayGraphQLTag: node `%s` unexpectedly wrapped in a function.', node.kind === 'Fragment' ? node.name : node.operation.name) : void 0;\n  } else if (node[\"default\"]) {\n    // Support for languages that work (best) with ES6 modules, such as TypeScript.\n    node = node[\"default\"];\n  }\n\n  return node;\n}\n\nfunction isFragment(node) {\n  var fragment = getNode(node);\n  return typeof fragment === 'object' && fragment !== null && fragment.kind === RelayConcreteNode.FRAGMENT;\n}\n\nfunction isRequest(node) {\n  var request = getNode(node);\n  return typeof request === 'object' && request !== null && request.kind === RelayConcreteNode.REQUEST;\n}\n\nfunction isInlineDataFragment(node) {\n  var fragment = getNode(node);\n  return typeof fragment === 'object' && fragment !== null && fragment.kind === RelayConcreteNode.INLINE_DATA_FRAGMENT;\n}\n\nfunction getFragment(taggedNode) {\n  var fragment = getNode(taggedNode);\n  !isFragment(fragment) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'GraphQLTag: Expected a fragment, got `%s`.', JSON.stringify(fragment)) : invariant(false) : void 0;\n  return fragment;\n}\n\nfunction getPaginationFragment(taggedNode) {\n  var _fragment$metadata;\n\n  var fragment = getFragment(taggedNode);\n  var refetch = (_fragment$metadata = fragment.metadata) === null || _fragment$metadata === void 0 ? void 0 : _fragment$metadata.refetch;\n  var connection = refetch === null || refetch === void 0 ? void 0 : refetch.connection;\n\n  if (refetch === null || typeof refetch !== 'object' || connection === null || typeof connection !== 'object') {\n    return null;\n  }\n\n  return fragment;\n}\n\nfunction getRefetchableFragment(taggedNode) {\n  var _fragment$metadata2;\n\n  var fragment = getFragment(taggedNode);\n  var refetch = (_fragment$metadata2 = fragment.metadata) === null || _fragment$metadata2 === void 0 ? void 0 : _fragment$metadata2.refetch;\n\n  if (refetch === null || typeof refetch !== 'object') {\n    return null;\n  }\n\n  return fragment;\n}\n\nfunction getRequest(taggedNode) {\n  var request = getNode(taggedNode);\n  !isRequest(request) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'GraphQLTag: Expected a request, got `%s`.', JSON.stringify(request)) : invariant(false) : void 0;\n  return request;\n}\n\nfunction getInlineDataFragment(taggedNode) {\n  var fragment = getNode(taggedNode);\n  !isInlineDataFragment(fragment) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'GraphQLTag: Expected an inline data fragment, got `%s`.', JSON.stringify(fragment)) : invariant(false) : void 0;\n  return fragment;\n}\n\nmodule.exports = {\n  getFragment: getFragment,\n  getNode: getNode,\n  getPaginationFragment: getPaginationFragment,\n  getRefetchableFragment: getRefetchableFragment,\n  getRequest: getRequest,\n  getInlineDataFragment: getInlineDataFragment,\n  graphql: graphql,\n  isFragment: isFragment,\n  isRequest: isRequest,\n  isInlineDataFragment: isInlineDataFragment\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 _global$ErrorUtils$ap, _global$ErrorUtils;\n\nvar RelayReader = require('./RelayReader');\n\nvar RelayRecordSource = require('./RelayRecordSource');\n\nvar RelayRecordSourceMutator = require('../mutations/RelayRecordSourceMutator');\n\nvar RelayRecordSourceProxy = require('../mutations/RelayRecordSourceProxy');\n\nvar RelayRecordSourceSelectorProxy = require('../mutations/RelayRecordSourceSelectorProxy');\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar applyWithGuard = (_global$ErrorUtils$ap = (_global$ErrorUtils = global.ErrorUtils) === null || _global$ErrorUtils === void 0 ? void 0 : _global$ErrorUtils.applyWithGuard) !== null && _global$ErrorUtils$ap !== void 0 ? _global$ErrorUtils$ap : function (callback, context, args, onError, name) {\n  return callback.apply(context, args);\n};\n/**\n * Coordinates the concurrent modification of a `Store` due to optimistic and\n * non-revertable client updates and server payloads:\n * - Applies optimistic updates.\n * - Reverts optimistic updates, rebasing any subsequent updates.\n * - Commits client updates (typically for client schema extensions).\n * - Commits server updates:\n *   - Normalizes query/mutation/subscription responses.\n *   - Executes handlers for \"handle\" fields.\n *   - Reverts and reapplies pending optimistic updates.\n */\n\nvar RelayPublishQueue = /*#__PURE__*/function () {\n  // True if the next `run()` should apply the backup and rerun all optimistic\n  // updates performing a rebase.\n  // Payloads to apply or Sources to publish to the store with the next `run()`.\n  // Optimistic updaters to add with the next `run()`.\n  // Optimistic updaters that are already added and might be rerun in order to\n  // rebase them.\n  // Garbage collection hold, should rerun gc on dispose\n  function RelayPublishQueue(store, handlerProvider, getDataID) {\n    this._hasStoreSnapshot = false;\n    this._handlerProvider = handlerProvider || null;\n    this._pendingBackupRebase = false;\n    this._pendingData = new Set();\n    this._pendingOptimisticUpdates = new Set();\n    this._store = store;\n    this._appliedOptimisticUpdates = new Set();\n    this._gcHold = null;\n    this._getDataID = getDataID;\n  }\n  /**\n   * Schedule applying an optimistic updates on the next `run()`.\n   */\n\n\n  var _proto = RelayPublishQueue.prototype;\n\n  _proto.applyUpdate = function applyUpdate(updater) {\n    !(!this._appliedOptimisticUpdates.has(updater) && !this._pendingOptimisticUpdates.has(updater)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayPublishQueue: Cannot apply the same update function more than ' + 'once concurrently.') : invariant(false) : void 0;\n\n    this._pendingOptimisticUpdates.add(updater);\n  }\n  /**\n   * Schedule reverting an optimistic updates on the next `run()`.\n   */\n  ;\n\n  _proto.revertUpdate = function revertUpdate(updater) {\n    if (this._pendingOptimisticUpdates.has(updater)) {\n      // Reverted before it was applied\n      this._pendingOptimisticUpdates[\"delete\"](updater);\n    } else if (this._appliedOptimisticUpdates.has(updater)) {\n      this._pendingBackupRebase = true;\n\n      this._appliedOptimisticUpdates[\"delete\"](updater);\n    }\n  }\n  /**\n   * Schedule a revert of all optimistic updates on the next `run()`.\n   */\n  ;\n\n  _proto.revertAll = function revertAll() {\n    this._pendingBackupRebase = true;\n\n    this._pendingOptimisticUpdates.clear();\n\n    this._appliedOptimisticUpdates.clear();\n  }\n  /**\n   * Schedule applying a payload to the store on the next `run()`.\n   */\n  ;\n\n  _proto.commitPayload = function commitPayload(operation, payload, updater) {\n    this._pendingBackupRebase = true;\n\n    this._pendingData.add({\n      kind: 'payload',\n      operation: operation,\n      payload: payload,\n      updater: updater\n    });\n  }\n  /**\n   * Schedule an updater to mutate the store on the next `run()` typically to\n   * update client schema fields.\n   */\n  ;\n\n  _proto.commitUpdate = function commitUpdate(updater) {\n    this._pendingBackupRebase = true;\n\n    this._pendingData.add({\n      kind: 'updater',\n      updater: updater\n    });\n  }\n  /**\n   * Schedule a publish to the store from the provided source on the next\n   * `run()`. As an example, to update the store with substituted fields that\n   * are missing in the store.\n   */\n  ;\n\n  _proto.commitSource = function commitSource(source) {\n    this._pendingBackupRebase = true;\n\n    this._pendingData.add({\n      kind: 'source',\n      source: source\n    });\n  }\n  /**\n   * Execute all queued up operations from the other public methods.\n   */\n  ;\n\n  _proto.run = function run(sourceOperation) {\n    if (process.env.NODE_ENV !== \"production\") {\n      process.env.NODE_ENV !== \"production\" ? warning(this._isRunning !== true, 'A store update was detected within another store update. Please ' + \"make sure new store updates aren't being executed within an \" + 'updater function for a different update.') : void 0;\n      this._isRunning = true;\n    }\n\n    if (this._pendingBackupRebase) {\n      if (this._hasStoreSnapshot) {\n        this._store.restore();\n\n        this._hasStoreSnapshot = false;\n      }\n    }\n\n    var invalidatedStore = this._commitData();\n\n    if (this._pendingOptimisticUpdates.size || this._pendingBackupRebase && this._appliedOptimisticUpdates.size) {\n      if (!this._hasStoreSnapshot) {\n        this._store.snapshot();\n\n        this._hasStoreSnapshot = true;\n      }\n\n      this._applyUpdates();\n    }\n\n    this._pendingBackupRebase = false;\n\n    if (this._appliedOptimisticUpdates.size > 0) {\n      if (!this._gcHold) {\n        this._gcHold = this._store.holdGC();\n      }\n    } else {\n      if (this._gcHold) {\n        this._gcHold.dispose();\n\n        this._gcHold = null;\n      }\n    }\n\n    if (process.env.NODE_ENV !== \"production\") {\n      this._isRunning = false;\n    }\n\n    return this._store.notify(sourceOperation, invalidatedStore);\n  }\n  /**\n   * _publishSourceFromPayload will return a boolean indicating if the\n   * publish caused the store to be globally invalidated.\n   */\n  ;\n\n  _proto._publishSourceFromPayload = function _publishSourceFromPayload(pendingPayload) {\n    var _this = this;\n\n    var payload = pendingPayload.payload,\n        operation = pendingPayload.operation,\n        updater = pendingPayload.updater;\n    var source = payload.source,\n        fieldPayloads = payload.fieldPayloads;\n    var mutator = new RelayRecordSourceMutator(this._store.getSource(), source);\n    var recordSourceProxy = new RelayRecordSourceProxy(mutator, this._getDataID);\n\n    if (fieldPayloads && fieldPayloads.length) {\n      fieldPayloads.forEach(function (fieldPayload) {\n        var handler = _this._handlerProvider && _this._handlerProvider(fieldPayload.handle);\n\n        !handler ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected a handler to be provided for ' + 'handle `%s`.', fieldPayload.handle) : invariant(false) : void 0;\n        handler.update(recordSourceProxy, fieldPayload);\n      });\n    }\n\n    if (updater) {\n      var selector = operation.fragment;\n      !(selector != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected a selector to be provided with updater function.') : invariant(false) : void 0;\n      var recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(mutator, recordSourceProxy, selector);\n      var selectorData = lookupSelector(source, selector);\n      updater(recordSourceSelectorProxy, selectorData);\n    }\n\n    var idsMarkedForInvalidation = recordSourceProxy.getIDsMarkedForInvalidation();\n\n    this._store.publish(source, idsMarkedForInvalidation);\n\n    return recordSourceProxy.isStoreMarkedForInvalidation();\n  }\n  /**\n   * _commitData will return a boolean indicating if any of\n   * the pending commits caused the store to be globally invalidated.\n   */\n  ;\n\n  _proto._commitData = function _commitData() {\n    var _this2 = this;\n\n    if (!this._pendingData.size) {\n      return false;\n    }\n\n    var invalidatedStore = false;\n\n    this._pendingData.forEach(function (data) {\n      if (data.kind === 'payload') {\n        var payloadInvalidatedStore = _this2._publishSourceFromPayload(data);\n\n        invalidatedStore = invalidatedStore || payloadInvalidatedStore;\n      } else if (data.kind === 'source') {\n        var source = data.source;\n\n        _this2._store.publish(source);\n      } else {\n        var updater = data.updater;\n        var sink = RelayRecordSource.create();\n        var mutator = new RelayRecordSourceMutator(_this2._store.getSource(), sink);\n        var recordSourceProxy = new RelayRecordSourceProxy(mutator, _this2._getDataID);\n        applyWithGuard(updater, null, [recordSourceProxy], null, 'RelayPublishQueue:commitData');\n        invalidatedStore = invalidatedStore || recordSourceProxy.isStoreMarkedForInvalidation();\n        var idsMarkedForInvalidation = recordSourceProxy.getIDsMarkedForInvalidation();\n\n        _this2._store.publish(sink, idsMarkedForInvalidation);\n      }\n    });\n\n    this._pendingData.clear();\n\n    return invalidatedStore;\n  }\n  /**\n   * Note that unlike _commitData, _applyUpdates will NOT return a boolean\n   * indicating if the store was globally invalidated, since invalidating the\n   * store during an optimistic update is a no-op.\n   */\n  ;\n\n  _proto._applyUpdates = function _applyUpdates() {\n    var _this3 = this;\n\n    var sink = RelayRecordSource.create();\n    var mutator = new RelayRecordSourceMutator(this._store.getSource(), sink);\n    var recordSourceProxy = new RelayRecordSourceProxy(mutator, this._getDataID, this._handlerProvider);\n\n    var processUpdate = function processUpdate(optimisticUpdate) {\n      if (optimisticUpdate.storeUpdater) {\n        var storeUpdater = optimisticUpdate.storeUpdater;\n        applyWithGuard(storeUpdater, null, [recordSourceProxy], null, 'RelayPublishQueue:applyUpdates');\n      } else {\n        var operation = optimisticUpdate.operation,\n            payload = optimisticUpdate.payload,\n            updater = optimisticUpdate.updater;\n        var source = payload.source,\n            fieldPayloads = payload.fieldPayloads;\n        var recordSourceSelectorProxy = new RelayRecordSourceSelectorProxy(mutator, recordSourceProxy, operation.fragment);\n        var selectorData;\n\n        if (source) {\n          recordSourceProxy.publishSource(source, fieldPayloads);\n          selectorData = lookupSelector(source, operation.fragment);\n        }\n\n        if (updater) {\n          applyWithGuard(updater, null, [recordSourceSelectorProxy, selectorData], null, 'RelayPublishQueue:applyUpdates');\n        }\n      }\n    }; // rerun all updaters in case we are running a rebase\n\n\n    if (this._pendingBackupRebase && this._appliedOptimisticUpdates.size) {\n      this._appliedOptimisticUpdates.forEach(processUpdate);\n    } // apply any new updaters\n\n\n    if (this._pendingOptimisticUpdates.size) {\n      this._pendingOptimisticUpdates.forEach(function (optimisticUpdate) {\n        processUpdate(optimisticUpdate);\n\n        _this3._appliedOptimisticUpdates.add(optimisticUpdate);\n      });\n\n      this._pendingOptimisticUpdates.clear();\n    }\n\n    this._store.publish(sink);\n  };\n\n  return RelayPublishQueue;\n}();\n\nfunction lookupSelector(source, selector) {\n  var selectorData = RelayReader.read(source, selector).data;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    var deepFreeze = require('../util/deepFreeze');\n\n    if (selectorData) {\n      deepFreeze(selectorData);\n    }\n  }\n\n  return selectorData;\n}\n\nmodule.exports = RelayPublishQueue;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\nmodule.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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 `RelayStoreTypes`.\n *\n * Use a sigil for detection to avoid a realm-specific instanceof check, and to\n * aid in module tree-shaking to avoid requiring all of RelayRuntime just to\n * detect its environment.\n */\n\nfunction isRelayModernEnvironment(environment) {\n  return Boolean(environment && environment['@@RelayModernEnvironment']);\n}\n\nmodule.exports = isRelayModernEnvironment;","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(o);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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 PREFIX = 'client:__type:';\nvar TYPE_SCHEMA_TYPE = '__TypeSchema';\n\nfunction generateTypeID(typeName) {\n  return PREFIX + typeName;\n}\n\nfunction isTypeID(id) {\n  return id.indexOf(PREFIX) === 0;\n}\n\nmodule.exports = {\n  generateTypeID: generateTypeID,\n  isTypeID: isTypeID,\n  TYPE_SCHEMA_TYPE: TYPE_SCHEMA_TYPE\n};","/**\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 invariant = require('invariant');\n\nvar stableCopy = require('./stableCopy');\n\n/**\n * Returns a stable identifier for the given pair of `RequestParameters` +\n * variables.\n */\nfunction getRequestIdentifier(parameters, variables) {\n  var requestID = parameters.cacheID != null ? parameters.cacheID : parameters.id;\n  !(requestID != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'getRequestIdentifier: Expected request `%s` to have either a ' + 'valid `id` or `cacheID` property', parameters.name) : invariant(false) : void 0;\n  return requestID + JSON.stringify(stableCopy(variables));\n}\n\nmodule.exports = getRequestIdentifier;","/**\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 * @private\n */\n\nfunction createError(type, name, messageFormat) {\n  for (var _len = arguments.length, messageParams = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {\n    messageParams[_key - 3] = arguments[_key];\n  }\n\n  var index = 0;\n  var message = messageFormat.replace(/%s/g, function () {\n    return String(messageParams[index++]);\n  });\n  var err = new Error(message);\n  var error = Object.assign(err, {\n    name: name,\n    messageFormat: messageFormat,\n    messageParams: messageParams,\n    type: type,\n    taalOpcodes: [2, 2] // skip frame (code=2) twice\n\n  }); // In V8, Error objects keep the closure scope chain alive until the\n  // err.stack property is accessed.\n\n  if (error.stack === undefined) {\n    // IE sets the stack only if error is thrown\n    try {\n      throw error;\n    } catch (_unused) {}\n  }\n\n  return error;\n}\n\nmodule.exports = {\n  create: function create(name, messageFormat) {\n    for (var _len2 = arguments.length, messageParams = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n      messageParams[_key2 - 2] = arguments[_key2];\n    }\n\n    return createError.apply(void 0, ['error', name, messageFormat].concat(messageParams));\n  },\n  createWarning: function createWarning(name, messageFormat) {\n    for (var _len3 = arguments.length, messageParams = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {\n      messageParams[_key3 - 2] = arguments[_key3];\n    }\n\n    return createError.apply(void 0, ['warn', name, messageFormat].concat(messageParams));\n  }\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 CONNECTION_CALLS = {\n  after: true,\n  before: true,\n  find: true,\n  first: true,\n  last: true,\n  surrounds: true\n};\nvar config = {\n  CLIENT_MUTATION_ID: 'clientMutationId',\n  CURSOR: 'cursor',\n  EDGES: 'edges',\n  END_CURSOR: 'endCursor',\n  HAS_NEXT_PAGE: 'hasNextPage',\n  HAS_PREV_PAGE: 'hasPreviousPage',\n  NODE: 'node',\n  PAGE_INFO_TYPE: 'PageInfo',\n  PAGE_INFO: 'pageInfo',\n  START_CURSOR: 'startCursor'\n};\n/**\n * @internal\n *\n * Defines logic relevant to the informal \"Connection\" GraphQL interface.\n */\n\nvar ConnectionInterface = {\n  inject: function inject(newConfig) {\n    config = newConfig;\n  },\n  get: function get() {\n    return config;\n  },\n\n  /**\n   * Checks whether a call exists strictly to encode which parts of a connection\n   * to fetch. Fields that only differ by connection call values should have the\n   * same identity.\n   */\n  isConnectionCall: function isConnectionCall(call) {\n    return CONNECTION_CALLS.hasOwnProperty(call.name);\n  }\n};\nmodule.exports = ConnectionInterface;","/**\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 RelayRecordSource = require('./RelayRecordSource');\n\nvar UNPUBLISH_RECORD_SENTINEL = Object.freeze({\n  __UNPUBLISH_RECORD_SENTINEL: true\n});\n/**\n * An implementation of MutableRecordSource that represents a base RecordSource\n * with optimistic updates stacked on top: records with optimistic updates\n * shadow the base version of the record rather than updating/replacing them.\n */\n\nvar RelayOptimisticRecordSource = /*#__PURE__*/function () {\n  function RelayOptimisticRecordSource(base) {\n    this._base = base;\n    this._sink = RelayRecordSource.create();\n  }\n\n  var _proto = RelayOptimisticRecordSource.prototype;\n\n  _proto.has = function has(dataID) {\n    if (this._sink.has(dataID)) {\n      var sinkRecord = this._sink.get(dataID);\n\n      return sinkRecord !== UNPUBLISH_RECORD_SENTINEL;\n    } else {\n      return this._base.has(dataID);\n    }\n  };\n\n  _proto.get = function get(dataID) {\n    if (this._sink.has(dataID)) {\n      var sinkRecord = this._sink.get(dataID);\n\n      if (sinkRecord === UNPUBLISH_RECORD_SENTINEL) {\n        return undefined;\n      } else {\n        return sinkRecord;\n      }\n    } else {\n      return this._base.get(dataID);\n    }\n  };\n\n  _proto.getStatus = function getStatus(dataID) {\n    var record = this.get(dataID);\n\n    if (record === undefined) {\n      return 'UNKNOWN';\n    } else if (record === null) {\n      return 'NONEXISTENT';\n    } else {\n      return 'EXISTENT';\n    }\n  };\n\n  _proto.clear = function clear() {\n    this._base = RelayRecordSource.create();\n\n    this._sink.clear();\n  };\n\n  _proto[\"delete\"] = function _delete(dataID) {\n    this._sink[\"delete\"](dataID);\n  };\n\n  _proto.remove = function remove(dataID) {\n    this._sink.set(dataID, UNPUBLISH_RECORD_SENTINEL);\n  };\n\n  _proto.set = function set(dataID, record) {\n    this._sink.set(dataID, record);\n  };\n\n  _proto.getRecordIDs = function getRecordIDs() {\n    return Object.keys(this.toJSON());\n  };\n\n  _proto.size = function size() {\n    return Object.keys(this.toJSON()).length;\n  };\n\n  _proto.toJSON = function toJSON() {\n    var _this = this;\n\n    var merged = (0, _objectSpread2[\"default\"])({}, this._base.toJSON());\n\n    this._sink.getRecordIDs().forEach(function (dataID) {\n      var record = _this.get(dataID);\n\n      if (record === undefined) {\n        delete merged[dataID];\n      } else {\n        merged[dataID] = record;\n      }\n    });\n\n    return merged;\n  };\n\n  return RelayOptimisticRecordSource;\n}();\n\nfunction create(base) {\n  return new RelayOptimisticRecordSource(base);\n}\n\nmodule.exports = {\n  create: create\n};","import { RequestParameters } from 'relay-runtime/lib/util/RelayConcreteNode'\nimport { Variables } from 'relay-runtime/lib/util/RelayRuntimeTypes'\nimport { getUrl } from '@/constant'\n\nexport const fetchGraphQL = async (\n  request: RequestParameters,\n  variables: Variables\n): Promise<any> => {\n  const response = await fetch(getUrl(), {\n    method: 'POST',\n    credentials: 'include', // Necessary to send auth cookies\n    headers: {\n      Accept: 'application/json',\n      'Content-type': 'application/json',\n    },\n    body: JSON.stringify({\n      query: request.text,\n      variables,\n    }),\n  })\n\n  const data = await response.json()\n\n  return data\n}\n","import createEnvironment from './client'\n\nexport default createEnvironment\n","import { Environment, Network, RecordSource, Store, IEnvironment } from 'relay-runtime'\nimport { RequestParameters } from 'relay-runtime/lib/util/RelayConcreteNode'\nimport { Variables } from 'relay-runtime/lib/util/RelayRuntimeTypes'\nimport { fetchGraphQL } from './fetchGraphQL'\n\nconst createEnvironment = (): IEnvironment => {\n  const handler = (request: RequestParameters, variables: Variables) =>\n    fetchGraphQL(request, variables)\n  const network = Network.create(handler)\n\n  const env = new Environment({\n    network,\n    store: new Store(new RecordSource()),\n  })\n  return env\n}\n\nexport default createEnvironment\n","import { extendTheme } from '@chakra-ui/react'\n// Global style overrides\nimport styles from './styles'\nimport colors from './colors'\nimport fonts from './fonts'\n// Foundational style overrides\n// import borders from \"./foundations/borders\";\n// Component style overrides\n\nimport Button from './components/button'\nimport Text from './components/text'\nimport Checkbox from './components/checkbox'\n\nconst overrides = {\n  styles,\n  colors,\n  fonts,\n  //   borders,\n  // Other foundational style overrides go here\n  components: {\n    Button,\n    Text,\n    Checkbox,\n    // Other components go here\n  },\n}\nexport default extendTheme(overrides)\n","export default {\n  global: {\n    // styles for the `body`\n    body: {\n      bg: 'gray.100',\n      color: 'grey.900',\n      minWidth: 'fit-content',\n    },\n    // styles for the `a`\n    a: {\n      color: 'grey.900',\n      _hover: {\n        textDecoration: 'underline',\n      },\n    },\n  },\n}\n","export default {\n  transparent: 'transparent',\n  black: '#000',\n  white: '#fff',\n  grey: {\n    50: '#f9f9f9',\n    100: '#D7D7D7',\n    300: '#757575',\n    400: '#4d4d4d',\n    900: '#212121',\n  },\n  red: {\n    50: '#FFF4F6',\n    400: '#DF3550',\n  },\n  blue: {\n    100: '#EFF6FE',\n    200: '#D9E3ED',\n    400: '#C9E2FA',\n    500: '#0B8CDB',\n    800: '#005587',\n    900: '#004b78',\n  },\n  orange: {\n    900: '#DE9629',\n  },\n  yellow: {\n    400: '#FFEA30',\n  },\n  green: {\n    50: '#ECF4ED',\n    400: '#48AD51',\n  },\n  teal: {\n    400: '#00877F',\n  },\n}\n","export default {\n  body: \"'GothamRounded-Medium', Helvetica, Arial, sans-serif\",\n  heading: \"'GothamRounded-Bold', Helvetica,Arial, sans-serif\",\n  mono: \"'GothamRounded-Book', monospace\",\n  digit: \"'GothamRounded-Light', Helvetica, Arial, sans-serif\",\n}\n","export default {\n  // 1. We can update the base styles\n  baseStyle: {\n    fontWeight: 'bold', // Normally, it is \"semibold\"\n  },\n  // 2. We can add a new button size or extend existing\n  sizes: {\n    md: {\n      fontSize: 'sm',\n    },\n  },\n  // 3. We can add a new visual variant\n  variants: {\n    // \"with-shadow\": {\n    //   bg: \"red.400\",\n    //   boxShadow: \"0 0 2px 2px #efdfde\",\n    // },\n    // // 4. We can override existing variants\n    // solid: (props) => ({\n    //   bg: props.colorMode === \"dark\" ? \"red.300\" : \"red.500\",\n    // }),\n  },\n  defaultProps: {\n    size: 'md',\n    colorScheme: 'blue',\n  },\n}\n","export default {\n  defaultProps: {\n    colorScheme: 'black',\n  },\n}\n","export default {\n  baseStyle: {\n    control: {\n      padding: 1,\n      _checked: {\n        bg: 'blue.800',\n      },\n    },\n  },\n}\n","import NextPageTracking from '@/NextPageTracking'\nimport { init } from '@/sentry'\nimport { Global } from '@emotion/react'\nimport { ChakraProvider, Container } from '@packages/ui-components'\nimport { AppProps } from 'next/app'\nimport 'react-datepicker/dist/react-datepicker.css'\nimport { RelayEnvironmentProvider } from 'react-relay'\nimport '../components/Forms/date-picker.css'\nimport createEnvironment from '../relay/createEnvironment'\nimport fonts from '../styles/font-face'\nimport '../styles/ios-fix.css'\nimport theme from '../theme'\n\ninit()\n\nconst App = ({ children }: { children: React.ReactNode }) => {\n  const Environment = createEnvironment()\n  /* @ts-expect-error - environment type off */\n  return <RelayEnvironmentProvider environment={Environment}>{children}</RelayEnvironmentProvider>\n}\n\nfunction MyLifetimeContainer({ Component, pageProps }: AppProps) {\n  return (\n    <ChakraProvider theme={theme}>\n      <Global styles={fonts} />\n      <Container flex={1} display=\"flex\" flexDirection=\"column\" maxW=\"2xl\" p={0} bgColor=\"grey.50\">\n        <App>\n          <NextPageTracking />\n          <Component {...pageProps}></Component>\n        </App>\n      </Container>\n    </ChakraProvider>\n  )\n}\n\nexport default MyLifetimeContainer\n","export default `\n    @font-face {\n      font-family: 'GothamRounded-Light';\n      font-style: normal;\n      font-weight: normal;\n      font-display: swap;\n      src: url(/fonts/Gotham-Rounded-Light.woff) format('woff');\n      unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n    }\n    @font-face {\n      font-family: 'GothamRounded-Book';\n      font-style: normal;\n      font-weight: normal;\n      font-display: swap;\n      src: url(/fonts/Gotham-Rounded-Book.woff) format('woff');\n      unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n    }\n    @font-face {\n      font-family: 'GothamRounded-Medium';\n      font-style: normal;\n      font-weight: normal;\n      font-display: swap;\n      src: url(/fonts/Gotham-Rounded-Medium.woff) format('woff2');\n      unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n\n    }\n    @font-face {\n      font-family: 'GothamRounded-Bold';\n      font-style: normal;\n      font-weight: bold;\n      font-display: swap;\n      src: url(/fonts/Gotham-Rounded-Bold.woff) format('woff2');\n      unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n    }\n  `\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 RelayModernFragmentSpecResolver = require('./RelayModernFragmentSpecResolver');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nfunction createFragmentSpecResolver(context, containerName, fragments, props, rootIsQueryRenderer, callback) {\n  if (process.env.NODE_ENV !== \"production\") {\n    var fragmentNames = Object.keys(fragments);\n    fragmentNames.forEach(function (fragmentName) {\n      var propValue = props[fragmentName];\n      process.env.NODE_ENV !== \"production\" ? warning(propValue !== undefined, 'createFragmentSpecResolver: Expected prop `%s` to be supplied to `%s`, but ' + 'got `undefined`. Pass an explicit `null` if this is intentional.', fragmentName, containerName) : void 0;\n    });\n  }\n\n  return new RelayModernFragmentSpecResolver(context, fragments, props, callback, rootIsQueryRenderer);\n}\n\nmodule.exports = createFragmentSpecResolver;","/**\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 RelayModernRecord = require('../store/RelayModernRecord');\n\nvar RelayRecordProxy = require('./RelayRecordProxy');\n\nvar invariant = require('invariant');\n\nvar _require = require('../store/RelayRecordState'),\n    EXISTENT = _require.EXISTENT,\n    NONEXISTENT = _require.NONEXISTENT;\n\nvar _require2 = require('../store/RelayStoreUtils'),\n    ROOT_ID = _require2.ROOT_ID,\n    ROOT_TYPE = _require2.ROOT_TYPE;\n\n/**\n * @internal\n *\n * A helper for manipulating a `RecordSource` via an imperative/OO-style API.\n */\nvar RelayRecordSourceProxy = /*#__PURE__*/function () {\n  function RelayRecordSourceProxy(mutator, getDataID, handlerProvider) {\n    this.__mutator = mutator;\n    this._handlerProvider = handlerProvider || null;\n    this._proxies = {};\n    this._getDataID = getDataID;\n    this._invalidatedStore = false;\n    this._idsMarkedForInvalidation = new Set();\n  }\n\n  var _proto = RelayRecordSourceProxy.prototype;\n\n  _proto.publishSource = function publishSource(source, fieldPayloads) {\n    var _this = this;\n\n    var dataIDs = source.getRecordIDs();\n    dataIDs.forEach(function (dataID) {\n      var status = source.getStatus(dataID);\n\n      if (status === EXISTENT) {\n        var sourceRecord = source.get(dataID);\n\n        if (sourceRecord) {\n          if (_this.__mutator.getStatus(dataID) !== EXISTENT) {\n            _this.create(dataID, RelayModernRecord.getType(sourceRecord));\n          }\n\n          _this.__mutator.copyFieldsFromRecord(sourceRecord, dataID);\n        }\n      } else if (status === NONEXISTENT) {\n        _this[\"delete\"](dataID);\n      }\n    });\n\n    if (fieldPayloads && fieldPayloads.length) {\n      fieldPayloads.forEach(function (fieldPayload) {\n        var handler = _this._handlerProvider && _this._handlerProvider(fieldPayload.handle);\n\n        !handler ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected a handler to be provided for handle `%s`.', fieldPayload.handle) : invariant(false) : void 0;\n        handler.update(_this, fieldPayload);\n      });\n    }\n  };\n\n  _proto.create = function create(dataID, typeName) {\n    this.__mutator.create(dataID, typeName);\n\n    delete this._proxies[dataID];\n    var record = this.get(dataID); // For flow\n\n    !record ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordSourceProxy#create(): Expected the created record to exist.') : invariant(false) : void 0;\n    return record;\n  };\n\n  _proto[\"delete\"] = function _delete(dataID) {\n    !(dataID !== ROOT_ID) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordSourceProxy#delete(): Cannot delete the root record.') : invariant(false) : void 0;\n    delete this._proxies[dataID];\n\n    this.__mutator[\"delete\"](dataID);\n  };\n\n  _proto.get = function get(dataID) {\n    if (!this._proxies.hasOwnProperty(dataID)) {\n      var status = this.__mutator.getStatus(dataID);\n\n      if (status === EXISTENT) {\n        this._proxies[dataID] = new RelayRecordProxy(this, this.__mutator, dataID);\n      } else {\n        this._proxies[dataID] = status === NONEXISTENT ? null : undefined;\n      }\n    }\n\n    return this._proxies[dataID];\n  };\n\n  _proto.getRoot = function getRoot() {\n    var root = this.get(ROOT_ID);\n\n    if (!root) {\n      root = this.create(ROOT_ID, ROOT_TYPE);\n    }\n\n    !(root && root.getType() === ROOT_TYPE) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordSourceProxy#getRoot(): Expected the source to contain a ' + 'root record, %s.', root == null ? 'no root record found' : \"found a root record of type `\".concat(root.getType(), \"`\")) : invariant(false) : void 0;\n    return root;\n  };\n\n  _proto.invalidateStore = function invalidateStore() {\n    this._invalidatedStore = true;\n  };\n\n  _proto.isStoreMarkedForInvalidation = function isStoreMarkedForInvalidation() {\n    return this._invalidatedStore;\n  };\n\n  _proto.markIDForInvalidation = function markIDForInvalidation(dataID) {\n    this._idsMarkedForInvalidation.add(dataID);\n  };\n\n  _proto.getIDsMarkedForInvalidation = function getIDsMarkedForInvalidation() {\n    return this._idsMarkedForInvalidation;\n  };\n\n  return RelayRecordSourceProxy;\n}();\n\nmodule.exports = RelayRecordSourceProxy;","var toPropertyKey = require(\"./toPropertyKey.js\");\nfunction _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\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// 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 _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\n\nvar RelayError = require('../util/RelayError');\n\nvar RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar RelayModernRecord = require('./RelayModernRecord');\n\nvar RelayObservable = require('../network/RelayObservable');\n\nvar RelayRecordSource = require('./RelayRecordSource');\n\nvar RelayResponseNormalizer = require('./RelayResponseNormalizer');\n\nvar getOperation = require('../util/getOperation');\n\nvar invariant = require('invariant');\n\nvar stableCopy = require('../util/stableCopy');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('./ClientID'),\n    generateClientID = _require.generateClientID,\n    generateUniqueClientID = _require.generateUniqueClientID;\n\nvar _require2 = require('./RelayModernSelector'),\n    createNormalizationSelector = _require2.createNormalizationSelector,\n    createReaderSelector = _require2.createReaderSelector;\n\nvar _require3 = require('./RelayStoreUtils'),\n    ROOT_TYPE = _require3.ROOT_TYPE,\n    TYPENAME_KEY = _require3.TYPENAME_KEY,\n    getStorageKey = _require3.getStorageKey;\n\nfunction execute(config) {\n  return new Executor(config);\n}\n/**\n * Coordinates the execution of a query, handling network callbacks\n * including optimistic payloads, standard payloads, resolution of match\n * dependencies, etc.\n */\n\n\nvar Executor = /*#__PURE__*/function () {\n  function Executor(_ref) {\n    var _this = this;\n\n    var operation = _ref.operation,\n        operationExecutions = _ref.operationExecutions,\n        operationLoader = _ref.operationLoader,\n        optimisticConfig = _ref.optimisticConfig,\n        publishQueue = _ref.publishQueue,\n        scheduler = _ref.scheduler,\n        sink = _ref.sink,\n        source = _ref.source,\n        store = _ref.store,\n        updater = _ref.updater,\n        operationTracker = _ref.operationTracker,\n        treatMissingFieldsAsNull = _ref.treatMissingFieldsAsNull,\n        getDataID = _ref.getDataID,\n        isClientPayload = _ref.isClientPayload,\n        reactFlightPayloadDeserializer = _ref.reactFlightPayloadDeserializer,\n        reactFlightServerErrorHandler = _ref.reactFlightServerErrorHandler,\n        shouldProcessClientComponents = _ref.shouldProcessClientComponents;\n    this._getDataID = getDataID;\n    this._treatMissingFieldsAsNull = treatMissingFieldsAsNull;\n    this._incrementalPayloadsPending = false;\n    this._incrementalResults = new Map();\n    this._nextSubscriptionId = 0;\n    this._operation = operation;\n    this._operationExecutions = operationExecutions;\n    this._operationLoader = operationLoader;\n    this._operationTracker = operationTracker;\n    this._operationUpdateEpochs = new Map();\n    this._optimisticUpdates = null;\n    this._pendingModulePayloadsCount = 0;\n    this._publishQueue = publishQueue;\n    this._scheduler = scheduler;\n    this._sink = sink;\n    this._source = new Map();\n    this._state = 'started';\n    this._store = store;\n    this._subscriptions = new Map();\n    this._updater = updater;\n    this._isClientPayload = isClientPayload === true;\n    this._reactFlightPayloadDeserializer = reactFlightPayloadDeserializer;\n    this._reactFlightServerErrorHandler = reactFlightServerErrorHandler;\n    this._isSubscriptionOperation = this._operation.request.node.params.operationKind === 'subscription';\n    this._shouldProcessClientComponents = shouldProcessClientComponents;\n    var id = this._nextSubscriptionId++;\n    source.subscribe({\n      complete: function complete() {\n        return _this._complete(id);\n      },\n      error: function error(_error2) {\n        return _this._error(_error2);\n      },\n      next: function next(response) {\n        try {\n          _this._next(id, response);\n        } catch (error) {\n          sink.error(error);\n        }\n      },\n      start: function start(subscription) {\n        return _this._start(id, subscription);\n      }\n    });\n\n    if (optimisticConfig != null) {\n      this._processOptimisticResponse(optimisticConfig.response != null ? {\n        data: optimisticConfig.response\n      } : null, optimisticConfig.updater, false);\n    }\n  } // Cancel any pending execution tasks and mark the executor as completed.\n\n\n  var _proto = Executor.prototype;\n\n  _proto.cancel = function cancel() {\n    var _this2 = this;\n\n    if (this._state === 'completed') {\n      return;\n    }\n\n    this._state = 'completed';\n\n    this._operationExecutions[\"delete\"](this._operation.request.identifier);\n\n    if (this._subscriptions.size !== 0) {\n      this._subscriptions.forEach(function (sub) {\n        return sub.unsubscribe();\n      });\n\n      this._subscriptions.clear();\n    }\n\n    var optimisticUpdates = this._optimisticUpdates;\n\n    if (optimisticUpdates !== null) {\n      this._optimisticUpdates = null;\n      optimisticUpdates.forEach(function (update) {\n        return _this2._publishQueue.revertUpdate(update);\n      }); // OK: run revert on cancel\n\n      this._publishQueue.run();\n    }\n\n    this._incrementalResults.clear();\n\n    this._completeOperationTracker();\n\n    if (this._retainDisposable) {\n      this._retainDisposable.dispose();\n\n      this._retainDisposable = null;\n    }\n  };\n\n  _proto._updateActiveState = function _updateActiveState() {\n    var activeState;\n\n    switch (this._state) {\n      case 'started':\n        {\n          activeState = 'active';\n          break;\n        }\n\n      case 'loading_incremental':\n        {\n          activeState = 'active';\n          break;\n        }\n\n      case 'completed':\n        {\n          activeState = 'inactive';\n          break;\n        }\n\n      case 'loading_final':\n        {\n          activeState = this._pendingModulePayloadsCount > 0 ? 'active' : 'inactive';\n          break;\n        }\n\n      default:\n        this._state;\n        !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'OperationExecutor: invalid executor state.') : invariant(false) : void 0;\n    }\n\n    this._operationExecutions.set(this._operation.request.identifier, activeState);\n  };\n\n  _proto._schedule = function _schedule(task) {\n    var _this3 = this;\n\n    var scheduler = this._scheduler;\n\n    if (scheduler != null) {\n      var _id2 = this._nextSubscriptionId++;\n\n      RelayObservable.create(function (sink) {\n        var cancellationToken = scheduler.schedule(function () {\n          try {\n            task();\n            sink.complete();\n          } catch (error) {\n            sink.error(error);\n          }\n        });\n        return function () {\n          return scheduler.cancel(cancellationToken);\n        };\n      }).subscribe({\n        complete: function complete() {\n          return _this3._complete(_id2);\n        },\n        error: function error(_error3) {\n          return _this3._error(_error3);\n        },\n        start: function start(subscription) {\n          return _this3._start(_id2, subscription);\n        }\n      });\n    } else {\n      task();\n    }\n  };\n\n  _proto._complete = function _complete(id) {\n    this._subscriptions[\"delete\"](id);\n\n    if (this._subscriptions.size === 0) {\n      this.cancel();\n\n      this._sink.complete();\n    }\n  };\n\n  _proto._error = function _error(error) {\n    this.cancel();\n\n    this._sink.error(error);\n  };\n\n  _proto._start = function _start(id, subscription) {\n    this._subscriptions.set(id, subscription);\n\n    this._updateActiveState();\n  } // Handle a raw GraphQL response.\n  ;\n\n  _proto._next = function _next(_id, response) {\n    var _this4 = this;\n\n    this._schedule(function () {\n      _this4._handleNext(response);\n\n      _this4._maybeCompleteSubscriptionOperationTracking();\n    });\n  };\n\n  _proto._handleErrorResponse = function _handleErrorResponse(responses) {\n    var _this5 = this;\n\n    var results = [];\n    responses.forEach(function (response) {\n      if (response.data === null && response.extensions != null && !response.hasOwnProperty('errors')) {\n        // Skip extensions-only payloads\n        return;\n      } else if (response.data == null) {\n        // Error if any other payload in the batch is missing data, regardless of whether\n        // it had `errors` or not.\n        var errors = response.hasOwnProperty('errors') && response.errors != null ? response.errors : null;\n        var messages = errors ? errors.map(function (_ref2) {\n          var message = _ref2.message;\n          return message;\n        }).join('\\n') : '(No errors)';\n        var error = RelayError.create('RelayNetwork', 'No data returned for operation `' + _this5._operation.request.node.params.name + '`, got error(s):\\n' + messages + '\\n\\nSee the error `source` property for more information.');\n        error.source = {\n          errors: errors,\n          operation: _this5._operation.request.node,\n          variables: _this5._operation.request.variables\n        }; // In V8, Error objects keep the closure scope chain alive until the\n        // err.stack property is accessed.\n\n        error.stack;\n        throw error;\n      } else {\n        var responseWithData = response;\n        results.push(responseWithData);\n      }\n    });\n    return results;\n  }\n  /**\n   * This method return boolean to indicate if the optimistic\n   * response has been handled\n   */\n  ;\n\n  _proto._handleOptimisticResponses = function _handleOptimisticResponses(responses) {\n    var _response$extensions;\n\n    if (responses.length > 1) {\n      if (responses.some(function (responsePart) {\n        var _responsePart$extensi;\n\n        return ((_responsePart$extensi = responsePart.extensions) === null || _responsePart$extensi === void 0 ? void 0 : _responsePart$extensi.isOptimistic) === true;\n      })) {\n        !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Optimistic responses cannot be batched.') : invariant(false) : void 0;\n      }\n\n      return false;\n    }\n\n    var response = responses[0];\n    var isOptimistic = ((_response$extensions = response.extensions) === null || _response$extensions === void 0 ? void 0 : _response$extensions.isOptimistic) === true;\n\n    if (isOptimistic && this._state !== 'started') {\n      !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'OperationExecutor: optimistic payload received after server payload.') : invariant(false) : void 0;\n    }\n\n    if (isOptimistic) {\n      this._processOptimisticResponse(response, null, this._treatMissingFieldsAsNull);\n\n      this._sink.next(response);\n\n      return true;\n    }\n\n    return false;\n  };\n\n  _proto._handleNext = function _handleNext(response) {\n    if (this._state === 'completed') {\n      return;\n    }\n\n    var responses = Array.isArray(response) ? response : [response];\n\n    var responsesWithData = this._handleErrorResponse(responses);\n\n    if (responsesWithData.length === 0) {\n      // no results with data, nothing to process\n      // this can occur with extensions-only payloads\n      var isFinal = responses.some(function (x) {\n        var _x$extensions;\n\n        return ((_x$extensions = x.extensions) === null || _x$extensions === void 0 ? void 0 : _x$extensions.is_final) === true;\n      });\n\n      if (isFinal) {\n        this._state = 'loading_final';\n\n        this._updateActiveState();\n\n        this._incrementalPayloadsPending = false;\n      }\n\n      this._sink.next(response);\n\n      return;\n    } // Next, handle optimistic responses\n\n\n    var isOptimistic = this._handleOptimisticResponses(responsesWithData);\n\n    if (isOptimistic) {\n      return;\n    }\n\n    var _partitionGraphQLResp = partitionGraphQLResponses(responsesWithData),\n        nonIncrementalResponses = _partitionGraphQLResp[0],\n        incrementalResponses = _partitionGraphQLResp[1];\n\n    var hasNonIncrementalResponses = nonIncrementalResponses.length > 0; // In theory this doesn't preserve the ordering of the batch.\n    // The idea is that a batch is always:\n    //  * at most one non-incremental payload\n    //  * followed by zero or more incremental payloads\n    // The non-incremental payload can appear if the server sends a batch\n    // with the initial payload followed by some early-to-resolve incremental\n    // payloads (although, can that even happen?)\n\n    if (hasNonIncrementalResponses) {\n      var payloadFollowups = this._processResponses(nonIncrementalResponses);\n\n      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {\n        var updatedOwners = this._publishQueue.run(this._operation);\n\n        this._updateOperationTracker(updatedOwners);\n      }\n\n      this._processPayloadFollowups(payloadFollowups);\n\n      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {\n        if (this._incrementalPayloadsPending && !this._retainDisposable) {\n          this._retainDisposable = this._store.retain(this._operation);\n        }\n      }\n    }\n\n    if (incrementalResponses.length > 0) {\n      var _payloadFollowups = this._processIncrementalResponses(incrementalResponses);\n\n      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {\n        // For the incremental case, we're only handling follow-up responses\n        // for already initiated operation (and we're not passing it to\n        // the run(...) call)\n        var _updatedOwners = this._publishQueue.run();\n\n        this._updateOperationTracker(_updatedOwners);\n      }\n\n      this._processPayloadFollowups(_payloadFollowups);\n    }\n\n    if (this._isSubscriptionOperation && RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT) {\n      // We attach the id to allow the `requestSubscription` to read from the store using\n      // the current id in its `onNext` callback\n      if (responsesWithData[0].extensions == null) {\n        // $FlowFixMe[cannot-write]\n        responsesWithData[0].extensions = {\n          __relay_subscription_root_id: this._operation.fragment.dataID\n        };\n      } else {\n        responsesWithData[0].extensions.__relay_subscription_root_id = this._operation.fragment.dataID;\n      }\n    }\n\n    if (RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {\n      // OK: run once after each new payload\n      // If we have non-incremental responses, we passing `this._operation` to\n      // the publish queue here, which will later be passed to the store (via\n      // notify) to indicate that this operation caused the store to update\n      var _updatedOwners2 = this._publishQueue.run(hasNonIncrementalResponses ? this._operation : undefined);\n\n      if (hasNonIncrementalResponses) {\n        if (this._incrementalPayloadsPending && !this._retainDisposable) {\n          this._retainDisposable = this._store.retain(this._operation);\n        }\n      }\n\n      this._updateOperationTracker(_updatedOwners2);\n    }\n\n    this._sink.next(response);\n  };\n\n  _proto._processOptimisticResponse = function _processOptimisticResponse(response, updater, treatMissingFieldsAsNull) {\n    var _this6 = this;\n\n    !(this._optimisticUpdates === null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'environment.execute: only support one optimistic response per ' + 'execute.') : invariant(false) : void 0;\n\n    if (response == null && updater == null) {\n      return;\n    }\n\n    var optimisticUpdates = [];\n\n    if (response) {\n      var payload = normalizeResponse(response, this._operation.root, ROOT_TYPE, {\n        getDataID: this._getDataID,\n        path: [],\n        reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,\n        reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,\n        shouldProcessClientComponents: this._shouldProcessClientComponents,\n        treatMissingFieldsAsNull: treatMissingFieldsAsNull\n      });\n      validateOptimisticResponsePayload(payload);\n      optimisticUpdates.push({\n        operation: this._operation,\n        payload: payload,\n        updater: updater\n      });\n\n      this._processOptimisticFollowups(payload, optimisticUpdates);\n    } else if (updater) {\n      optimisticUpdates.push({\n        operation: this._operation,\n        payload: {\n          errors: null,\n          fieldPayloads: null,\n          incrementalPlaceholders: null,\n          moduleImportPayloads: null,\n          source: RelayRecordSource.create(),\n          isFinal: false\n        },\n        updater: updater\n      });\n    }\n\n    this._optimisticUpdates = optimisticUpdates;\n    optimisticUpdates.forEach(function (update) {\n      return _this6._publishQueue.applyUpdate(update);\n    }); // OK: only called on construction and when receiving an optimistic payload from network,\n    // which doesn't fall-through to the regular next() handling\n\n    this._publishQueue.run();\n  };\n\n  _proto._processOptimisticFollowups = function _processOptimisticFollowups(payload, optimisticUpdates) {\n    if (payload.moduleImportPayloads && payload.moduleImportPayloads.length) {\n      var moduleImportPayloads = payload.moduleImportPayloads;\n      var operationLoader = this._operationLoader;\n      !operationLoader ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected an operationLoader to be ' + 'configured when using `@match`.') : invariant(false) : void 0;\n\n      var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(moduleImportPayloads),\n          _step;\n\n      try {\n        for (_iterator.s(); !(_step = _iterator.n()).done;) {\n          var moduleImportPayload = _step.value;\n          var operation = operationLoader.get(moduleImportPayload.operationReference);\n\n          if (operation == null) {\n            this._processAsyncOptimisticModuleImport(operationLoader, moduleImportPayload);\n          } else {\n            var moduleImportOptimisticUpdates = this._processOptimisticModuleImport(operation, moduleImportPayload);\n\n            optimisticUpdates.push.apply(optimisticUpdates, (0, _toConsumableArray2[\"default\"])(moduleImportOptimisticUpdates));\n          }\n        }\n      } catch (err) {\n        _iterator.e(err);\n      } finally {\n        _iterator.f();\n      }\n    }\n  };\n\n  _proto._normalizeModuleImport = function _normalizeModuleImport(moduleImportPayload, operation) {\n    var selector = createNormalizationSelector(operation, moduleImportPayload.dataID, moduleImportPayload.variables);\n    return normalizeResponse({\n      data: moduleImportPayload.data\n    }, selector, moduleImportPayload.typeName, {\n      getDataID: this._getDataID,\n      path: moduleImportPayload.path,\n      reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,\n      reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,\n      treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,\n      shouldProcessClientComponents: this._shouldProcessClientComponents\n    });\n  };\n\n  _proto._processOptimisticModuleImport = function _processOptimisticModuleImport(normalizationRootNode, moduleImportPayload) {\n    var operation = getOperation(normalizationRootNode);\n    var optimisticUpdates = [];\n\n    var modulePayload = this._normalizeModuleImport(moduleImportPayload, operation);\n\n    validateOptimisticResponsePayload(modulePayload);\n    optimisticUpdates.push({\n      operation: this._operation,\n      payload: modulePayload,\n      updater: null\n    });\n\n    this._processOptimisticFollowups(modulePayload, optimisticUpdates);\n\n    return optimisticUpdates;\n  };\n\n  _proto._processAsyncOptimisticModuleImport = function _processAsyncOptimisticModuleImport(operationLoader, moduleImportPayload) {\n    var _this7 = this;\n\n    operationLoader.load(moduleImportPayload.operationReference).then(function (operation) {\n      if (operation == null || _this7._state !== 'started') {\n        return;\n      }\n\n      var moduleImportOptimisticUpdates = _this7._processOptimisticModuleImport(operation, moduleImportPayload);\n\n      moduleImportOptimisticUpdates.forEach(function (update) {\n        return _this7._publishQueue.applyUpdate(update);\n      });\n\n      if (_this7._optimisticUpdates == null) {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'OperationExecutor: Unexpected ModuleImport optimistic ' + 'update in operation %s.' + _this7._operation.request.node.params.name) : void 0;\n      } else {\n        var _this$_optimisticUpda;\n\n        (_this$_optimisticUpda = _this7._optimisticUpdates).push.apply(_this$_optimisticUpda, (0, _toConsumableArray2[\"default\"])(moduleImportOptimisticUpdates)); // OK: always have to run() after an module import resolves async\n\n\n        _this7._publishQueue.run();\n      }\n    });\n  };\n\n  _proto._processResponses = function _processResponses(responses) {\n    var _this8 = this;\n\n    if (this._optimisticUpdates !== null) {\n      this._optimisticUpdates.forEach(function (update) {\n        return _this8._publishQueue.revertUpdate(update);\n      });\n\n      this._optimisticUpdates = null;\n    }\n\n    this._incrementalPayloadsPending = false;\n\n    this._incrementalResults.clear();\n\n    this._source.clear();\n\n    return responses.map(function (payloadPart) {\n      var relayPayload = normalizeResponse(payloadPart, _this8._operation.root, ROOT_TYPE, {\n        getDataID: _this8._getDataID,\n        path: [],\n        reactFlightPayloadDeserializer: _this8._reactFlightPayloadDeserializer,\n        reactFlightServerErrorHandler: _this8._reactFlightServerErrorHandler,\n        treatMissingFieldsAsNull: _this8._treatMissingFieldsAsNull,\n        shouldProcessClientComponents: _this8._shouldProcessClientComponents\n      });\n\n      _this8._publishQueue.commitPayload(_this8._operation, relayPayload, _this8._updater);\n\n      return relayPayload;\n    });\n  }\n  /**\n   * Handles any follow-up actions for a Relay payload for @match, @defer,\n   * and @stream directives.\n   */\n  ;\n\n  _proto._processPayloadFollowups = function _processPayloadFollowups(payloads) {\n    var _this9 = this;\n\n    if (this._state === 'completed') {\n      return;\n    }\n\n    payloads.forEach(function (payload) {\n      var incrementalPlaceholders = payload.incrementalPlaceholders,\n          moduleImportPayloads = payload.moduleImportPayloads,\n          isFinal = payload.isFinal;\n      _this9._state = isFinal ? 'loading_final' : 'loading_incremental';\n\n      _this9._updateActiveState();\n\n      if (isFinal) {\n        _this9._incrementalPayloadsPending = false;\n      }\n\n      if (moduleImportPayloads && moduleImportPayloads.length !== 0) {\n        var operationLoader = _this9._operationLoader;\n        !operationLoader ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected an operationLoader to be ' + 'configured when using `@match`.') : invariant(false) : void 0;\n        moduleImportPayloads.forEach(function (moduleImportPayload) {\n          _this9._processModuleImportPayload(moduleImportPayload, operationLoader);\n        });\n      }\n\n      if (incrementalPlaceholders && incrementalPlaceholders.length !== 0) {\n        _this9._incrementalPayloadsPending = _this9._state !== 'loading_final';\n        incrementalPlaceholders.forEach(function (incrementalPlaceholder) {\n          _this9._processIncrementalPlaceholder(payload, incrementalPlaceholder);\n        });\n\n        if (_this9._isClientPayload || _this9._state === 'loading_final') {\n          // The query has defer/stream selections that are enabled, but either\n          // the server indicated that this is a \"final\" payload: no incremental\n          // payloads will be delivered, then warn that the query was (likely)\n          // executed on the server in non-streaming mode, with incremental\n          // delivery disabled; or this is a client payload, and there will be\n          // no incremental payload.\n          process.env.NODE_ENV !== \"production\" ? warning(_this9._isClientPayload, 'RelayModernEnvironment: Operation `%s` contains @defer/@stream ' + 'directives but was executed in non-streaming mode. See ' + 'https://fburl.com/relay-incremental-delivery-non-streaming-warning.', _this9._operation.request.node.params.name) : void 0; // But eagerly process any deferred payloads\n\n          var relayPayloads = [];\n          incrementalPlaceholders.forEach(function (placeholder) {\n            if (placeholder.kind === 'defer') {\n              relayPayloads.push(_this9._processDeferResponse(placeholder.label, placeholder.path, placeholder, {\n                data: placeholder.data\n              }));\n            }\n          });\n\n          if (relayPayloads.length > 0) {\n            if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {\n              var updatedOwners = _this9._publishQueue.run();\n\n              _this9._updateOperationTracker(updatedOwners);\n            }\n\n            _this9._processPayloadFollowups(relayPayloads);\n          }\n        }\n      }\n    });\n  };\n\n  _proto._maybeCompleteSubscriptionOperationTracking = function _maybeCompleteSubscriptionOperationTracking() {\n    if (!this._isSubscriptionOperation) {\n      return;\n    }\n\n    if (this._pendingModulePayloadsCount === 0 && this._incrementalPayloadsPending === false) {\n      this._completeOperationTracker();\n    }\n\n    if (RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT) {\n      var nextID = generateUniqueClientID();\n      this._operation = {\n        request: this._operation.request,\n        fragment: createReaderSelector(this._operation.fragment.node, nextID, this._operation.fragment.variables, this._operation.fragment.owner),\n        root: createNormalizationSelector(this._operation.root.node, nextID, this._operation.root.variables)\n      };\n    }\n  }\n  /**\n   * Processes a ModuleImportPayload, asynchronously resolving the normalization\n   * AST and using it to normalize the field data into a RelayResponsePayload.\n   * The resulting payload may contain other incremental payloads (match,\n   * defer, stream, etc); these are handled by calling\n   * `_processPayloadFollowups()`.\n   */\n  ;\n\n  _proto._processModuleImportPayload = function _processModuleImportPayload(moduleImportPayload, operationLoader) {\n    var _this10 = this;\n\n    var node = operationLoader.get(moduleImportPayload.operationReference);\n\n    if (node != null) {\n      var operation = getOperation(node); // If the operation module is available synchronously, normalize the\n      // data synchronously.\n\n      this._handleModuleImportPayload(moduleImportPayload, operation);\n\n      this._maybeCompleteSubscriptionOperationTracking();\n    } else {\n      // Otherwise load the operation module and schedule a task to normalize\n      // the data when the module is available.\n      var _id3 = this._nextSubscriptionId++;\n\n      this._pendingModulePayloadsCount++;\n\n      var decrementPendingCount = function decrementPendingCount() {\n        _this10._pendingModulePayloadsCount--;\n\n        _this10._maybeCompleteSubscriptionOperationTracking();\n      }; // Observable.from(operationLoader.load()) wouldn't catch synchronous\n      // errors thrown by the load function, which is user-defined. Guard\n      // against that with Observable.from(new Promise(<work>)).\n\n\n      RelayObservable.from(new Promise(function (resolve, reject) {\n        operationLoader.load(moduleImportPayload.operationReference).then(resolve, reject);\n      })).map(function (operation) {\n        if (operation != null) {\n          _this10._schedule(function () {\n            _this10._handleModuleImportPayload(moduleImportPayload, getOperation(operation)); // OK: always have to run after an async module import resolves\n\n\n            var updatedOwners = _this10._publishQueue.run();\n\n            _this10._updateOperationTracker(updatedOwners);\n          });\n        }\n      }).subscribe({\n        complete: function complete() {\n          _this10._complete(_id3);\n\n          decrementPendingCount();\n        },\n        error: function error(_error4) {\n          _this10._error(_error4);\n\n          decrementPendingCount();\n        },\n        start: function start(subscription) {\n          return _this10._start(_id3, subscription);\n        }\n      });\n    }\n  };\n\n  _proto._handleModuleImportPayload = function _handleModuleImportPayload(moduleImportPayload, operation) {\n    var relayPayload = this._normalizeModuleImport(moduleImportPayload, operation);\n\n    this._publishQueue.commitPayload(this._operation, relayPayload);\n\n    if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {\n      var updatedOwners = this._publishQueue.run();\n\n      this._updateOperationTracker(updatedOwners);\n    }\n\n    this._processPayloadFollowups([relayPayload]);\n  }\n  /**\n   * The executor now knows that GraphQL responses are expected for a given\n   * label/path:\n   * - Store the placeholder in order to process any future responses that may\n   *   arrive.\n   * - Then process any responses that had already arrived.\n   *\n   * The placeholder contains the normalization selector, path (for nested\n   * defer/stream), and other metadata used to normalize the incremental\n   * response(s).\n   */\n  ;\n\n  _proto._processIncrementalPlaceholder = function _processIncrementalPlaceholder(relayPayload, placeholder) {\n    var _relayPayload$fieldPa;\n\n    // Update the label => path => placeholder map\n    var label = placeholder.label,\n        path = placeholder.path;\n    var pathKey = path.map(String).join('.');\n\n    var resultForLabel = this._incrementalResults.get(label);\n\n    if (resultForLabel == null) {\n      resultForLabel = new Map();\n\n      this._incrementalResults.set(label, resultForLabel);\n    }\n\n    var resultForPath = resultForLabel.get(pathKey);\n    var pendingResponses = resultForPath != null && resultForPath.kind === 'response' ? resultForPath.responses : null;\n    resultForLabel.set(pathKey, {\n      kind: 'placeholder',\n      placeholder: placeholder\n    }); // Store references to the parent node to allow detecting concurrent\n    // modifications to the parent before items arrive and to replay\n    // handle field payloads to account for new information on source records.\n\n    var parentID;\n\n    if (placeholder.kind === 'stream') {\n      parentID = placeholder.parentID;\n    } else if (placeholder.kind === 'defer') {\n      parentID = placeholder.selector.dataID;\n    } else {\n      placeholder;\n      !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Unsupported incremental placeholder kind `%s`.', placeholder.kind) : invariant(false) : void 0;\n    }\n\n    var parentRecord = relayPayload.source.get(parentID);\n    var parentPayloads = ((_relayPayload$fieldPa = relayPayload.fieldPayloads) !== null && _relayPayload$fieldPa !== void 0 ? _relayPayload$fieldPa : []).filter(function (fieldPayload) {\n      var fieldID = generateClientID(fieldPayload.dataID, fieldPayload.fieldKey);\n      return (// handlers applied to the streamed field itself\n        fieldPayload.dataID === parentID || // handlers applied to a field on an ancestor object, where\n        // ancestor.field links to the parent record (example: connections)\n        fieldID === parentID\n      );\n    }); // If an incremental payload exists for some id that record should also\n    // exist.\n\n    !(parentRecord != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected record `%s` to exist.', parentID) : invariant(false) : void 0;\n    var nextParentRecord;\n    var nextParentPayloads;\n\n    var previousParentEntry = this._source.get(parentID);\n\n    if (previousParentEntry != null) {\n      // If a previous entry exists, merge the previous/next records and\n      // payloads together.\n      nextParentRecord = RelayModernRecord.update(previousParentEntry.record, parentRecord);\n      var handlePayloads = new Map();\n\n      var dedupePayload = function dedupePayload(payload) {\n        var key = stableStringify(payload);\n        handlePayloads.set(key, payload);\n      };\n\n      previousParentEntry.fieldPayloads.forEach(dedupePayload);\n      parentPayloads.forEach(dedupePayload);\n      nextParentPayloads = Array.from(handlePayloads.values());\n    } else {\n      nextParentRecord = parentRecord;\n      nextParentPayloads = parentPayloads;\n    }\n\n    this._source.set(parentID, {\n      record: nextParentRecord,\n      fieldPayloads: nextParentPayloads\n    }); // If there were any queued responses, process them now that placeholders\n    // are in place\n\n\n    if (pendingResponses != null) {\n      var payloadFollowups = this._processIncrementalResponses(pendingResponses);\n\n      if (!RelayFeatureFlags.ENABLE_BATCHED_STORE_UPDATES) {\n        var updatedOwners = this._publishQueue.run();\n\n        this._updateOperationTracker(updatedOwners);\n      }\n\n      this._processPayloadFollowups(payloadFollowups);\n    }\n  }\n  /**\n   * Lookup the placeholder the describes how to process an incremental\n   * response, normalize/publish it, and process any nested defer/match/stream\n   * metadata.\n   */\n  ;\n\n  _proto._processIncrementalResponses = function _processIncrementalResponses(incrementalResponses) {\n    var _this11 = this;\n\n    var relayPayloads = [];\n    incrementalResponses.forEach(function (incrementalResponse) {\n      var label = incrementalResponse.label,\n          path = incrementalResponse.path,\n          response = incrementalResponse.response;\n\n      var resultForLabel = _this11._incrementalResults.get(label);\n\n      if (resultForLabel == null) {\n        resultForLabel = new Map();\n\n        _this11._incrementalResults.set(label, resultForLabel);\n      }\n\n      if (label.indexOf('$defer$') !== -1) {\n        var pathKey = path.map(String).join('.');\n        var resultForPath = resultForLabel.get(pathKey);\n\n        if (resultForPath == null) {\n          resultForPath = {\n            kind: 'response',\n            responses: [incrementalResponse]\n          };\n          resultForLabel.set(pathKey, resultForPath);\n          return;\n        } else if (resultForPath.kind === 'response') {\n          resultForPath.responses.push(incrementalResponse);\n          return;\n        }\n\n        var placeholder = resultForPath.placeholder;\n        !(placeholder.kind === 'defer') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected data for path `%s` for label `%s` ' + 'to be data for @defer, was `@%s`.', pathKey, label, placeholder.kind) : invariant(false) : void 0;\n        relayPayloads.push(_this11._processDeferResponse(label, path, placeholder, response));\n      } else {\n        // @stream payload path values end in the field name and item index,\n        // but Relay records paths relative to the parent of the stream node:\n        // therefore we strip the last two elements just to lookup the path\n        // (the item index is used later to insert the element in the list)\n        var _pathKey = path.slice(0, -2).map(String).join('.');\n\n        var _resultForPath = resultForLabel.get(_pathKey);\n\n        if (_resultForPath == null) {\n          _resultForPath = {\n            kind: 'response',\n            responses: [incrementalResponse]\n          };\n          resultForLabel.set(_pathKey, _resultForPath);\n          return;\n        } else if (_resultForPath.kind === 'response') {\n          _resultForPath.responses.push(incrementalResponse);\n\n          return;\n        }\n\n        var _placeholder = _resultForPath.placeholder;\n        !(_placeholder.kind === 'stream') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected data for path `%s` for label `%s` ' + 'to be data for @stream, was `@%s`.', _pathKey, label, _placeholder.kind) : invariant(false) : void 0;\n        relayPayloads.push(_this11._processStreamResponse(label, path, _placeholder, response));\n      }\n    });\n    return relayPayloads;\n  };\n\n  _proto._processDeferResponse = function _processDeferResponse(label, path, placeholder, response) {\n    var parentID = placeholder.selector.dataID;\n    var relayPayload = normalizeResponse(response, placeholder.selector, placeholder.typeName, {\n      getDataID: this._getDataID,\n      path: placeholder.path,\n      reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,\n      reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,\n      treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,\n      shouldProcessClientComponents: this._shouldProcessClientComponents\n    });\n\n    this._publishQueue.commitPayload(this._operation, relayPayload); // Load the version of the parent record from which this incremental data\n    // was derived\n\n\n    var parentEntry = this._source.get(parentID);\n\n    !(parentEntry != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected the parent record `%s` for @defer ' + 'data to exist.', parentID) : invariant(false) : void 0;\n    var fieldPayloads = parentEntry.fieldPayloads;\n\n    if (fieldPayloads.length !== 0) {\n      var _response$extensions2;\n\n      var handleFieldsRelayPayload = {\n        errors: null,\n        fieldPayloads: fieldPayloads,\n        incrementalPlaceholders: null,\n        moduleImportPayloads: null,\n        source: RelayRecordSource.create(),\n        isFinal: ((_response$extensions2 = response.extensions) === null || _response$extensions2 === void 0 ? void 0 : _response$extensions2.is_final) === true\n      };\n\n      this._publishQueue.commitPayload(this._operation, handleFieldsRelayPayload);\n    }\n\n    return relayPayload;\n  }\n  /**\n   * Process the data for one item in a @stream field.\n   */\n  ;\n\n  _proto._processStreamResponse = function _processStreamResponse(label, path, placeholder, response) {\n    var parentID = placeholder.parentID,\n        node = placeholder.node,\n        variables = placeholder.variables; // Find the LinkedField where @stream was applied\n\n    var field = node.selections[0];\n    !(field != null && field.kind === 'LinkedField' && field.plural === true) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected @stream to be used on a plural field.') : invariant(false) : void 0;\n\n    var _this$_normalizeStrea = this._normalizeStreamItem(response, parentID, field, variables, path, placeholder.path),\n        fieldPayloads = _this$_normalizeStrea.fieldPayloads,\n        itemID = _this$_normalizeStrea.itemID,\n        itemIndex = _this$_normalizeStrea.itemIndex,\n        prevIDs = _this$_normalizeStrea.prevIDs,\n        relayPayload = _this$_normalizeStrea.relayPayload,\n        storageKey = _this$_normalizeStrea.storageKey; // Publish the new item and update the parent record to set\n    // field[index] = item *if* the parent record hasn't been concurrently\n    // modified.\n\n\n    this._publishQueue.commitPayload(this._operation, relayPayload, function (store) {\n      var currentParentRecord = store.get(parentID);\n\n      if (currentParentRecord == null) {\n        // parent has since been deleted, stream data is stale\n        return;\n      }\n\n      var currentItems = currentParentRecord.getLinkedRecords(storageKey);\n\n      if (currentItems == null) {\n        // field has since been deleted, stream data is stale\n        return;\n      }\n\n      if (currentItems.length !== prevIDs.length || currentItems.some(function (currentItem, index) {\n        return prevIDs[index] !== (currentItem && currentItem.getDataID());\n      })) {\n        // field has been modified by something other than this query,\n        // stream data is stale\n        return;\n      } // parent.field has not been concurrently modified:\n      // update `parent.field[index] = item`\n\n\n      var nextItems = (0, _toConsumableArray2[\"default\"])(currentItems);\n      nextItems[itemIndex] = store.get(itemID);\n      currentParentRecord.setLinkedRecords(nextItems, storageKey);\n    }); // Now that the parent record has been updated to include the new item,\n    // also update any handle fields that are derived from the parent record.\n\n\n    if (fieldPayloads.length !== 0) {\n      var handleFieldsRelayPayload = {\n        errors: null,\n        fieldPayloads: fieldPayloads,\n        incrementalPlaceholders: null,\n        moduleImportPayloads: null,\n        source: RelayRecordSource.create(),\n        isFinal: false\n      };\n\n      this._publishQueue.commitPayload(this._operation, handleFieldsRelayPayload);\n    }\n\n    return relayPayload;\n  };\n\n  _proto._normalizeStreamItem = function _normalizeStreamItem(response, parentID, field, variables, path, normalizationPath) {\n    var _field$alias, _field$concreteType, _this$_getDataID;\n\n    var data = response.data;\n    !(typeof data === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected the GraphQL @stream payload `data` ' + 'value to be an object.') : invariant(false) : void 0;\n    var responseKey = (_field$alias = field.alias) !== null && _field$alias !== void 0 ? _field$alias : field.name;\n    var storageKey = getStorageKey(field, variables); // Load the version of the parent record from which this incremental data\n    // was derived\n\n    var parentEntry = this._source.get(parentID);\n\n    !(parentEntry != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected the parent record `%s` for @stream ' + 'data to exist.', parentID) : invariant(false) : void 0;\n    var parentRecord = parentEntry.record,\n        fieldPayloads = parentEntry.fieldPayloads; // Load the field value (items) that were created by *this* query executor\n    // in order to check if there has been any concurrent modifications by some\n    // other operation.\n\n    var prevIDs = RelayModernRecord.getLinkedRecordIDs(parentRecord, storageKey);\n    !(prevIDs != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected record `%s` to have fetched field ' + '`%s` with @stream.', parentID, field.name) : invariant(false) : void 0; // Determine the index in the field of the new item\n\n    var finalPathEntry = path[path.length - 1];\n    var itemIndex = parseInt(finalPathEntry, 10);\n    !(itemIndex === finalPathEntry && itemIndex >= 0) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected path for @stream to end in a ' + 'positive integer index, got `%s`', finalPathEntry) : invariant(false) : void 0;\n    var typeName = (_field$concreteType = field.concreteType) !== null && _field$concreteType !== void 0 ? _field$concreteType : data[TYPENAME_KEY];\n    !(typeof typeName === 'string') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected @stream field `%s` to have a ' + '__typename.', field.name) : invariant(false) : void 0; // Determine the __id of the new item: this must equal the value that would\n    // be assigned had the item not been streamed\n\n    var itemID = // https://github.com/prettier/prettier/issues/6403\n    // prettier-ignore\n    ((_this$_getDataID = this._getDataID(data, typeName)) !== null && _this$_getDataID !== void 0 ? _this$_getDataID : prevIDs && prevIDs[itemIndex]) || // Reuse previously generated client IDs\n    generateClientID(parentID, storageKey, itemIndex);\n    !(typeof itemID === 'string') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernEnvironment: Expected id of elements of field `%s` to ' + 'be strings.', storageKey) : invariant(false) : void 0; // Build a selector to normalize the item data with\n\n    var selector = createNormalizationSelector(field, itemID, variables); // Update the cached version of the parent record to reflect the new item:\n    // this is used when subsequent stream payloads arrive to see if there\n    // have been concurrent modifications to the list\n\n    var nextParentRecord = RelayModernRecord.clone(parentRecord);\n    var nextIDs = (0, _toConsumableArray2[\"default\"])(prevIDs);\n    nextIDs[itemIndex] = itemID;\n    RelayModernRecord.setLinkedRecordIDs(nextParentRecord, storageKey, nextIDs);\n\n    this._source.set(parentID, {\n      record: nextParentRecord,\n      fieldPayloads: fieldPayloads\n    });\n\n    var relayPayload = normalizeResponse(response, selector, typeName, {\n      getDataID: this._getDataID,\n      path: [].concat((0, _toConsumableArray2[\"default\"])(normalizationPath), [responseKey, String(itemIndex)]),\n      reactFlightPayloadDeserializer: this._reactFlightPayloadDeserializer,\n      reactFlightServerErrorHandler: this._reactFlightServerErrorHandler,\n      treatMissingFieldsAsNull: this._treatMissingFieldsAsNull,\n      shouldProcessClientComponents: this._shouldProcessClientComponents\n    });\n    return {\n      fieldPayloads: fieldPayloads,\n      itemID: itemID,\n      itemIndex: itemIndex,\n      prevIDs: prevIDs,\n      relayPayload: relayPayload,\n      storageKey: storageKey\n    };\n  };\n\n  _proto._updateOperationTracker = function _updateOperationTracker(updatedOwners) {\n    if (updatedOwners != null && updatedOwners.length > 0) {\n      this._operationTracker.update(this._operation.request, new Set(updatedOwners));\n    }\n  };\n\n  _proto._completeOperationTracker = function _completeOperationTracker() {\n    this._operationTracker.complete(this._operation.request);\n  };\n\n  return Executor;\n}();\n\nfunction partitionGraphQLResponses(responses) {\n  var nonIncrementalResponses = [];\n  var incrementalResponses = [];\n  responses.forEach(function (response) {\n    if (response.path != null || response.label != null) {\n      var label = response.label,\n          path = response.path;\n\n      if (label == null || path == null) {\n        !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'OperationExecutor: invalid incremental payload, expected ' + '`path` and `label` to either both be null/undefined, or ' + '`path` to be an `Array<string | number>` and `label` to be a ' + '`string`.') : invariant(false) : void 0;\n      }\n\n      incrementalResponses.push({\n        label: label,\n        path: path,\n        response: response\n      });\n    } else {\n      nonIncrementalResponses.push(response);\n    }\n  });\n  return [nonIncrementalResponses, incrementalResponses];\n}\n\nfunction normalizeResponse(response, selector, typeName, options) {\n  var _response$extensions3;\n\n  var data = response.data,\n      errors = response.errors;\n  var source = RelayRecordSource.create();\n  var record = RelayModernRecord.create(selector.dataID, typeName);\n  source.set(selector.dataID, record);\n  var relayPayload = RelayResponseNormalizer.normalize(source, selector, data, options);\n  return (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, relayPayload), {}, {\n    errors: errors,\n    isFinal: ((_response$extensions3 = response.extensions) === null || _response$extensions3 === void 0 ? void 0 : _response$extensions3.is_final) === true\n  });\n}\n\nfunction stableStringify(value) {\n  var _JSON$stringify;\n\n  return (_JSON$stringify = JSON.stringify(stableCopy(value))) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : ''; // null-check for flow\n}\n\nfunction validateOptimisticResponsePayload(payload) {\n  var incrementalPlaceholders = payload.incrementalPlaceholders;\n\n  if (incrementalPlaceholders != null && incrementalPlaceholders.length !== 0) {\n    !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'OperationExecutor: optimistic responses cannot be returned ' + 'for operations that use incremental data delivery (@defer, ' + '@stream, and @stream_connection).') : invariant(false) : void 0;\n  }\n}\n\nmodule.exports = {\n  execute: execute\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 RelayDeclarativeMutationConfig = require('./RelayDeclarativeMutationConfig');\n\nvar invariant = require('invariant');\n\nvar isRelayModernEnvironment = require('../store/isRelayModernEnvironment');\n\nvar _require = require('../query/GraphQLTag'),\n    getRequest = _require.getRequest;\n\nvar _require2 = require('../store/RelayModernOperationDescriptor'),\n    createOperationDescriptor = _require2.createOperationDescriptor;\n\n/**\n * Higher-level helper function to execute a mutation against a specific\n * environment.\n */\nfunction applyOptimisticMutation(environment, config) {\n  !isRelayModernEnvironment(environment) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'commitMutation: expected `environment` to be an instance of ' + '`RelayModernEnvironment`.') : invariant(false) : void 0;\n  var mutation = getRequest(config.mutation);\n\n  if (mutation.params.operationKind !== 'mutation') {\n    throw new Error('commitMutation: Expected mutation operation');\n  }\n\n  var optimisticUpdater = config.optimisticUpdater;\n  var configs = config.configs,\n      optimisticResponse = config.optimisticResponse,\n      variables = config.variables;\n  var operation = createOperationDescriptor(mutation, variables);\n\n  if (configs) {\n    var _RelayDeclarativeMuta = RelayDeclarativeMutationConfig.convert(configs, mutation, optimisticUpdater);\n\n    optimisticUpdater = _RelayDeclarativeMuta.optimisticUpdater;\n  }\n\n  return environment.applyMutation({\n    operation: operation,\n    response: optimisticResponse,\n    updater: optimisticUpdater\n  });\n}\n\nmodule.exports = applyOptimisticMutation;","/**\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 invariant = require('invariant');\n\nvar stableCopy = require('../util/stableCopy');\n\n/**\n * A cache for storing query responses, featuring:\n * - `get` with TTL\n * - cache size limiting, with least-recently *updated* entries purged first\n */\nvar RelayQueryResponseCache = /*#__PURE__*/function () {\n  function RelayQueryResponseCache(_ref) {\n    var size = _ref.size,\n        ttl = _ref.ttl;\n    !(size > 0) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayQueryResponseCache: Expected the max cache size to be > 0, got ' + '`%s`.', size) : invariant(false) : void 0;\n    !(ttl > 0) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayQueryResponseCache: Expected the max ttl to be > 0, got `%s`.', ttl) : invariant(false) : void 0;\n    this._responses = new Map();\n    this._size = size;\n    this._ttl = ttl;\n  }\n\n  var _proto = RelayQueryResponseCache.prototype;\n\n  _proto.clear = function clear() {\n    this._responses.clear();\n  };\n\n  _proto.get = function get(queryID, variables) {\n    var _this = this;\n\n    var cacheKey = getCacheKey(queryID, variables);\n\n    this._responses.forEach(function (response, key) {\n      if (!isCurrent(response.fetchTime, _this._ttl)) {\n        _this._responses[\"delete\"](key);\n      }\n    });\n\n    var response = this._responses.get(cacheKey);\n\n    return response != null ? // $FlowFixMe[speculation-ambiguous]\n    (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, response.payload), {}, {\n      extensions: (0, _objectSpread2[\"default\"])((0, _objectSpread2[\"default\"])({}, response.payload.extensions), {}, {\n        cacheTimestamp: response.fetchTime\n      })\n    }) : null;\n  };\n\n  _proto.set = function set(queryID, variables, payload) {\n    var fetchTime = Date.now();\n    var cacheKey = getCacheKey(queryID, variables);\n\n    this._responses[\"delete\"](cacheKey); // deletion resets key ordering\n\n\n    this._responses.set(cacheKey, {\n      fetchTime: fetchTime,\n      payload: payload\n    }); // Purge least-recently updated key when max size reached\n\n\n    if (this._responses.size > this._size) {\n      var firstKey = this._responses.keys().next();\n\n      if (!firstKey.done) {\n        this._responses[\"delete\"](firstKey.value);\n      }\n    }\n  };\n\n  return RelayQueryResponseCache;\n}();\n\nfunction getCacheKey(queryID, variables) {\n  return JSON.stringify(stableCopy({\n    queryID: queryID,\n    variables: variables\n  }));\n}\n/**\n * Determine whether a response fetched at `fetchTime` is still valid given\n * some `ttl`.\n */\n\n\nfunction isCurrent(fetchTime, ttl) {\n  return fetchTime + ttl >= Date.now();\n}\n\nmodule.exports = RelayQueryResponseCache;","/**\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 RelayFeatureFlags = {\n  ENABLE_VARIABLE_CONNECTION_KEY: false,\n  ENABLE_PARTIAL_RENDERING_DEFAULT: true,\n  ENABLE_RELAY_CONTAINERS_SUSPENSE: true,\n  ENABLE_PRECISE_TYPE_REFINEMENT: false,\n  ENABLE_REACT_FLIGHT_COMPONENT_FIELD: false,\n  ENABLE_REQUIRED_DIRECTIVES: false,\n  ENABLE_RELAY_RESOLVERS: false,\n  ENABLE_GETFRAGMENTIDENTIFIER_OPTIMIZATION: false,\n  ENABLE_FRIENDLY_QUERY_NAME_GQL_URL: false,\n  ENABLE_STORE_SUBSCRIPTIONS_REFACTOR: false,\n  ENABLE_LOAD_QUERY_REQUEST_DEDUPING: true,\n  ENABLE_DO_NOT_WRAP_LIVE_QUERY: false,\n  ENABLE_NOTIFY_SUBSCRIPTION: false,\n  ENABLE_UNIQUE_SUBSCRIPTION_ROOT: false,\n  ENABLE_BATCHED_STORE_UPDATES: false\n};\nmodule.exports = RelayFeatureFlags;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar toPrimitive = require(\"./toPrimitive.js\");\nfunction _toPropertyKey(arg) {\n  var key = toPrimitive(arg, \"string\");\n  return _typeof(key) === \"symbol\" ? key : String(key);\n}\nmodule.exports = _toPropertyKey, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\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 */\nfunction makeEmptyFunction(arg) {\n  return function () {\n    return arg;\n  };\n}\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\n\n\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\n\nemptyFunction.thatReturnsThis = function () {\n  return this;\n};\n\nemptyFunction.thatReturnsArgument = function (arg) {\n  return arg;\n};\n\nmodule.exports = emptyFunction;","/**\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 _require = require('./ConvertToExecuteFunction'),\n    convertFetch = _require.convertFetch;\n\n/**\n * Creates an implementation of the `Network` interface defined in\n * `RelayNetworkTypes` given `fetch` and `subscribe` functions.\n */\nfunction create(fetchFn, subscribe) {\n  // Convert to functions that returns RelayObservable.\n  var observeFetch = convertFetch(fetchFn);\n\n  function execute(request, variables, cacheConfig, uploadables, logRequestInfo) {\n    if (request.operationKind === 'subscription') {\n      !subscribe ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayNetwork: This network layer does not support Subscriptions. ' + 'To use Subscriptions, provide a custom network layer.') : invariant(false) : void 0;\n      !!uploadables ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayNetwork: Cannot provide uploadables while subscribing.') : invariant(false) : void 0;\n      return subscribe(request, variables, cacheConfig);\n    }\n\n    var pollInterval = cacheConfig.poll;\n\n    if (pollInterval != null) {\n      !!uploadables ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayNetwork: Cannot provide uploadables while polling.') : invariant(false) : void 0;\n      return observeFetch(request, variables, {\n        force: true\n      }).poll(pollInterval);\n    }\n\n    return observeFetch(request, variables, cacheConfig, uploadables, logRequestInfo);\n  }\n\n  return {\n    execute: execute\n  };\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 * \n * @format\n */\n// flowlint ambiguous-object-type:error\n'use strict';\n\nvar isPromise = require('../util/isPromise');\n/**\n * A Subscription object is returned from .subscribe(), which can be\n * unsubscribed or checked to see if the resulting subscription has closed.\n */\n\n\nvar hostReportError = swallowError;\n/**\n * Limited implementation of ESObservable, providing the limited set of behavior\n * Relay networking requires.\n *\n * Observables retain the benefit of callbacks which can be called\n * synchronously, avoiding any UI jitter, while providing a compositional API,\n * which simplifies logic and prevents mishandling of errors compared to\n * the direct use of callback functions.\n *\n * ESObservable: https://github.com/tc39/proposal-observable\n */\n\nvar RelayObservable = /*#__PURE__*/function () {\n  RelayObservable.create = function create(source) {\n    return new RelayObservable(source);\n  } // Use RelayObservable.create()\n  ;\n\n  function RelayObservable(source) {\n    if (process.env.NODE_ENV !== \"production\") {\n      // Early runtime errors for ill-formed sources.\n      if (!source || typeof source !== 'function') {\n        throw new Error('Source must be a Function: ' + String(source));\n      }\n    }\n\n    this._source = source;\n  }\n  /**\n   * When an emitted error event is not handled by an Observer, it is reported\n   * to the host environment (what the ESObservable spec refers to as\n   * \"HostReportErrors()\").\n   *\n   * The default implementation in development rethrows thrown errors, and\n   * logs emitted error events to the console, while in production does nothing\n   * (swallowing unhandled errors).\n   *\n   * Called during application initialization, this method allows\n   * application-specific handling of unhandled errors. Allowing, for example,\n   * integration with error logging or developer tools.\n   *\n   * A second parameter `isUncaughtThrownError` is true when the unhandled error\n   * was thrown within an Observer handler, and false when the unhandled error\n   * was an unhandled emitted event.\n   *\n   *  - Uncaught thrown errors typically represent avoidable errors thrown from\n   *    application code, which should be handled with a try/catch block, and\n   *    usually have useful stack traces.\n   *\n   *  - Unhandled emitted event errors typically represent unavoidable events in\n   *    application flow such as network failure, and may not have useful\n   *    stack traces.\n   */\n\n\n  RelayObservable.onUnhandledError = function onUnhandledError(callback) {\n    hostReportError = callback;\n  }\n  /**\n   * Accepts various kinds of data sources, and always returns a RelayObservable\n   * useful for accepting the result of a user-provided FetchFunction.\n   */\n  ;\n\n  RelayObservable.from = function from(obj) {\n    return isObservable(obj) ? fromObservable(obj) : isPromise(obj) ? fromPromise(obj) : fromValue(obj);\n  }\n  /**\n   * Similar to promise.catch(), observable.catch() handles error events, and\n   * provides an alternative observable to use in it's place.\n   *\n   * If the catch handler throws a new error, it will appear as an error event\n   * on the resulting Observable.\n   */\n  ;\n\n  var _proto = RelayObservable.prototype;\n\n  _proto[\"catch\"] = function _catch(fn) {\n    var _this = this;\n\n    return RelayObservable.create(function (sink) {\n      var subscription;\n\n      _this.subscribe({\n        start: function start(sub) {\n          subscription = sub;\n        },\n        next: sink.next,\n        complete: sink.complete,\n        error: function error(_error2) {\n          try {\n            fn(_error2).subscribe({\n              start: function start(sub) {\n                subscription = sub;\n              },\n              next: sink.next,\n              complete: sink.complete,\n              error: sink.error\n            });\n          } catch (error2) {\n            sink.error(error2, true\n            /* isUncaughtThrownError */\n            );\n          }\n        }\n      });\n\n      return function () {\n        return subscription.unsubscribe();\n      };\n    });\n  }\n  /**\n   * Returns a new Observable which first yields values from this Observable,\n   * then yields values from the next Observable. This is useful for chaining\n   * together Observables of finite length.\n   */\n  ;\n\n  _proto.concat = function concat(next) {\n    var _this2 = this;\n\n    return RelayObservable.create(function (sink) {\n      var current;\n\n      _this2.subscribe({\n        start: function start(subscription) {\n          current = subscription;\n        },\n        next: sink.next,\n        error: sink.error,\n        complete: function complete() {\n          current = next.subscribe(sink);\n        }\n      });\n\n      return function () {\n        current && current.unsubscribe();\n      };\n    });\n  }\n  /**\n   * Returns a new Observable which returns the same values as this one, but\n   * modified so that the provided Observer is called to perform a side-effects\n   * for all events emitted by the source.\n   *\n   * Any errors that are thrown in the side-effect Observer are unhandled, and\n   * do not affect the source Observable or its Observer.\n   *\n   * This is useful for when debugging your Observables or performing other\n   * side-effects such as logging or performance monitoring.\n   */\n  ;\n\n  _proto[\"do\"] = function _do(observer) {\n    var _this3 = this;\n\n    return RelayObservable.create(function (sink) {\n      var both = function both(action) {\n        return function () {\n          try {\n            observer[action] && observer[action].apply(observer, arguments);\n          } catch (error) {\n            hostReportError(error, true\n            /* isUncaughtThrownError */\n            );\n          }\n\n          sink[action] && sink[action].apply(sink, arguments);\n        };\n      };\n\n      return _this3.subscribe({\n        start: both('start'),\n        next: both('next'),\n        error: both('error'),\n        complete: both('complete'),\n        unsubscribe: both('unsubscribe')\n      });\n    });\n  }\n  /**\n   * Returns a new Observable which returns the same values as this one, but\n   * modified so that the finally callback is performed after completion,\n   * whether normal or due to error or unsubscription.\n   *\n   * This is useful for cleanup such as resource finalization.\n   */\n  ;\n\n  _proto[\"finally\"] = function _finally(fn) {\n    var _this4 = this;\n\n    return RelayObservable.create(function (sink) {\n      var subscription = _this4.subscribe(sink);\n\n      return function () {\n        subscription.unsubscribe();\n        fn();\n      };\n    });\n  }\n  /**\n   * Returns a new Observable which is identical to this one, unless this\n   * Observable completes before yielding any values, in which case the new\n   * Observable will yield the values from the alternate Observable.\n   *\n   * If this Observable does yield values, the alternate is never subscribed to.\n   *\n   * This is useful for scenarios where values may come from multiple sources\n   * which should be tried in order, i.e. from a cache before a network.\n   */\n  ;\n\n  _proto.ifEmpty = function ifEmpty(alternate) {\n    var _this5 = this;\n\n    return RelayObservable.create(function (sink) {\n      var hasValue = false;\n\n      var current = _this5.subscribe({\n        next: function next(value) {\n          hasValue = true;\n          sink.next(value);\n        },\n        error: sink.error,\n        complete: function complete() {\n          if (hasValue) {\n            sink.complete();\n          } else {\n            current = alternate.subscribe(sink);\n          }\n        }\n      });\n\n      return function () {\n        current.unsubscribe();\n      };\n    });\n  }\n  /**\n   * Observable's primary API: returns an unsubscribable Subscription to the\n   * source of this Observable.\n   *\n   * Note: A sink may be passed directly to .subscribe() as its observer,\n   * allowing for easily composing Observables.\n   */\n  ;\n\n  _proto.subscribe = function subscribe(observer) {\n    if (process.env.NODE_ENV !== \"production\") {\n      // Early runtime errors for ill-formed observers.\n      if (!observer || typeof observer !== 'object') {\n        throw new Error('Observer must be an Object with callbacks: ' + String(observer));\n      }\n    }\n\n    return _subscribe(this._source, observer);\n  }\n  /**\n   * Returns a new Observerable where each value has been transformed by\n   * the mapping function.\n   */\n  ;\n\n  _proto.map = function map(fn) {\n    var _this6 = this;\n\n    return RelayObservable.create(function (sink) {\n      var subscription = _this6.subscribe({\n        complete: sink.complete,\n        error: sink.error,\n        next: function next(value) {\n          try {\n            var mapValue = fn(value);\n            sink.next(mapValue);\n          } catch (error) {\n            sink.error(error, true\n            /* isUncaughtThrownError */\n            );\n          }\n        }\n      });\n\n      return function () {\n        subscription.unsubscribe();\n      };\n    });\n  }\n  /**\n   * Returns a new Observable where each value is replaced with a new Observable\n   * by the mapping function, the results of which returned as a single\n   * merged Observable.\n   */\n  ;\n\n  _proto.mergeMap = function mergeMap(fn) {\n    var _this7 = this;\n\n    return RelayObservable.create(function (sink) {\n      var subscriptions = [];\n\n      function start(subscription) {\n        this._sub = subscription;\n        subscriptions.push(subscription);\n      }\n\n      function complete() {\n        subscriptions.splice(subscriptions.indexOf(this._sub), 1);\n\n        if (subscriptions.length === 0) {\n          sink.complete();\n        }\n      }\n\n      _this7.subscribe({\n        start: start,\n        next: function next(value) {\n          try {\n            if (!sink.closed) {\n              RelayObservable.from(fn(value)).subscribe({\n                start: start,\n                next: sink.next,\n                error: sink.error,\n                complete: complete\n              });\n            }\n          } catch (error) {\n            sink.error(error, true\n            /* isUncaughtThrownError */\n            );\n          }\n        },\n        error: sink.error,\n        complete: complete\n      });\n\n      return function () {\n        subscriptions.forEach(function (sub) {\n          return sub.unsubscribe();\n        });\n        subscriptions.length = 0;\n      };\n    });\n  }\n  /**\n   * Returns a new Observable which first mirrors this Observable, then when it\n   * completes, waits for `pollInterval` milliseconds before re-subscribing to\n   * this Observable again, looping in this manner until unsubscribed.\n   *\n   * The returned Observable never completes.\n   */\n  ;\n\n  _proto.poll = function poll(pollInterval) {\n    var _this8 = this;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      if (typeof pollInterval !== 'number' || pollInterval <= 0) {\n        throw new Error('RelayObservable: Expected pollInterval to be positive, got: ' + pollInterval);\n      }\n    }\n\n    return RelayObservable.create(function (sink) {\n      var subscription;\n      var timeout;\n\n      var poll = function poll() {\n        subscription = _this8.subscribe({\n          next: sink.next,\n          error: sink.error,\n          complete: function complete() {\n            timeout = setTimeout(poll, pollInterval);\n          }\n        });\n      };\n\n      poll();\n      return function () {\n        clearTimeout(timeout);\n        subscription.unsubscribe();\n      };\n    });\n  }\n  /**\n   * Returns a Promise which resolves when this Observable yields a first value\n   * or when it completes with no value.\n   *\n   * NOTE: The source Observable is *NOT* canceled when the returned Promise\n   * resolves. The Observable is always run to completion.\n   */\n  ;\n\n  _proto.toPromise = function toPromise() {\n    var _this9 = this;\n\n    return new Promise(function (resolve, reject) {\n      var resolved = false;\n\n      _this9.subscribe({\n        next: function next(val) {\n          if (!resolved) {\n            resolved = true;\n            resolve(val);\n          }\n        },\n        error: reject,\n        complete: resolve\n      });\n    });\n  };\n\n  return RelayObservable;\n}(); // Use declarations to teach Flow how to check isObservable.\n\n\nfunction isObservable(obj) {\n  return typeof obj === 'object' && obj !== null && typeof obj.subscribe === 'function';\n}\n\nfunction fromObservable(obj) {\n  return obj instanceof RelayObservable ? obj : RelayObservable.create(function (sink) {\n    return obj.subscribe(sink);\n  });\n}\n\nfunction fromPromise(promise) {\n  return RelayObservable.create(function (sink) {\n    // Since sink methods do not throw, the resulting Promise can be ignored.\n    promise.then(function (value) {\n      sink.next(value);\n      sink.complete();\n    }, sink.error);\n  });\n}\n\nfunction fromValue(value) {\n  return RelayObservable.create(function (sink) {\n    sink.next(value);\n    sink.complete();\n  });\n}\n\nfunction _subscribe(source, observer) {\n  var closed = false;\n  var cleanup; // Ideally we would simply describe a `get closed()` method on the Sink and\n  // Subscription objects below, however not all flow environments we expect\n  // Relay to be used within will support property getters, and many minifier\n  // tools still do not support ES5 syntax. Instead, we can use defineProperty.\n\n  var withClosed = function withClosed(obj) {\n    return Object.defineProperty(obj, 'closed', {\n      get: function get() {\n        return closed;\n      }\n    });\n  };\n\n  function doCleanup() {\n    if (cleanup) {\n      if (cleanup.unsubscribe) {\n        cleanup.unsubscribe();\n      } else {\n        try {\n          cleanup();\n        } catch (error) {\n          hostReportError(error, true\n          /* isUncaughtThrownError */\n          );\n        }\n      }\n\n      cleanup = undefined;\n    }\n  } // Create a Subscription.\n\n\n  var subscription = withClosed({\n    unsubscribe: function unsubscribe() {\n      if (!closed) {\n        closed = true; // Tell Observer that unsubscribe was called.\n\n        try {\n          observer.unsubscribe && observer.unsubscribe(subscription);\n        } catch (error) {\n          hostReportError(error, true\n          /* isUncaughtThrownError */\n          );\n        } finally {\n          doCleanup();\n        }\n      }\n    }\n  }); // Tell Observer that observation is about to begin.\n\n  try {\n    observer.start && observer.start(subscription);\n  } catch (error) {\n    hostReportError(error, true\n    /* isUncaughtThrownError */\n    );\n  } // If closed already, don't bother creating a Sink.\n\n\n  if (closed) {\n    return subscription;\n  } // Create a Sink respecting subscription state and cleanup.\n\n\n  var sink = withClosed({\n    next: function next(value) {\n      if (!closed && observer.next) {\n        try {\n          observer.next(value);\n        } catch (error) {\n          hostReportError(error, true\n          /* isUncaughtThrownError */\n          );\n        }\n      }\n    },\n    error: function error(_error3, isUncaughtThrownError) {\n      if (closed || !observer.error) {\n        closed = true;\n        hostReportError(_error3, isUncaughtThrownError || false);\n        doCleanup();\n      } else {\n        closed = true;\n\n        try {\n          observer.error(_error3);\n        } catch (error2) {\n          hostReportError(error2, true\n          /* isUncaughtThrownError */\n          );\n        } finally {\n          doCleanup();\n        }\n      }\n    },\n    complete: function complete() {\n      if (!closed) {\n        closed = true;\n\n        try {\n          observer.complete && observer.complete();\n        } catch (error) {\n          hostReportError(error, true\n          /* isUncaughtThrownError */\n          );\n        } finally {\n          doCleanup();\n        }\n      }\n    }\n  }); // If anything goes wrong during observing the source, handle the error.\n\n  try {\n    cleanup = source(sink);\n  } catch (error) {\n    sink.error(error, true\n    /* isUncaughtThrownError */\n    );\n  }\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // Early runtime errors for ill-formed returned cleanup.\n    if (cleanup !== undefined && typeof cleanup !== 'function' && (!cleanup || typeof cleanup.unsubscribe !== 'function')) {\n      throw new Error('Returned cleanup function which cannot be called: ' + String(cleanup));\n    }\n  } // If closed before the source function existed, cleanup now.\n\n\n  if (closed) {\n    doCleanup();\n  }\n\n  return subscription;\n}\n\nfunction swallowError(_error, _isUncaughtThrownError) {// do nothing.\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  // Default implementation of HostReportErrors() in development builds.\n  // Can be replaced by the host application environment.\n  RelayObservable.onUnhandledError(function (error, isUncaughtThrownError) {\n    if (typeof fail === 'function') {\n      // In test environments (Jest), fail() immediately fails the current test.\n      fail(String(error));\n    } else if (isUncaughtThrownError) {\n      // Rethrow uncaught thrown errors on the next frame to avoid breaking\n      // current logic.\n      setTimeout(function () {\n        throw error;\n      });\n    } else if (typeof console !== 'undefined') {\n      // Otherwise, log the unhandled error for visibility.\n      // eslint-disable-next-line no-console\n      console.error('RelayObservable: Unhandled Error', error);\n    }\n  });\n}\n\nmodule.exports = RelayObservable;","/**\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 deepFreeze = require('../util/deepFreeze');\n\nvar getRequestIdentifier = require('../util/getRequestIdentifier');\n\nvar _require = require('./RelayConcreteVariables'),\n    getOperationVariables = _require.getOperationVariables;\n\nvar _require2 = require('./RelayModernSelector'),\n    createNormalizationSelector = _require2.createNormalizationSelector,\n    createReaderSelector = _require2.createReaderSelector;\n\nvar _require3 = require('./RelayStoreUtils'),\n    ROOT_ID = _require3.ROOT_ID;\n\n/**\n * Creates an instance of the `OperationDescriptor` type defined in\n * `RelayStoreTypes` given an operation and some variables. The input variables\n * are filtered to exclude variables that do not match defined arguments on the\n * operation, and default values are populated for null values.\n */\nfunction createOperationDescriptor(request, variables, cacheConfig) {\n  var dataID = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : ROOT_ID;\n  var operation = request.operation;\n  var operationVariables = getOperationVariables(operation, variables);\n  var requestDescriptor = createRequestDescriptor(request, operationVariables, cacheConfig);\n  var operationDescriptor = {\n    fragment: createReaderSelector(request.fragment, dataID, operationVariables, requestDescriptor),\n    request: requestDescriptor,\n    root: createNormalizationSelector(operation, dataID, operationVariables)\n  };\n\n  if (process.env.NODE_ENV !== \"production\") {\n    // Freezing properties short-circuits a deepFreeze of snapshots that contain\n    // an OperationDescriptor via their selector's owner, avoiding stack\n    // overflow on larger queries.\n    Object.freeze(operationDescriptor.fragment);\n    Object.freeze(operationDescriptor.root);\n    Object.freeze(operationDescriptor);\n  }\n\n  return operationDescriptor;\n}\n\nfunction createRequestDescriptor(request, variables, cacheConfig) {\n  var requestDescriptor = {\n    identifier: getRequestIdentifier(request.params, variables),\n    node: request,\n    variables: variables,\n    cacheConfig: cacheConfig\n  };\n\n  if (process.env.NODE_ENV !== \"production\") {\n    deepFreeze(variables);\n    Object.freeze(request);\n    Object.freeze(requestDescriptor);\n  }\n\n  return requestDescriptor;\n}\n\nmodule.exports = {\n  createOperationDescriptor: createOperationDescriptor,\n  createRequestDescriptor: createRequestDescriptor\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 RelayRecordState = {\n  /**\n   * Record exists (either fetched from the server or produced by a local,\n   * optimistic update).\n   */\n  EXISTENT: 'EXISTENT',\n\n  /**\n   * Record is known not to exist (either as the result of a mutation, or\n   * because the server returned `null` when queried for the record).\n   */\n  NONEXISTENT: 'NONEXISTENT',\n\n  /**\n   * Record State is unknown because it has not yet been fetched from the\n   * server.\n   */\n  UNKNOWN: 'UNKNOWN'\n};\nmodule.exports = RelayRecordState;","/**\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 _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar RelayReader = require('./RelayReader');\n\nvar deepFreeze = require('../util/deepFreeze');\n\nvar recycleNodesInto = require('../util/recycleNodesInto');\n\nvar RelayStoreSubscriptionsUsingMapByID = /*#__PURE__*/function () {\n  function RelayStoreSubscriptionsUsingMapByID(log) {\n    this._notifiedRevision = 0;\n    this._snapshotRevision = 0;\n    this._subscriptionsByDataId = new Map();\n    this._staleSubscriptions = new Set();\n    this.__log = log;\n  }\n\n  var _proto = RelayStoreSubscriptionsUsingMapByID.prototype;\n\n  _proto.subscribe = function subscribe(snapshot, callback) {\n    var _this = this;\n\n    var subscription = {\n      backup: null,\n      callback: callback,\n      notifiedRevision: this._notifiedRevision,\n      snapshotRevision: this._snapshotRevision,\n      snapshot: snapshot\n    };\n\n    var dispose = function dispose() {\n      var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(snapshot.seenRecords),\n          _step;\n\n      try {\n        for (_iterator.s(); !(_step = _iterator.n()).done;) {\n          var dataId = _step.value;\n\n          var subscriptionsForDataId = _this._subscriptionsByDataId.get(dataId);\n\n          if (subscriptionsForDataId != null) {\n            subscriptionsForDataId[\"delete\"](subscription);\n\n            if (subscriptionsForDataId.size === 0) {\n              _this._subscriptionsByDataId[\"delete\"](dataId);\n            }\n          }\n        }\n      } catch (err) {\n        _iterator.e(err);\n      } finally {\n        _iterator.f();\n      }\n    };\n\n    var _iterator2 = (0, _createForOfIteratorHelper2[\"default\"])(snapshot.seenRecords),\n        _step2;\n\n    try {\n      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n        var dataId = _step2.value;\n\n        var subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);\n\n        if (subscriptionsForDataId != null) {\n          subscriptionsForDataId.add(subscription);\n        } else {\n          this._subscriptionsByDataId.set(dataId, new Set([subscription]));\n        }\n      }\n    } catch (err) {\n      _iterator2.e(err);\n    } finally {\n      _iterator2.f();\n    }\n\n    return {\n      dispose: dispose\n    };\n  };\n\n  _proto.snapshotSubscriptions = function snapshotSubscriptions(source) {\n    var _this2 = this;\n\n    this._snapshotRevision++;\n\n    this._subscriptionsByDataId.forEach(function (subscriptions) {\n      subscriptions.forEach(function (subscription) {\n        if (subscription.snapshotRevision === _this2._snapshotRevision) {\n          return;\n        }\n\n        subscription.snapshotRevision = _this2._snapshotRevision; // Backup occurs after writing a new \"final\" payload(s) and before (re)applying\n        // optimistic changes. Each subscription's `snapshot` represents what was *last\n        // published to the subscriber*, which notably may include previous optimistic\n        // updates. Therefore a subscription can be in any of the following states:\n        // - stale=true: This subscription was restored to a different value than\n        //   `snapshot`. That means this subscription has changes relative to its base,\n        //   but its base has changed (we just applied a final payload): recompute\n        //   a backup so that we can later restore to the state the subscription\n        //   should be in.\n        // - stale=false: This subscription was restored to the same value than\n        //   `snapshot`. That means this subscription does *not* have changes relative\n        //   to its base, so the current `snapshot` is valid to use as a backup.\n\n        if (!_this2._staleSubscriptions.has(subscription)) {\n          subscription.backup = subscription.snapshot;\n          return;\n        }\n\n        var snapshot = subscription.snapshot;\n        var backup = RelayReader.read(source, snapshot.selector);\n        var nextData = recycleNodesInto(snapshot.data, backup.data);\n        backup.data = nextData; // backup owns the snapshot and can safely mutate\n\n        subscription.backup = backup;\n      });\n    });\n  };\n\n  _proto.restoreSubscriptions = function restoreSubscriptions() {\n    var _this3 = this;\n\n    this._snapshotRevision++;\n\n    this._subscriptionsByDataId.forEach(function (subscriptions) {\n      subscriptions.forEach(function (subscription) {\n        if (subscription.snapshotRevision === _this3._snapshotRevision) {\n          return;\n        }\n\n        subscription.snapshotRevision = _this3._snapshotRevision;\n        var backup = subscription.backup;\n        subscription.backup = null;\n\n        if (backup) {\n          if (backup.data !== subscription.snapshot.data) {\n            _this3._staleSubscriptions.add(subscription);\n          }\n\n          var prevSeenRecords = subscription.snapshot.seenRecords;\n          subscription.snapshot = {\n            data: subscription.snapshot.data,\n            isMissingData: backup.isMissingData,\n            seenRecords: backup.seenRecords,\n            selector: backup.selector,\n            missingRequiredFields: backup.missingRequiredFields\n          };\n\n          _this3._updateSubscriptionsMap(subscription, prevSeenRecords);\n        } else {\n          _this3._staleSubscriptions.add(subscription);\n        }\n      });\n    });\n  };\n\n  _proto.updateSubscriptions = function updateSubscriptions(source, updatedRecordIDs, updatedOwners, sourceOperation) {\n    var _this4 = this;\n\n    this._notifiedRevision++;\n    updatedRecordIDs.forEach(function (updatedRecordId) {\n      var subcriptionsForDataId = _this4._subscriptionsByDataId.get(updatedRecordId);\n\n      if (subcriptionsForDataId == null) {\n        return;\n      }\n\n      subcriptionsForDataId.forEach(function (subscription) {\n        if (subscription.notifiedRevision === _this4._notifiedRevision) {\n          return;\n        }\n\n        var owner = _this4._updateSubscription(source, subscription, false, sourceOperation);\n\n        if (owner != null) {\n          updatedOwners.push(owner);\n        }\n      });\n    });\n\n    this._staleSubscriptions.forEach(function (subscription) {\n      if (subscription.notifiedRevision === _this4._notifiedRevision) {\n        return;\n      }\n\n      var owner = _this4._updateSubscription(source, subscription, true, sourceOperation);\n\n      if (owner != null) {\n        updatedOwners.push(owner);\n      }\n    });\n\n    this._staleSubscriptions.clear();\n  }\n  /**\n   * Notifies the callback for the subscription if the data for the associated\n   * snapshot has changed.\n   * Additionally, updates the subscription snapshot with the latest snapshot,\n   * amarks it as not stale, and updates the subscription tracking for any\n   * any new ids observed in the latest data snapshot.\n   * Returns the owner (RequestDescriptor) if the subscription was affected by the\n   * latest update, or null if it was not affected.\n   */\n  ;\n\n  _proto._updateSubscription = function _updateSubscription(source, subscription, stale, sourceOperation) {\n    var backup = subscription.backup,\n        callback = subscription.callback,\n        snapshot = subscription.snapshot;\n    var nextSnapshot = stale && backup != null ? backup : RelayReader.read(source, snapshot.selector);\n    var nextData = recycleNodesInto(snapshot.data, nextSnapshot.data);\n    nextSnapshot = {\n      data: nextData,\n      isMissingData: nextSnapshot.isMissingData,\n      seenRecords: nextSnapshot.seenRecords,\n      selector: nextSnapshot.selector,\n      missingRequiredFields: nextSnapshot.missingRequiredFields\n    };\n\n    if (process.env.NODE_ENV !== \"production\") {\n      deepFreeze(nextSnapshot);\n    }\n\n    var prevSeenRecords = subscription.snapshot.seenRecords;\n    subscription.snapshot = nextSnapshot;\n    subscription.notifiedRevision = this._notifiedRevision;\n\n    this._updateSubscriptionsMap(subscription, prevSeenRecords);\n\n    if (nextSnapshot.data !== snapshot.data) {\n      if (this.__log && RelayFeatureFlags.ENABLE_NOTIFY_SUBSCRIPTION) {\n        this.__log({\n          name: 'store.notify.subscription',\n          sourceOperation: sourceOperation,\n          snapshot: snapshot,\n          nextSnapshot: nextSnapshot\n        });\n      }\n\n      callback(nextSnapshot);\n      return snapshot.selector.owner;\n    }\n  }\n  /**\n   * Updates the Map that tracks subscriptions by id.\n   * Given an updated subscription and the records that where seen\n   * on the previous subscription snapshot, updates our tracking\n   * to track the subscription for the newly and no longer seen ids.\n   */\n  ;\n\n  _proto._updateSubscriptionsMap = function _updateSubscriptionsMap(subscription, prevSeenRecords) {\n    var _iterator3 = (0, _createForOfIteratorHelper2[\"default\"])(prevSeenRecords),\n        _step3;\n\n    try {\n      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n        var dataId = _step3.value;\n\n        var subscriptionsForDataId = this._subscriptionsByDataId.get(dataId);\n\n        if (subscriptionsForDataId != null) {\n          subscriptionsForDataId[\"delete\"](subscription);\n\n          if (subscriptionsForDataId.size === 0) {\n            this._subscriptionsByDataId[\"delete\"](dataId);\n          }\n        }\n      }\n    } catch (err) {\n      _iterator3.e(err);\n    } finally {\n      _iterator3.f();\n    }\n\n    var _iterator4 = (0, _createForOfIteratorHelper2[\"default\"])(subscription.snapshot.seenRecords),\n        _step4;\n\n    try {\n      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n        var _dataId = _step4.value;\n\n        var _subscriptionsForDataId = this._subscriptionsByDataId.get(_dataId);\n\n        if (_subscriptionsForDataId != null) {\n          _subscriptionsForDataId.add(subscription);\n        } else {\n          this._subscriptionsByDataId.set(_dataId, new Set([subscription]));\n        }\n      }\n    } catch (err) {\n      _iterator4.e(err);\n    } finally {\n      _iterator4.f();\n    }\n  };\n\n  return RelayStoreSubscriptionsUsingMapByID;\n}();\n\nmodule.exports = RelayStoreSubscriptionsUsingMapByID;","/**\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 _require = require('../query/GraphQLTag'),\n    getFragment = _require.getFragment;\n\nvar _require2 = require('./RelayModernSelector'),\n    getSelector = _require2.getSelector;\n\nvar contextStack = [];\n\nfunction withResolverContext(context, cb) {\n  contextStack.push(context);\n\n  try {\n    return cb();\n  } finally {\n    contextStack.pop();\n  }\n} // NOTE: these declarations are copied from 'useFragment'; it would be good\n// to figure out how to share the same type signature between the two functions.\n// The declarations ensure that the type of the returned data is:\n//   - non-nullable if the provided ref type is non-nullable\n//   - nullable if the provided ref type is nullable\n//   - array of non-nullable if the privoided ref type is an array of\n//     non-nullable refs\n//   - array of nullable if the privoided ref type is an array of nullable refs\n\n\nfunction readFragment(fragmentInput, fragmentRef) {\n  if (!contextStack.length) {\n    throw new Error('readFragment should be called only from within a Relay Resolver function.');\n  }\n\n  var context = contextStack[contextStack.length - 1];\n  var fragmentNode = getFragment(fragmentInput);\n  var fragmentSelector = getSelector(fragmentNode, fragmentRef);\n  !(fragmentSelector != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Expected a selector for the fragment of the resolver \".concat(fragmentNode.name, \", but got null.\")) : invariant(false) : void 0;\n  !(fragmentSelector.kind === 'SingularReaderSelector') ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Expected a singular reader selector for the fragment of the resolver \".concat(fragmentNode.name, \", but it was plural.\")) : invariant(false) : void 0;\n  return context.getDataForResolverFragment(fragmentSelector);\n}\n\nmodule.exports = {\n  readFragment: readFragment,\n  withResolverContext: withResolverContext\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 RelayDeclarativeMutationConfig = require('../mutations/RelayDeclarativeMutationConfig');\n\nvar RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('../query/GraphQLTag'),\n    getRequest = _require.getRequest;\n\nvar _require2 = require('../store/ClientID'),\n    generateUniqueClientID = _require2.generateUniqueClientID;\n\nvar _require3 = require('../store/RelayModernOperationDescriptor'),\n    createOperationDescriptor = _require3.createOperationDescriptor;\n\nvar _require4 = require('../store/RelayModernSelector'),\n    createReaderSelector = _require4.createReaderSelector;\n\nfunction requestSubscription(environment, config) {\n  var subscription = getRequest(config.subscription);\n\n  if (subscription.params.operationKind !== 'subscription') {\n    throw new Error('requestSubscription: Must use Subscription operation');\n  }\n\n  var configs = config.configs,\n      onCompleted = config.onCompleted,\n      onError = config.onError,\n      onNext = config.onNext,\n      variables = config.variables,\n      cacheConfig = config.cacheConfig;\n  var operation = createOperationDescriptor(subscription, variables, cacheConfig, RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT ? generateUniqueClientID() : undefined);\n  process.env.NODE_ENV !== \"production\" ? warning(!(config.updater && configs), 'requestSubscription: Expected only one of `updater` and `configs` to be provided') : void 0;\n\n  var _ref = configs ? RelayDeclarativeMutationConfig.convert(configs, subscription, null\n  /* optimisticUpdater */\n  , config.updater) : config,\n      updater = _ref.updater;\n\n  var sub = environment.execute({\n    operation: operation,\n    updater: updater\n  }).map(function (responses) {\n    var selector = operation.fragment;\n\n    if (RelayFeatureFlags.ENABLE_UNIQUE_SUBSCRIPTION_ROOT) {\n      var nextID;\n\n      if (Array.isArray(responses)) {\n        var _responses$, _responses$$extension;\n\n        nextID = (_responses$ = responses[0]) === null || _responses$ === void 0 ? void 0 : (_responses$$extension = _responses$.extensions) === null || _responses$$extension === void 0 ? void 0 : _responses$$extension.__relay_subscription_root_id;\n      } else {\n        var _responses$extensions;\n\n        nextID = (_responses$extensions = responses.extensions) === null || _responses$extensions === void 0 ? void 0 : _responses$extensions.__relay_subscription_root_id;\n      }\n\n      if (typeof nextID === 'string') {\n        selector = createReaderSelector(selector.node, nextID, selector.variables, selector.owner);\n      }\n    }\n\n    var data = environment.lookup(selector).data; // $FlowFixMe[incompatible-cast]\n\n    return data;\n  }).subscribe({\n    next: onNext,\n    error: onError,\n    complete: onCompleted\n  });\n  return {\n    dispose: sub.unsubscribe\n  };\n}\n\nmodule.exports = requestSubscription;","/**\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 _require = require('./RelayDefaultHandleKey'),\n    DEFAULT_HANDLE_KEY = _require.DEFAULT_HANDLE_KEY;\n/**\n * @internal\n *\n * Helper to create a unique name for a handle field based on the handle name, handle key and\n * source field.\n */\n\n\nfunction getRelayHandleKey(handleName, key, fieldName) {\n  if (key && key !== DEFAULT_HANDLE_KEY) {\n    return \"__\".concat(key, \"_\").concat(handleName);\n  }\n\n  !(fieldName != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'getRelayHandleKey: Expected either `fieldName` or `key` in `handle` to be provided') : invariant(false) : void 0;\n  return \"__\".concat(fieldName, \"_\").concat(handleName);\n}\n\nmodule.exports = getRelayHandleKey;","/**\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// flowlint ambiguous-object-type:error\n'use strict';\n\nvar _require = require('./RelayConcreteNode'),\n    REQUEST = _require.REQUEST,\n    SPLIT_OPERATION = _require.SPLIT_OPERATION;\n\n/**\n * OperationLoaders can return either a NormalizationSplitOperation or\n * ConcreteRequest.\n */\nfunction getOperation(node) {\n  switch (node.kind) {\n    case REQUEST:\n      return node.operation;\n\n    case SPLIT_OPERATION:\n    default:\n      return node;\n  }\n}\n\nmodule.exports = getOperation;","/**\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 _defineProperty2 = _interopRequireDefault(require(\"@babel/runtime/helpers/defineProperty\"));\n\nvar RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar areEqual = require(\"fbjs/lib/areEqual\");\n\nvar invariant = require('invariant');\n\nvar isScalarAndEqual = require('../util/isScalarAndEqual');\n\nvar reportMissingRequiredFields = require('../util/reportMissingRequiredFields');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('../query/fetchQueryInternal'),\n    getPromiseForActiveRequest = _require.getPromiseForActiveRequest;\n\nvar _require2 = require('./RelayModernOperationDescriptor'),\n    createRequestDescriptor = _require2.createRequestDescriptor;\n\nvar _require3 = require('./RelayModernSelector'),\n    areEqualSelectors = _require3.areEqualSelectors,\n    createReaderSelector = _require3.createReaderSelector,\n    getSelectorsFromObject = _require3.getSelectorsFromObject;\n\n/**\n * A utility for resolving and subscribing to the results of a fragment spec\n * (key -> fragment mapping) given some \"props\" that determine the root ID\n * and variables to use when reading each fragment. When props are changed via\n * `setProps()`, the resolver will update its results and subscriptions\n * accordingly. Internally, the resolver:\n * - Converts the fragment map & props map into a map of `Selector`s.\n * - Removes any resolvers for any props that became null.\n * - Creates resolvers for any props that became non-null.\n * - Updates resolvers with the latest props.\n *\n * This utility is implemented as an imperative, stateful API for performance\n * reasons: reusing previous resolvers, callback functions, and subscriptions\n * all helps to reduce object allocation and thereby decrease GC time.\n *\n * The `resolve()` function is also lazy and memoized: changes in the store mark\n * the resolver as stale and notify the caller, and the actual results are\n * recomputed the first time `resolve()` is called.\n */\nvar RelayModernFragmentSpecResolver = /*#__PURE__*/function () {\n  function RelayModernFragmentSpecResolver(context, fragments, props, callback, rootIsQueryRenderer) {\n    var _this = this;\n\n    (0, _defineProperty2[\"default\"])(this, \"_onChange\", function () {\n      _this._stale = true;\n\n      if (typeof _this._callback === 'function') {\n        _this._callback();\n      }\n    });\n    this._callback = callback;\n    this._context = context;\n    this._data = {};\n    this._fragments = fragments;\n    this._props = {};\n    this._resolvers = {};\n    this._stale = false;\n    this._rootIsQueryRenderer = rootIsQueryRenderer;\n    this.setProps(props);\n  }\n\n  var _proto = RelayModernFragmentSpecResolver.prototype;\n\n  _proto.dispose = function dispose() {\n    for (var _key in this._resolvers) {\n      if (this._resolvers.hasOwnProperty(_key)) {\n        disposeCallback(this._resolvers[_key]);\n      }\n    }\n  };\n\n  _proto.resolve = function resolve() {\n    if (this._stale) {\n      // Avoid mapping the object multiple times, which could occur if data for\n      // multiple keys changes in the same event loop.\n      var prevData = this._data;\n      var nextData;\n\n      for (var _key2 in this._resolvers) {\n        if (this._resolvers.hasOwnProperty(_key2)) {\n          var resolver = this._resolvers[_key2];\n          var prevItem = prevData[_key2];\n\n          if (resolver) {\n            var nextItem = resolver.resolve();\n\n            if (nextData || nextItem !== prevItem) {\n              nextData = nextData || (0, _objectSpread2[\"default\"])({}, prevData);\n              nextData[_key2] = nextItem;\n            }\n          } else {\n            var prop = this._props[_key2];\n\n            var _nextItem = prop !== undefined ? prop : null;\n\n            if (nextData || !isScalarAndEqual(_nextItem, prevItem)) {\n              nextData = nextData || (0, _objectSpread2[\"default\"])({}, prevData);\n              nextData[_key2] = _nextItem;\n            }\n          }\n        }\n      }\n\n      this._data = nextData || prevData;\n      this._stale = false;\n    }\n\n    return this._data;\n  };\n\n  _proto.setCallback = function setCallback(callback) {\n    this._callback = callback;\n  };\n\n  _proto.setProps = function setProps(props) {\n    var ownedSelectors = getSelectorsFromObject(this._fragments, props);\n    this._props = {};\n\n    for (var _key3 in ownedSelectors) {\n      if (ownedSelectors.hasOwnProperty(_key3)) {\n        var ownedSelector = ownedSelectors[_key3];\n        var resolver = this._resolvers[_key3];\n\n        if (ownedSelector == null) {\n          if (resolver != null) {\n            resolver.dispose();\n          }\n\n          resolver = null;\n        } else if (ownedSelector.kind === 'PluralReaderSelector') {\n          if (resolver == null) {\n            resolver = new SelectorListResolver(this._context.environment, this._rootIsQueryRenderer, ownedSelector, this._onChange);\n          } else {\n            !(resolver instanceof SelectorListResolver) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernFragmentSpecResolver: Expected prop `%s` to always be an array.', _key3) : invariant(false) : void 0;\n            resolver.setSelector(ownedSelector);\n          }\n        } else {\n          if (resolver == null) {\n            resolver = new SelectorResolver(this._context.environment, this._rootIsQueryRenderer, ownedSelector, this._onChange);\n          } else {\n            !(resolver instanceof SelectorResolver) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayModernFragmentSpecResolver: Expected prop `%s` to always be an object.', _key3) : invariant(false) : void 0;\n            resolver.setSelector(ownedSelector);\n          }\n        }\n\n        this._props[_key3] = props[_key3];\n        this._resolvers[_key3] = resolver;\n      }\n    }\n\n    this._stale = true;\n  };\n\n  _proto.setVariables = function setVariables(variables, request) {\n    for (var _key4 in this._resolvers) {\n      if (this._resolvers.hasOwnProperty(_key4)) {\n        var resolver = this._resolvers[_key4];\n\n        if (resolver) {\n          resolver.setVariables(variables, request);\n        }\n      }\n    }\n\n    this._stale = true;\n  };\n\n  return RelayModernFragmentSpecResolver;\n}();\n/**\n * A resolver for a single Selector.\n */\n\n\nvar SelectorResolver = /*#__PURE__*/function () {\n  function SelectorResolver(environment, rootIsQueryRenderer, selector, callback) {\n    var _this2 = this;\n\n    (0, _defineProperty2[\"default\"])(this, \"_onChange\", function (snapshot) {\n      _this2._data = snapshot.data;\n      _this2._isMissingData = snapshot.isMissingData;\n      _this2._missingRequiredFields = snapshot.missingRequiredFields;\n\n      _this2._callback();\n    });\n\n    var _snapshot = environment.lookup(selector);\n\n    this._callback = callback;\n    this._data = _snapshot.data;\n    this._isMissingData = _snapshot.isMissingData;\n    this._missingRequiredFields = _snapshot.missingRequiredFields;\n    this._environment = environment;\n    this._rootIsQueryRenderer = rootIsQueryRenderer;\n    this._selector = selector;\n    this._subscription = environment.subscribe(_snapshot, this._onChange);\n  }\n\n  var _proto2 = SelectorResolver.prototype;\n\n  _proto2.dispose = function dispose() {\n    if (this._subscription) {\n      this._subscription.dispose();\n\n      this._subscription = null;\n    }\n  };\n\n  _proto2.resolve = function resolve() {\n    if (RelayFeatureFlags.ENABLE_RELAY_CONTAINERS_SUSPENSE === true && this._isMissingData === true) {\n      var _getPromiseForActiveR;\n\n      // NOTE: This branch exists to handle the case in which:\n      // - A RelayModern container is rendered as a descendant of a Relay Hook\n      //   root using a \"partial\" renderPolicy (this means that eargerly\n      //   reading any cached data that is available instead of blocking\n      //   at the root until the whole query is fetched).\n      // - A parent Relay Hook didnt' suspend earlier on data being fetched,\n      //   either because the fragment data for the parent was available, or\n      //   the parent fragment didn't have any data dependencies.\n      // Even though our Flow types reflect the possiblity of null data, there\n      // might still be cases where it's not handled at runtime becuase the\n      // Flow types are being ignored, or simply not being used (for example,\n      // the case reported here: https://fburl.com/srnbucf8, was due to\n      // misuse of Flow types here: https://fburl.com/g3m0mqqh).\n      // Additionally, even though the null data might be handled without a\n      // runtime error, we might not suspend when we intended to if a parent\n      // Relay Hook (e.g. that is using @defer) decided not to suspend becuase\n      // it's immediate data was already available (even if it was deferred),\n      // or it didn't actually need any data (was just spreading other fragments).\n      // This should eventually go away with something like @optional, where we only\n      // suspend at specific boundaries depending on whether the boundary\n      // can be fulfilled or not.\n      var promise = (_getPromiseForActiveR = getPromiseForActiveRequest(this._environment, this._selector.owner)) !== null && _getPromiseForActiveR !== void 0 ? _getPromiseForActiveR : this._environment.getOperationTracker().getPromiseForPendingOperationsAffectingOwner(this._selector.owner);\n\n      if (promise != null) {\n        if (this._rootIsQueryRenderer) {\n          process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Relay Container for fragment `%s` has missing data and ' + 'would suspend. When using features such as @defer or @module, ' + 'use `useFragment` instead of a Relay Container.', this._selector.node.name) : void 0;\n        } else {\n          process.env.NODE_ENV !== \"production\" ? warning(false, 'Relay: Relay Container for fragment `%s` suspended. When using ' + 'features such as @defer or @module, use `useFragment` instead ' + 'of a Relay Container.', this._selector.node.name) : void 0;\n          throw promise;\n        }\n      }\n    }\n\n    if (this._missingRequiredFields != null) {\n      reportMissingRequiredFields(this._environment, this._missingRequiredFields);\n    }\n\n    return this._data;\n  };\n\n  _proto2.setSelector = function setSelector(selector) {\n    if (this._subscription != null && areEqualSelectors(selector, this._selector)) {\n      return;\n    }\n\n    this.dispose();\n\n    var snapshot = this._environment.lookup(selector);\n\n    this._data = snapshot.data;\n    this._isMissingData = snapshot.isMissingData;\n    this._missingRequiredFields = snapshot.missingRequiredFields;\n    this._selector = selector;\n    this._subscription = this._environment.subscribe(snapshot, this._onChange);\n  };\n\n  _proto2.setVariables = function setVariables(variables, request) {\n    if (areEqual(variables, this._selector.variables)) {\n      // If we're not actually setting new variables, we don't actually want\n      // to create a new fragment owner, since areEqualSelectors relies on\n      // owner identity.\n      // In fact, we don't even need to try to attempt to set a new selector.\n      // When fragment ownership is not enabled, setSelector will also bail\n      // out since the selector doesn't really change, so we're doing it here\n      // earlier.\n      return;\n    } // NOTE: We manually create the request descriptor here instead of\n    // calling createOperationDescriptor() because we want to set a\n    // descriptor with *unaltered* variables as the fragment owner.\n    // This is a hack that allows us to preserve existing (broken)\n    // behavior of RelayModern containers while using fragment ownership\n    // to propagate variables instead of Context.\n    // For more details, see the summary of D13999308\n\n\n    var requestDescriptor = createRequestDescriptor(request, variables);\n    var selector = createReaderSelector(this._selector.node, this._selector.dataID, variables, requestDescriptor);\n    this.setSelector(selector);\n  };\n\n  return SelectorResolver;\n}();\n/**\n * A resolver for an array of Selectors.\n */\n\n\nvar SelectorListResolver = /*#__PURE__*/function () {\n  function SelectorListResolver(environment, rootIsQueryRenderer, selector, callback) {\n    var _this3 = this;\n\n    (0, _defineProperty2[\"default\"])(this, \"_onChange\", function (data) {\n      _this3._stale = true;\n\n      _this3._callback();\n    });\n    this._callback = callback;\n    this._data = [];\n    this._environment = environment;\n    this._resolvers = [];\n    this._stale = true;\n    this._rootIsQueryRenderer = rootIsQueryRenderer;\n    this.setSelector(selector);\n  }\n\n  var _proto3 = SelectorListResolver.prototype;\n\n  _proto3.dispose = function dispose() {\n    this._resolvers.forEach(disposeCallback);\n  };\n\n  _proto3.resolve = function resolve() {\n    if (this._stale) {\n      // Avoid mapping the array multiple times, which could occur if data for\n      // multiple indices changes in the same event loop.\n      var prevData = this._data;\n      var nextData;\n\n      for (var ii = 0; ii < this._resolvers.length; ii++) {\n        var prevItem = prevData[ii];\n\n        var nextItem = this._resolvers[ii].resolve();\n\n        if (nextData || nextItem !== prevItem) {\n          nextData = nextData || prevData.slice(0, ii);\n          nextData.push(nextItem);\n        }\n      }\n\n      if (!nextData && this._resolvers.length !== prevData.length) {\n        nextData = prevData.slice(0, this._resolvers.length);\n      }\n\n      this._data = nextData || prevData;\n      this._stale = false;\n    }\n\n    return this._data;\n  };\n\n  _proto3.setSelector = function setSelector(selector) {\n    var selectors = selector.selectors;\n\n    while (this._resolvers.length > selectors.length) {\n      var resolver = this._resolvers.pop();\n\n      resolver.dispose();\n    }\n\n    for (var ii = 0; ii < selectors.length; ii++) {\n      if (ii < this._resolvers.length) {\n        this._resolvers[ii].setSelector(selectors[ii]);\n      } else {\n        this._resolvers[ii] = new SelectorResolver(this._environment, this._rootIsQueryRenderer, selectors[ii], this._onChange);\n      }\n    }\n\n    this._stale = true;\n  };\n\n  _proto3.setVariables = function setVariables(variables, request) {\n    this._resolvers.forEach(function (resolver) {\n      return resolver.setVariables(variables, request);\n    });\n\n    this._stale = true;\n  };\n\n  return SelectorListResolver;\n}();\n\nfunction disposeCallback(disposable) {\n  disposable && disposable.dispose();\n}\n\nmodule.exports = RelayModernFragmentSpecResolver;","/**\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/**\n * Represents a common GraphQL request that can be executed, an `operation`\n * containing information to normalize the results, and a `fragment` derived\n * from that operation to read the response data (masking data from child\n * fragments).\n */\n\n/**\n * Contains the parameters required for executing a GraphQL request.\n * The operation can either be provided as a persisted `id` or `text`. If given\n * in `text` format, a `cacheID` as a hash of the text should be set to be used\n * for local caching.\n */\nvar RelayConcreteNode = {\n  CONDITION: 'Condition',\n  CLIENT_COMPONENT: 'ClientComponent',\n  CLIENT_EXTENSION: 'ClientExtension',\n  DEFER: 'Defer',\n  CONNECTION: 'Connection',\n  FLIGHT_FIELD: 'FlightField',\n  FRAGMENT: 'Fragment',\n  FRAGMENT_SPREAD: 'FragmentSpread',\n  INLINE_DATA_FRAGMENT_SPREAD: 'InlineDataFragmentSpread',\n  INLINE_DATA_FRAGMENT: 'InlineDataFragment',\n  INLINE_FRAGMENT: 'InlineFragment',\n  LINKED_FIELD: 'LinkedField',\n  LINKED_HANDLE: 'LinkedHandle',\n  LITERAL: 'Literal',\n  LIST_VALUE: 'ListValue',\n  LOCAL_ARGUMENT: 'LocalArgument',\n  MODULE_IMPORT: 'ModuleImport',\n  RELAY_RESOLVER: 'RelayResolver',\n  REQUIRED_FIELD: 'RequiredField',\n  OBJECT_VALUE: 'ObjectValue',\n  OPERATION: 'Operation',\n  REQUEST: 'Request',\n  ROOT_ARGUMENT: 'RootArgument',\n  SCALAR_FIELD: 'ScalarField',\n  SCALAR_HANDLE: 'ScalarHandle',\n  SPLIT_OPERATION: 'SplitOperation',\n  STREAM: 'Stream',\n  TYPE_DISCRIMINATOR: 'TypeDiscriminator',\n  VARIABLE: 'Variable'\n};\nmodule.exports = RelayConcreteNode;","/**\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 _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\n\nvar RelayConcreteNode = require('../util/RelayConcreteNode');\n\nvar getRelayHandleKey = require('../util/getRelayHandleKey');\n\nvar invariant = require('invariant');\n\nvar stableCopy = require('../util/stableCopy');\n\nvar VARIABLE = RelayConcreteNode.VARIABLE,\n    LITERAL = RelayConcreteNode.LITERAL,\n    OBJECT_VALUE = RelayConcreteNode.OBJECT_VALUE,\n    LIST_VALUE = RelayConcreteNode.LIST_VALUE;\nvar MODULE_COMPONENT_KEY_PREFIX = '__module_component_';\nvar MODULE_OPERATION_KEY_PREFIX = '__module_operation_';\n\nfunction getArgumentValue(arg, variables) {\n  if (arg.kind === VARIABLE) {\n    // Variables are provided at runtime and are not guaranteed to be stable.\n    return getStableVariableValue(arg.variableName, variables);\n  } else if (arg.kind === LITERAL) {\n    // The Relay compiler generates stable ConcreteArgument values.\n    return arg.value;\n  } else if (arg.kind === OBJECT_VALUE) {\n    var value = {};\n    arg.fields.forEach(function (field) {\n      value[field.name] = getArgumentValue(field, variables);\n    });\n    return value;\n  } else if (arg.kind === LIST_VALUE) {\n    var _value = [];\n    arg.items.forEach(function (item) {\n      item != null ? _value.push(getArgumentValue(item, variables)) : null;\n    });\n    return _value;\n  }\n}\n/**\n * Returns the values of field/fragment arguments as an object keyed by argument\n * names. Guaranteed to return a result with stable ordered nested values.\n */\n\n\nfunction getArgumentValues(args, variables) {\n  var values = {};\n  args.forEach(function (arg) {\n    values[arg.name] = getArgumentValue(arg, variables);\n  });\n  return values;\n}\n/**\n * Given a handle field and variable values, returns a key that can be used to\n * uniquely identify the combination of the handle name and argument values.\n *\n * Note: the word \"storage\" here refers to the fact this key is primarily used\n * when writing the results of a key in a normalized graph or \"store\". This\n * name was used in previous implementations of Relay internals and is also\n * used here for consistency.\n */\n\n\nfunction getHandleStorageKey(handleField, variables) {\n  var dynamicKey = handleField.dynamicKey,\n      handle = handleField.handle,\n      key = handleField.key,\n      name = handleField.name,\n      args = handleField.args,\n      filters = handleField.filters;\n  var handleName = getRelayHandleKey(handle, key, name);\n  var filterArgs = null;\n\n  if (args && filters && args.length !== 0 && filters.length !== 0) {\n    filterArgs = args.filter(function (arg) {\n      return filters.indexOf(arg.name) > -1;\n    });\n  }\n\n  if (dynamicKey) {\n    // \"Sort\" the arguments by argument name: this is done by the compiler for\n    // user-supplied arguments but the dynamic argument must also be in sorted\n    // order.  Note that dynamic key argument name is double-underscore-\n    // -prefixed, and a double-underscore prefix is disallowed for user-supplied\n    // argument names, so there's no need to actually sort.\n    filterArgs = filterArgs != null ? [dynamicKey].concat((0, _toConsumableArray2[\"default\"])(filterArgs)) : [dynamicKey];\n  }\n\n  if (filterArgs === null) {\n    return handleName;\n  } else {\n    return formatStorageKey(handleName, getArgumentValues(filterArgs, variables));\n  }\n}\n/**\n * Given a field and variable values, returns a key that can be used to\n * uniquely identify the combination of the field name and argument values.\n *\n * Note: the word \"storage\" here refers to the fact this key is primarily used\n * when writing the results of a key in a normalized graph or \"store\". This\n * name was used in previous implementations of Relay internals and is also\n * used here for consistency.\n */\n\n\nfunction getStorageKey(field, variables) {\n  if (field.storageKey) {\n    // TODO T23663664: Handle nodes do not yet define a static storageKey.\n    return field.storageKey;\n  }\n\n  var args = field.args,\n      name = field.name;\n  return args && args.length !== 0 ? formatStorageKey(name, getArgumentValues(args, variables)) : name;\n}\n/**\n * Given a `name` (eg. \"foo\") and an object representing argument values\n * (eg. `{orberBy: \"name\", first: 10}`) returns a unique storage key\n * (ie. `foo{\"first\":10,\"orderBy\":\"name\"}`).\n *\n * This differs from getStorageKey which requires a ConcreteNode where arguments\n * are assumed to already be sorted into a stable order.\n */\n\n\nfunction getStableStorageKey(name, args) {\n  return formatStorageKey(name, stableCopy(args));\n}\n/**\n * Given a name and argument values, format a storage key.\n *\n * Arguments and the values within them are expected to be ordered in a stable\n * alphabetical ordering.\n */\n\n\nfunction formatStorageKey(name, argValues) {\n  if (!argValues) {\n    return name;\n  }\n\n  var values = [];\n\n  for (var argName in argValues) {\n    if (argValues.hasOwnProperty(argName)) {\n      var value = argValues[argName];\n\n      if (value != null) {\n        var _JSON$stringify;\n\n        values.push(argName + ':' + ((_JSON$stringify = JSON.stringify(value)) !== null && _JSON$stringify !== void 0 ? _JSON$stringify : 'undefined'));\n      }\n    }\n  }\n\n  return values.length === 0 ? name : name + \"(\".concat(values.join(','), \")\");\n}\n/**\n * Given Variables and a variable name, return a variable value with\n * all values in a stable order.\n */\n\n\nfunction getStableVariableValue(name, variables) {\n  !variables.hasOwnProperty(name) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'getVariableValue(): Undefined variable `%s`.', name) : invariant(false) : void 0; // $FlowFixMe[cannot-write]\n\n  return stableCopy(variables[name]);\n}\n\nfunction getModuleComponentKey(documentName) {\n  return \"\".concat(MODULE_COMPONENT_KEY_PREFIX).concat(documentName);\n}\n\nfunction getModuleOperationKey(documentName) {\n  return \"\".concat(MODULE_OPERATION_KEY_PREFIX).concat(documentName);\n}\n/**\n * Constants shared by all implementations of RecordSource/MutableRecordSource/etc.\n */\n\n\nvar RelayStoreUtils = {\n  FRAGMENTS_KEY: '__fragments',\n  FRAGMENT_OWNER_KEY: '__fragmentOwner',\n  FRAGMENT_PROP_NAME_KEY: '__fragmentPropName',\n  MODULE_COMPONENT_KEY: '__module_component',\n  // alias returned by Reader\n  ID_KEY: '__id',\n  REF_KEY: '__ref',\n  REFS_KEY: '__refs',\n  ROOT_ID: 'client:root',\n  ROOT_TYPE: '__Root',\n  TYPENAME_KEY: '__typename',\n  INVALIDATED_AT_KEY: '__invalidated_at',\n  IS_WITHIN_UNMATCHED_TYPE_REFINEMENT: '__isWithinUnmatchedTypeRefinement',\n  formatStorageKey: formatStorageKey,\n  getArgumentValue: getArgumentValue,\n  getArgumentValues: getArgumentValues,\n  getHandleStorageKey: getHandleStorageKey,\n  getStorageKey: getStorageKey,\n  getStableStorageKey: getStableStorageKey,\n  getModuleComponentKey: getModuleComponentKey,\n  getModuleOperationKey: getModuleOperationKey\n};\nmodule.exports = RelayStoreUtils;","/**\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 _require = require('../store/RelayStoreUtils'),\n    getStorageKey = _require.getStorageKey,\n    ROOT_TYPE = _require.ROOT_TYPE;\n\n/**\n * @internal\n *\n * A subclass of RecordSourceProxy that provides convenience methods for\n * accessing the root fields of a given query/mutation. These fields accept\n * complex arguments and it can be tedious to re-construct the correct sets of\n * arguments to pass to e.g. `getRoot().getLinkedRecord()`.\n */\nvar RelayRecordSourceSelectorProxy = /*#__PURE__*/function () {\n  function RelayRecordSourceSelectorProxy(mutator, recordSource, readSelector) {\n    this.__mutator = mutator;\n    this.__recordSource = recordSource;\n    this._readSelector = readSelector;\n  }\n\n  var _proto = RelayRecordSourceSelectorProxy.prototype;\n\n  _proto.create = function create(dataID, typeName) {\n    return this.__recordSource.create(dataID, typeName);\n  };\n\n  _proto[\"delete\"] = function _delete(dataID) {\n    this.__recordSource[\"delete\"](dataID);\n  };\n\n  _proto.get = function get(dataID) {\n    return this.__recordSource.get(dataID);\n  };\n\n  _proto.getRoot = function getRoot() {\n    return this.__recordSource.getRoot();\n  };\n\n  _proto.getOperationRoot = function getOperationRoot() {\n    var root = this.__recordSource.get(this._readSelector.dataID);\n\n    if (!root) {\n      root = this.__recordSource.create(this._readSelector.dataID, ROOT_TYPE);\n    }\n\n    return root;\n  };\n\n  _proto._getRootField = function _getRootField(selector, fieldName, plural) {\n    var field = selector.node.selections.find(function (selection) {\n      return selection.kind === 'LinkedField' && selection.name === fieldName;\n    });\n    !(field && field.kind === 'LinkedField') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordSourceSelectorProxy#getRootField(): Cannot find root ' + 'field `%s`, no such field is defined on GraphQL document `%s`.', fieldName, selector.node.name) : invariant(false) : void 0;\n    !(field.plural === plural) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayRecordSourceSelectorProxy#getRootField(): Expected root field ' + '`%s` to be %s.', fieldName, plural ? 'plural' : 'singular') : invariant(false) : void 0;\n    return field;\n  };\n\n  _proto.getRootField = function getRootField(fieldName) {\n    var field = this._getRootField(this._readSelector, fieldName, false);\n\n    var storageKey = getStorageKey(field, this._readSelector.variables);\n    return this.getOperationRoot().getLinkedRecord(storageKey);\n  };\n\n  _proto.getPluralRootField = function getPluralRootField(fieldName) {\n    var field = this._getRootField(this._readSelector, fieldName, true);\n\n    var storageKey = getStorageKey(field, this._readSelector.variables);\n    return this.getOperationRoot().getLinkedRecords(storageKey);\n  };\n\n  _proto.invalidateStore = function invalidateStore() {\n    this.__recordSource.invalidateStore();\n  };\n\n  return RelayRecordSourceSelectorProxy;\n}();\n\nmodule.exports = RelayRecordSourceSelectorProxy;","/**\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 _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar _toConsumableArray2 = _interopRequireDefault(require(\"@babel/runtime/helpers/toConsumableArray\"));\n\nvar RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar RelayModernRecord = require('./RelayModernRecord');\n\nvar areEqual = require(\"fbjs/lib/areEqual\");\n\nvar invariant = require('invariant');\n\nvar warning = require(\"fbjs/lib/warning\");\n\nvar _require = require('../util/RelayConcreteNode'),\n    CONDITION = _require.CONDITION,\n    CLIENT_COMPONENT = _require.CLIENT_COMPONENT,\n    CLIENT_EXTENSION = _require.CLIENT_EXTENSION,\n    DEFER = _require.DEFER,\n    FLIGHT_FIELD = _require.FLIGHT_FIELD,\n    FRAGMENT_SPREAD = _require.FRAGMENT_SPREAD,\n    INLINE_FRAGMENT = _require.INLINE_FRAGMENT,\n    LINKED_FIELD = _require.LINKED_FIELD,\n    LINKED_HANDLE = _require.LINKED_HANDLE,\n    MODULE_IMPORT = _require.MODULE_IMPORT,\n    SCALAR_FIELD = _require.SCALAR_FIELD,\n    SCALAR_HANDLE = _require.SCALAR_HANDLE,\n    STREAM = _require.STREAM,\n    TYPE_DISCRIMINATOR = _require.TYPE_DISCRIMINATOR;\n\nvar _require2 = require('./ClientID'),\n    generateClientID = _require2.generateClientID,\n    isClientID = _require2.isClientID;\n\nvar _require3 = require('./RelayModernSelector'),\n    createNormalizationSelector = _require3.createNormalizationSelector;\n\nvar _require4 = require('./RelayStoreReactFlightUtils'),\n    refineToReactFlightPayloadData = _require4.refineToReactFlightPayloadData,\n    REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY = _require4.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY,\n    REACT_FLIGHT_TREE_STORAGE_KEY = _require4.REACT_FLIGHT_TREE_STORAGE_KEY,\n    REACT_FLIGHT_TYPE_NAME = _require4.REACT_FLIGHT_TYPE_NAME;\n\nvar _require5 = require('./RelayStoreUtils'),\n    getArgumentValues = _require5.getArgumentValues,\n    getHandleStorageKey = _require5.getHandleStorageKey,\n    getModuleComponentKey = _require5.getModuleComponentKey,\n    getModuleOperationKey = _require5.getModuleOperationKey,\n    getStorageKey = _require5.getStorageKey,\n    TYPENAME_KEY = _require5.TYPENAME_KEY,\n    ROOT_ID = _require5.ROOT_ID,\n    ROOT_TYPE = _require5.ROOT_TYPE;\n\nvar _require6 = require('./TypeID'),\n    generateTypeID = _require6.generateTypeID,\n    TYPE_SCHEMA_TYPE = _require6.TYPE_SCHEMA_TYPE;\n\n/**\n * Normalizes the results of a query and standard GraphQL response, writing the\n * normalized records/fields into the given MutableRecordSource.\n */\nfunction normalize(recordSource, selector, response, options) {\n  var dataID = selector.dataID,\n      node = selector.node,\n      variables = selector.variables;\n  var normalizer = new RelayResponseNormalizer(recordSource, variables, options);\n  return normalizer.normalizeResponse(node, dataID, response);\n}\n/**\n * @private\n *\n * Helper for handling payloads.\n */\n\n\nvar RelayResponseNormalizer = /*#__PURE__*/function () {\n  function RelayResponseNormalizer(recordSource, variables, options) {\n    this._getDataId = options.getDataID;\n    this._handleFieldPayloads = [];\n    this._treatMissingFieldsAsNull = options.treatMissingFieldsAsNull;\n    this._incrementalPlaceholders = [];\n    this._isClientExtension = false;\n    this._isUnmatchedAbstractType = false;\n    this._moduleImportPayloads = [];\n    this._path = options.path ? (0, _toConsumableArray2[\"default\"])(options.path) : [];\n    this._recordSource = recordSource;\n    this._variables = variables;\n    this._reactFlightPayloadDeserializer = options.reactFlightPayloadDeserializer;\n    this._reactFlightServerErrorHandler = options.reactFlightServerErrorHandler;\n    this._shouldProcessClientComponents = options.shouldProcessClientComponents;\n  }\n\n  var _proto = RelayResponseNormalizer.prototype;\n\n  _proto.normalizeResponse = function normalizeResponse(node, dataID, data) {\n    var record = this._recordSource.get(dataID);\n\n    !record ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer(): Expected root record `%s` to exist.', dataID) : invariant(false) : void 0;\n\n    this._traverseSelections(node, record, data);\n\n    return {\n      errors: null,\n      fieldPayloads: this._handleFieldPayloads,\n      incrementalPlaceholders: this._incrementalPlaceholders,\n      moduleImportPayloads: this._moduleImportPayloads,\n      source: this._recordSource,\n      isFinal: false\n    };\n  };\n\n  _proto._getVariableValue = function _getVariableValue(name) {\n    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer(): Undefined variable `%s`.', name) : invariant(false) : void 0; // $FlowFixMe[cannot-write]\n\n    return this._variables[name];\n  };\n\n  _proto._getRecordType = function _getRecordType(data) {\n    var typeName = data[TYPENAME_KEY];\n    !(typeName != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer(): Expected a typename for record `%s`.', JSON.stringify(data, null, 2)) : invariant(false) : void 0;\n    return typeName;\n  };\n\n  _proto._traverseSelections = function _traverseSelections(node, record, data) {\n    for (var i = 0; i < node.selections.length; i++) {\n      var selection = node.selections[i];\n\n      switch (selection.kind) {\n        case SCALAR_FIELD:\n        case LINKED_FIELD:\n          this._normalizeField(node, selection, record, data);\n\n          break;\n\n        case CONDITION:\n          var conditionValue = this._getVariableValue(selection.condition);\n\n          if (conditionValue === selection.passingValue) {\n            this._traverseSelections(selection, record, data);\n          }\n\n          break;\n\n        case FRAGMENT_SPREAD:\n          {\n            this._traverseSelections(selection.fragment, record, data);\n\n            break;\n          }\n\n        case INLINE_FRAGMENT:\n          {\n            var abstractKey = selection.abstractKey;\n\n            if (abstractKey == null) {\n              var _typeName = RelayModernRecord.getType(record);\n\n              if (_typeName === selection.type) {\n                this._traverseSelections(selection, record, data);\n              }\n            } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {\n              var implementsInterface = data.hasOwnProperty(abstractKey);\n\n              var _typeName2 = RelayModernRecord.getType(record);\n\n              var typeID = generateTypeID(_typeName2);\n\n              var typeRecord = this._recordSource.get(typeID);\n\n              if (typeRecord == null) {\n                typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);\n\n                this._recordSource.set(typeID, typeRecord);\n              }\n\n              RelayModernRecord.setValue(typeRecord, abstractKey, implementsInterface);\n\n              if (implementsInterface) {\n                this._traverseSelections(selection, record, data);\n              }\n            } else {\n              // legacy behavior for abstract refinements: always normalize even\n              // if the type doesn't conform, but track if the type matches or not\n              // for determining whether response fields are expected to be present\n              var _implementsInterface = data.hasOwnProperty(abstractKey);\n\n              var parentIsUnmatchedAbstractType = this._isUnmatchedAbstractType;\n              this._isUnmatchedAbstractType = this._isUnmatchedAbstractType || !_implementsInterface;\n\n              this._traverseSelections(selection, record, data);\n\n              this._isUnmatchedAbstractType = parentIsUnmatchedAbstractType;\n            }\n\n            break;\n          }\n\n        case TYPE_DISCRIMINATOR:\n          {\n            if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {\n              var _abstractKey = selection.abstractKey;\n\n              var _implementsInterface2 = data.hasOwnProperty(_abstractKey);\n\n              var _typeName3 = RelayModernRecord.getType(record);\n\n              var _typeID = generateTypeID(_typeName3);\n\n              var _typeRecord = this._recordSource.get(_typeID);\n\n              if (_typeRecord == null) {\n                _typeRecord = RelayModernRecord.create(_typeID, TYPE_SCHEMA_TYPE);\n\n                this._recordSource.set(_typeID, _typeRecord);\n              }\n\n              RelayModernRecord.setValue(_typeRecord, _abstractKey, _implementsInterface2);\n            }\n\n            break;\n          }\n\n        case LINKED_HANDLE:\n        case SCALAR_HANDLE:\n          var args = selection.args ? getArgumentValues(selection.args, this._variables) : {};\n          var fieldKey = getStorageKey(selection, this._variables);\n          var handleKey = getHandleStorageKey(selection, this._variables);\n\n          this._handleFieldPayloads.push({\n            args: args,\n            dataID: RelayModernRecord.getDataID(record),\n            fieldKey: fieldKey,\n            handle: selection.handle,\n            handleKey: handleKey,\n            handleArgs: selection.handleArgs ? getArgumentValues(selection.handleArgs, this._variables) : {}\n          });\n\n          break;\n\n        case MODULE_IMPORT:\n          this._normalizeModuleImport(node, selection, record, data);\n\n          break;\n\n        case DEFER:\n          this._normalizeDefer(selection, record, data);\n\n          break;\n\n        case STREAM:\n          this._normalizeStream(selection, record, data);\n\n          break;\n\n        case CLIENT_EXTENSION:\n          var isClientExtension = this._isClientExtension;\n          this._isClientExtension = true;\n\n          this._traverseSelections(selection, record, data);\n\n          this._isClientExtension = isClientExtension;\n          break;\n\n        case CLIENT_COMPONENT:\n          if (this._shouldProcessClientComponents === false) {\n            break;\n          }\n\n          this._traverseSelections(selection.fragment, record, data);\n\n          break;\n\n        case FLIGHT_FIELD:\n          if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {\n            this._normalizeFlightField(node, selection, record, data);\n          } else {\n            throw new Error('Flight fields are not yet supported.');\n          }\n\n          break;\n\n        default:\n          selection;\n          !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer(): Unexpected ast kind `%s`.', selection.kind) : invariant(false) : void 0;\n      }\n    }\n  };\n\n  _proto._normalizeDefer = function _normalizeDefer(defer, record, data) {\n    var isDeferred = defer[\"if\"] === null || this._getVariableValue(defer[\"if\"]);\n\n    if (process.env.NODE_ENV !== \"production\") {\n      process.env.NODE_ENV !== \"production\" ? warning(typeof isDeferred === 'boolean', 'RelayResponseNormalizer: Expected value for @defer `if` argument to ' + 'be a boolean, got `%s`.', isDeferred) : void 0;\n    }\n\n    if (isDeferred === false) {\n      // If defer is disabled there will be no additional response chunk:\n      // normalize the data already present.\n      this._traverseSelections(defer, record, data);\n    } else {\n      // Otherwise data *for this selection* should not be present: enqueue\n      // metadata to process the subsequent response chunk.\n      this._incrementalPlaceholders.push({\n        kind: 'defer',\n        data: data,\n        label: defer.label,\n        path: (0, _toConsumableArray2[\"default\"])(this._path),\n        selector: createNormalizationSelector(defer, RelayModernRecord.getDataID(record), this._variables),\n        typeName: RelayModernRecord.getType(record)\n      });\n    }\n  };\n\n  _proto._normalizeStream = function _normalizeStream(stream, record, data) {\n    // Always normalize regardless of whether streaming is enabled or not,\n    // this populates the initial array value (including any items when\n    // initial_count > 0).\n    this._traverseSelections(stream, record, data);\n\n    var isStreamed = stream[\"if\"] === null || this._getVariableValue(stream[\"if\"]);\n\n    if (process.env.NODE_ENV !== \"production\") {\n      process.env.NODE_ENV !== \"production\" ? warning(typeof isStreamed === 'boolean', 'RelayResponseNormalizer: Expected value for @stream `if` argument ' + 'to be a boolean, got `%s`.', isStreamed) : void 0;\n    }\n\n    if (isStreamed === true) {\n      // If streaming is enabled, *also* emit metadata to process any\n      // response chunks that may be delivered.\n      this._incrementalPlaceholders.push({\n        kind: 'stream',\n        label: stream.label,\n        path: (0, _toConsumableArray2[\"default\"])(this._path),\n        parentID: RelayModernRecord.getDataID(record),\n        node: stream,\n        variables: this._variables\n      });\n    }\n  };\n\n  _proto._normalizeModuleImport = function _normalizeModuleImport(parent, moduleImport, record, data) {\n    !(typeof data === 'object' && data) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer: Expected data for @module to be an object.') : invariant(false) : void 0;\n    var typeName = RelayModernRecord.getType(record);\n    var componentKey = getModuleComponentKey(moduleImport.documentName);\n    var componentReference = data[componentKey];\n    RelayModernRecord.setValue(record, componentKey, componentReference !== null && componentReference !== void 0 ? componentReference : null);\n    var operationKey = getModuleOperationKey(moduleImport.documentName);\n    var operationReference = data[operationKey];\n    RelayModernRecord.setValue(record, operationKey, operationReference !== null && operationReference !== void 0 ? operationReference : null);\n\n    if (operationReference != null) {\n      this._moduleImportPayloads.push({\n        data: data,\n        dataID: RelayModernRecord.getDataID(record),\n        operationReference: operationReference,\n        path: (0, _toConsumableArray2[\"default\"])(this._path),\n        typeName: typeName,\n        variables: this._variables\n      });\n    }\n  };\n\n  _proto._normalizeField = function _normalizeField(parent, selection, record, data) {\n    !(typeof data === 'object' && data) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'writeField(): Expected data for field `%s` to be an object.', selection.name) : invariant(false) : void 0;\n    var responseKey = selection.alias || selection.name;\n    var storageKey = getStorageKey(selection, this._variables);\n    var fieldValue = data[responseKey];\n\n    if (fieldValue == null) {\n      if (fieldValue === undefined) {\n        // Fields may be missing in the response in two main cases:\n        // - Inside a client extension: the server will not generally return\n        //   values for these fields, but a local update may provide them.\n        // - Inside an abstract type refinement where the concrete type does\n        //   not conform to the interface/union.\n        // However an otherwise-required field may also be missing if the server\n        // is configured to skip fields with `null` values, in which case the\n        // client is assumed to be correctly configured with\n        // treatMissingFieldsAsNull=true.\n        var isOptionalField = this._isClientExtension || this._isUnmatchedAbstractType;\n\n        if (isOptionalField) {\n          // Field not expected to exist regardless of whether the server is pruning null\n          // fields or not.\n          return;\n        } else if (!this._treatMissingFieldsAsNull) {\n          // Not optional and the server is not pruning null fields: field is expected\n          // to be present\n          if (process.env.NODE_ENV !== \"production\") {\n            process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayResponseNormalizer: Payload did not contain a value ' + 'for field `%s: %s`. Check that you are parsing with the same ' + 'query that was used to fetch the payload.', responseKey, storageKey) : void 0;\n          }\n\n          return;\n        }\n      }\n\n      if (process.env.NODE_ENV !== \"production\") {\n        if (selection.kind === SCALAR_FIELD) {\n          this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);\n        }\n      }\n\n      RelayModernRecord.setValue(record, storageKey, null);\n      return;\n    }\n\n    if (selection.kind === SCALAR_FIELD) {\n      if (process.env.NODE_ENV !== \"production\") {\n        this._validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue);\n      }\n\n      RelayModernRecord.setValue(record, storageKey, fieldValue);\n    } else if (selection.kind === LINKED_FIELD) {\n      this._path.push(responseKey);\n\n      if (selection.plural) {\n        this._normalizePluralLink(selection, record, storageKey, fieldValue);\n      } else {\n        this._normalizeLink(selection, record, storageKey, fieldValue);\n      }\n\n      this._path.pop();\n    } else {\n      selection;\n      !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer(): Unexpected ast kind `%s` during normalization.', selection.kind) : invariant(false) : void 0;\n    }\n  };\n\n  _proto._normalizeFlightField = function _normalizeFlightField(parent, selection, record, data) {\n    var responseKey = selection.alias || selection.name;\n    var storageKey = getStorageKey(selection, this._variables);\n    var fieldValue = data[responseKey];\n\n    if (fieldValue == null) {\n      if (fieldValue === undefined) {\n        // Flight field may be missing in the response if:\n        // - It is inside an abstract type refinement where the concrete type does\n        //   not conform to the interface/union.\n        // However an otherwise-required field may also be missing if the server\n        // is configured to skip fields with `null` values, in which case the\n        // client is assumed to be correctly configured with\n        // treatMissingFieldsAsNull=true.\n        if (this._isUnmatchedAbstractType) {\n          // Field not expected to exist regardless of whether the server is pruning null\n          // fields or not.\n          return;\n        } else if (!this._treatMissingFieldsAsNull) {\n          // Not optional and the server is not pruning null fields: field is expected\n          // to be present\n          if (process.env.NODE_ENV !== \"production\") {\n            process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayResponseNormalizer: Payload did not contain a value ' + 'for field `%s: %s`. Check that you are parsing with the same ' + 'query that was used to fetch the payload.', responseKey, storageKey) : void 0;\n          }\n\n          return;\n        }\n      }\n\n      RelayModernRecord.setValue(record, storageKey, null);\n      return;\n    }\n\n    var reactFlightPayload = refineToReactFlightPayloadData(fieldValue);\n    var reactFlightPayloadDeserializer = this._reactFlightPayloadDeserializer;\n    !(reactFlightPayload != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer: Expected React Flight payload data to be an ' + 'object with `status`, tree`, `queries` and `errors` properties, got ' + '`%s`.', fieldValue) : invariant(false) : void 0;\n    !(typeof reactFlightPayloadDeserializer === 'function') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer: Expected reactFlightPayloadDeserializer to ' + 'be a function, got `%s`.', reactFlightPayloadDeserializer) : invariant(false) : void 0;\n\n    if (reactFlightPayload.errors.length > 0) {\n      if (typeof this._reactFlightServerErrorHandler === 'function') {\n        this._reactFlightServerErrorHandler(reactFlightPayload.status, reactFlightPayload.errors);\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayResponseNormalizer: Received server errors for field `%s`.\\n\\n' + '%s\\n%s', responseKey, reactFlightPayload.errors[0].message, reactFlightPayload.errors[0].stack) : void 0;\n      }\n    }\n\n    var reactFlightID = generateClientID(RelayModernRecord.getDataID(record), getStorageKey(selection, this._variables));\n\n    var reactFlightClientResponseRecord = this._recordSource.get(reactFlightID);\n\n    if (reactFlightClientResponseRecord == null) {\n      reactFlightClientResponseRecord = RelayModernRecord.create(reactFlightID, REACT_FLIGHT_TYPE_NAME);\n\n      this._recordSource.set(reactFlightID, reactFlightClientResponseRecord);\n    }\n\n    if (reactFlightPayload.tree == null) {\n      // This typically indicates that a fatal server error prevented rows from\n      // being written. When this occurs, we should not continue normalization of\n      // the Flight field because the row response is malformed.\n      //\n      // Receiving empty rows is OK because it can indicate the start of a stream.\n      process.env.NODE_ENV !== \"production\" ? warning(false, 'RelayResponseNormalizer: Expected `tree` not to be null. This ' + 'typically indicates that a fatal server error prevented any Server ' + 'Component rows from being written.') : void 0; // We create the flight record with a null value for the tree\n      // and empty reachable definitions\n\n      RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_TREE_STORAGE_KEY, null);\n      RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY, []);\n      RelayModernRecord.setLinkedRecordID(record, storageKey, reactFlightID);\n      return;\n    } // We store the deserialized reactFlightClientResponse in a separate\n    // record and link it to the parent record. This is so we can GC the Flight\n    // tree later even if the parent record is still reachable.\n\n\n    var reactFlightClientResponse = reactFlightPayloadDeserializer(reactFlightPayload.tree);\n    RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_TREE_STORAGE_KEY, reactFlightClientResponse);\n    var reachableExecutableDefinitions = [];\n\n    var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(reactFlightPayload.queries),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var query = _step.value;\n\n        if (query.response.data != null) {\n          this._moduleImportPayloads.push({\n            data: query.response.data,\n            dataID: ROOT_ID,\n            operationReference: query.module,\n            path: [],\n            typeName: ROOT_TYPE,\n            variables: query.variables\n          });\n        }\n\n        reachableExecutableDefinitions.push({\n          module: query.module,\n          variables: query.variables\n        });\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n\n    var _iterator2 = (0, _createForOfIteratorHelper2[\"default\"])(reactFlightPayload.fragments),\n        _step2;\n\n    try {\n      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n        var fragment = _step2.value;\n\n        if (fragment.response.data != null) {\n          this._moduleImportPayloads.push({\n            data: fragment.response.data,\n            dataID: fragment.__id,\n            operationReference: fragment.module,\n            path: [],\n            typeName: fragment.__typename,\n            variables: fragment.variables\n          });\n        }\n\n        reachableExecutableDefinitions.push({\n          module: fragment.module,\n          variables: fragment.variables\n        });\n      }\n    } catch (err) {\n      _iterator2.e(err);\n    } finally {\n      _iterator2.f();\n    }\n\n    RelayModernRecord.setValue(reactFlightClientResponseRecord, REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY, reachableExecutableDefinitions);\n    RelayModernRecord.setLinkedRecordID(record, storageKey, reactFlightID);\n  };\n\n  _proto._normalizeLink = function _normalizeLink(field, record, storageKey, fieldValue) {\n    var _field$concreteType;\n\n    !(typeof fieldValue === 'object' && fieldValue) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer: Expected data for field `%s` to be an object.', storageKey) : invariant(false) : void 0;\n    var nextID = this._getDataId( // $FlowFixMe[incompatible-variance]\n    fieldValue, // $FlowFixMe[incompatible-variance]\n    (_field$concreteType = field.concreteType) !== null && _field$concreteType !== void 0 ? _field$concreteType : this._getRecordType(fieldValue)) || // Reuse previously generated client IDs\n    RelayModernRecord.getLinkedRecordID(record, storageKey) || generateClientID(RelayModernRecord.getDataID(record), storageKey);\n    !(typeof nextID === 'string') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer: Expected id on field `%s` to be a string.', storageKey) : invariant(false) : void 0;\n\n    if (process.env.NODE_ENV !== \"production\") {\n      this._validateConflictingLinkedFieldsWithIdenticalId(record, RelayModernRecord.getLinkedRecordID(record, storageKey), nextID, storageKey);\n    }\n\n    RelayModernRecord.setLinkedRecordID(record, storageKey, nextID);\n\n    var nextRecord = this._recordSource.get(nextID);\n\n    if (!nextRecord) {\n      // $FlowFixMe[incompatible-variance]\n      var _typeName4 = field.concreteType || this._getRecordType(fieldValue);\n\n      nextRecord = RelayModernRecord.create(nextID, _typeName4);\n\n      this._recordSource.set(nextID, nextRecord);\n    } else if (process.env.NODE_ENV !== \"production\") {\n      this._validateRecordType(nextRecord, field, fieldValue);\n    } // $FlowFixMe[incompatible-variance]\n\n\n    this._traverseSelections(field, nextRecord, fieldValue);\n  };\n\n  _proto._normalizePluralLink = function _normalizePluralLink(field, record, storageKey, fieldValue) {\n    var _this = this;\n\n    !Array.isArray(fieldValue) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer: Expected data for field `%s` to be an array ' + 'of objects.', storageKey) : invariant(false) : void 0;\n    var prevIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);\n    var nextIDs = [];\n    fieldValue.forEach(function (item, nextIndex) {\n      var _field$concreteType2;\n\n      // validate response data\n      if (item == null) {\n        nextIDs.push(item);\n        return;\n      }\n\n      _this._path.push(String(nextIndex));\n\n      !(typeof item === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer: Expected elements for field `%s` to be ' + 'objects.', storageKey) : invariant(false) : void 0;\n      var nextID = _this._getDataId( // $FlowFixMe[incompatible-variance]\n      item, // $FlowFixMe[incompatible-variance]\n      (_field$concreteType2 = field.concreteType) !== null && _field$concreteType2 !== void 0 ? _field$concreteType2 : _this._getRecordType(item)) || prevIDs && prevIDs[nextIndex] || // Reuse previously generated client IDs:\n      generateClientID(RelayModernRecord.getDataID(record), storageKey, nextIndex);\n      !(typeof nextID === 'string') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayResponseNormalizer: Expected id of elements of field `%s` to ' + 'be strings.', storageKey) : invariant(false) : void 0;\n      nextIDs.push(nextID);\n\n      var nextRecord = _this._recordSource.get(nextID);\n\n      if (!nextRecord) {\n        // $FlowFixMe[incompatible-variance]\n        var _typeName5 = field.concreteType || _this._getRecordType(item);\n\n        nextRecord = RelayModernRecord.create(nextID, _typeName5);\n\n        _this._recordSource.set(nextID, nextRecord);\n      } else if (process.env.NODE_ENV !== \"production\") {\n        _this._validateRecordType(nextRecord, field, item);\n      } // NOTE: the check to strip __DEV__ code only works for simple\n      // `if (__DEV__)`\n\n\n      if (process.env.NODE_ENV !== \"production\") {\n        if (prevIDs) {\n          _this._validateConflictingLinkedFieldsWithIdenticalId(record, prevIDs[nextIndex], nextID, storageKey);\n        }\n      } // $FlowFixMe[incompatible-variance]\n\n\n      _this._traverseSelections(field, nextRecord, item);\n\n      _this._path.pop();\n    });\n    RelayModernRecord.setLinkedRecordIDs(record, storageKey, nextIDs);\n  }\n  /**\n   * Warns if the type of the record does not match the type of the field/payload.\n   */\n  ;\n\n  _proto._validateRecordType = function _validateRecordType(record, field, payload) {\n    var _field$concreteType3;\n\n    var typeName = (_field$concreteType3 = field.concreteType) !== null && _field$concreteType3 !== void 0 ? _field$concreteType3 : this._getRecordType(payload);\n    var dataID = RelayModernRecord.getDataID(record);\n    process.env.NODE_ENV !== \"production\" ? warning(isClientID(dataID) && dataID !== ROOT_ID || RelayModernRecord.getType(record) === typeName, 'RelayResponseNormalizer: Invalid record `%s`. Expected %s to be ' + 'consistent, but the record was assigned conflicting types `%s` ' + 'and `%s`. The GraphQL server likely violated the globally unique ' + 'id requirement by returning the same id for different objects.', dataID, TYPENAME_KEY, RelayModernRecord.getType(record), typeName) : void 0;\n  }\n  /**\n   * Warns if a single response contains conflicting fields with the same id\n   */\n  ;\n\n  _proto._validateConflictingFieldsWithIdenticalId = function _validateConflictingFieldsWithIdenticalId(record, storageKey, fieldValue) {\n    // NOTE: Only call this function in DEV\n    if (process.env.NODE_ENV !== \"production\") {\n      var dataID = RelayModernRecord.getDataID(record);\n      var previousValue = RelayModernRecord.getValue(record, storageKey);\n      process.env.NODE_ENV !== \"production\" ? warning(storageKey === TYPENAME_KEY || previousValue === undefined || areEqual(previousValue, fieldValue), 'RelayResponseNormalizer: Invalid record. The record contains two ' + 'instances of the same id: `%s` with conflicting field, %s and its values: %s and %s. ' + 'If two fields are different but share ' + 'the same id, one field will overwrite the other.', dataID, storageKey, previousValue, fieldValue) : void 0;\n    }\n  }\n  /**\n   * Warns if a single response contains conflicting fields with the same id\n   */\n  ;\n\n  _proto._validateConflictingLinkedFieldsWithIdenticalId = function _validateConflictingLinkedFieldsWithIdenticalId(record, prevID, nextID, storageKey) {\n    // NOTE: Only call this function in DEV\n    if (process.env.NODE_ENV !== \"production\") {\n      process.env.NODE_ENV !== \"production\" ? warning(prevID === undefined || prevID === nextID, 'RelayResponseNormalizer: Invalid record. The record contains ' + 'references to the conflicting field, %s and its id values: %s and %s. ' + 'We need to make sure that the record the field points ' + 'to remains consistent or one field will overwrite the other.', storageKey, prevID, nextID) : void 0;\n    }\n  };\n\n  return RelayResponseNormalizer;\n}();\n\nmodule.exports = {\n  normalize: normalize\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'use strict';\n\nvar defaultRequiredFieldLogger = function defaultRequiredFieldLogger(event) {\n  if (process.env.NODE_ENV !== \"production\" && event.kind === 'missing_field.log') {\n    throw new Error('Relay Environment Configuration Error (dev only): `@required(action: LOG)` requires that the Relay Environment be configured with a `requiredFieldLogger`.');\n  }\n};\n\nmodule.exports = defaultRequiredFieldLogger;","/**\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 * A fast test to determine if two values are equal scalars:\n * - compares scalars such as booleans, strings, numbers by value\n * - compares functions by identity\n * - returns false for complex values, since these cannot be cheaply tested for\n *   equality (use `areEquals` instead)\n */\n\nfunction isScalarAndEqual(valueA, valueB) {\n  return valueA === valueB && (valueA === null || typeof valueA !== 'object');\n}\n\nmodule.exports = isScalarAndEqual;","/**\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 isPromise(p) {\n  return !!p && typeof p.then === 'function';\n}\n\nmodule.exports = isPromise;","/**\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 areEqual = require(\"fbjs/lib/areEqual\");\n\nvar invariant = require('invariant');\n\nvar _require = require('../util/RelayConcreteNode'),\n    SCALAR_FIELD = _require.SCALAR_FIELD;\n\nvar _require2 = require('./RelayStoreUtils'),\n    getHandleStorageKey = _require2.getHandleStorageKey;\n\n/**\n * @private\n *\n * Creates a clone of the supplied `handleField` by finding the original scalar\n * field (on which the handle was declared) among the sibling `selections`.\n */\nfunction cloneRelayScalarHandleSourceField(handleField, selections, variables) {\n  var sourceField = selections.find(function (source) {\n    return source.kind === SCALAR_FIELD && source.name === handleField.name && source.alias === handleField.alias && areEqual(source.args, handleField.args);\n  });\n  !(sourceField && sourceField.kind === SCALAR_FIELD) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'cloneRelayScalarHandleSourceField: Expected a corresponding source field for ' + 'handle `%s`.', handleField.handle) : invariant(false) : void 0;\n  var handleKey = getHandleStorageKey(handleField, variables);\n  return {\n    kind: 'ScalarField',\n    alias: sourceField.alias,\n    name: handleKey,\n    storageKey: handleKey,\n    args: null\n  };\n}\n\nmodule.exports = cloneRelayScalarHandleSourceField;","/**\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 ConnectionHandler = require('./handlers/connection/ConnectionHandler');\n\nvar ConnectionInterface = require('./handlers/connection/ConnectionInterface');\n\nvar GraphQLTag = require('./query/GraphQLTag');\n\nvar MutationHandlers = require('./handlers/connection/MutationHandlers');\n\nvar PreloadableQueryRegistry = require('./query/PreloadableQueryRegistry');\n\nvar RelayConcreteNode = require('./util/RelayConcreteNode');\n\nvar RelayConcreteVariables = require('./store/RelayConcreteVariables');\n\nvar RelayDeclarativeMutationConfig = require('./mutations/RelayDeclarativeMutationConfig');\n\nvar RelayDefaultHandleKey = require('./util/RelayDefaultHandleKey');\n\nvar RelayDefaultHandlerProvider = require('./handlers/RelayDefaultHandlerProvider');\n\nvar RelayError = require('./util/RelayError');\n\nvar RelayFeatureFlags = require('./util/RelayFeatureFlags');\n\nvar RelayModernEnvironment = require('./store/RelayModernEnvironment');\n\nvar RelayModernOperationDescriptor = require('./store/RelayModernOperationDescriptor');\n\nvar RelayModernRecord = require('./store/RelayModernRecord');\n\nvar RelayModernSelector = require('./store/RelayModernSelector');\n\nvar RelayModernStore = require('./store/RelayModernStore');\n\nvar RelayNetwork = require('./network/RelayNetwork');\n\nvar RelayObservable = require('./network/RelayObservable');\n\nvar RelayOperationTracker = require('./store/RelayOperationTracker');\n\nvar RelayProfiler = require('./util/RelayProfiler');\n\nvar RelayQueryResponseCache = require('./network/RelayQueryResponseCache');\n\nvar RelayRecordSource = require('./store/RelayRecordSource');\n\nvar RelayReplaySubject = require('./util/RelayReplaySubject');\n\nvar RelayStoreUtils = require('./store/RelayStoreUtils');\n\nvar ViewerPattern = require('./store/ViewerPattern');\n\nvar applyOptimisticMutation = require('./mutations/applyOptimisticMutation');\n\nvar commitLocalUpdate = require('./mutations/commitLocalUpdate');\n\nvar commitMutation = require('./mutations/commitMutation');\n\nvar createFragmentSpecResolver = require('./store/createFragmentSpecResolver');\n\nvar createPayloadFor3DField = require('./util/createPayloadFor3DField');\n\nvar createRelayContext = require('./store/createRelayContext');\n\nvar deepFreeze = require('./util/deepFreeze');\n\nvar fetchQuery = require('./query/fetchQuery');\n\nvar fetchQueryInternal = require('./query/fetchQueryInternal');\n\nvar fetchQuery_DEPRECATED = require('./query/fetchQuery_DEPRECATED');\n\nvar getFragmentIdentifier = require('./util/getFragmentIdentifier');\n\nvar getRelayHandleKey = require('./util/getRelayHandleKey');\n\nvar getRequestIdentifier = require('./util/getRequestIdentifier');\n\nvar isPromise = require('./util/isPromise');\n\nvar isRelayModernEnvironment = require('./store/isRelayModernEnvironment');\n\nvar isScalarAndEqual = require('./util/isScalarAndEqual');\n\nvar readInlineData = require('./store/readInlineData');\n\nvar recycleNodesInto = require('./util/recycleNodesInto');\n\nvar reportMissingRequiredFields = require('./util/reportMissingRequiredFields');\n\nvar requestSubscription = require('./subscription/requestSubscription');\n\nvar stableCopy = require('./util/stableCopy');\n\nvar _require = require('./store/ClientID'),\n    generateClientID = _require.generateClientID,\n    generateUniqueClientID = _require.generateUniqueClientID,\n    isClientID = _require.isClientID;\n\n// As early as possible, check for the existence of the JavaScript globals which\n// Relay Runtime relies upon, and produce a clear message if they do not exist.\nif (process.env.NODE_ENV !== \"production\") {\n  var mapStr = typeof Map !== 'function' ? 'Map' : null;\n  var setStr = typeof Set !== 'function' ? 'Set' : null;\n  var promiseStr = typeof Promise !== 'function' ? 'Promise' : null;\n  var objStr = typeof Object.assign !== 'function' ? 'Object.assign' : null;\n\n  if (mapStr || setStr || promiseStr || objStr) {\n    throw new Error(\"relay-runtime requires \".concat([mapStr, setStr, promiseStr, objStr].filter(Boolean).join(', and '), \" to exist. \") + 'Use a polyfill to provide these for older browsers.');\n  }\n}\n/**\n * The public interface to Relay Runtime.\n */\n\n\nmodule.exports = {\n  // Core API\n  Environment: RelayModernEnvironment,\n  Network: RelayNetwork,\n  Observable: RelayObservable,\n  QueryResponseCache: RelayQueryResponseCache,\n  RecordSource: RelayRecordSource,\n  Record: RelayModernRecord,\n  ReplaySubject: RelayReplaySubject,\n  Store: RelayModernStore,\n  areEqualSelectors: RelayModernSelector.areEqualSelectors,\n  createFragmentSpecResolver: createFragmentSpecResolver,\n  createNormalizationSelector: RelayModernSelector.createNormalizationSelector,\n  createOperationDescriptor: RelayModernOperationDescriptor.createOperationDescriptor,\n  createReaderSelector: RelayModernSelector.createReaderSelector,\n  createRequestDescriptor: RelayModernOperationDescriptor.createRequestDescriptor,\n  getDataIDsFromFragment: RelayModernSelector.getDataIDsFromFragment,\n  getDataIDsFromObject: RelayModernSelector.getDataIDsFromObject,\n  getNode: GraphQLTag.getNode,\n  getFragment: GraphQLTag.getFragment,\n  getInlineDataFragment: GraphQLTag.getInlineDataFragment,\n  getModuleComponentKey: RelayStoreUtils.getModuleComponentKey,\n  getModuleOperationKey: RelayStoreUtils.getModuleOperationKey,\n  getPaginationFragment: GraphQLTag.getPaginationFragment,\n  getPluralSelector: RelayModernSelector.getPluralSelector,\n  getRefetchableFragment: GraphQLTag.getRefetchableFragment,\n  getRequest: GraphQLTag.getRequest,\n  getRequestIdentifier: getRequestIdentifier,\n  getSelector: RelayModernSelector.getSelector,\n  getSelectorsFromObject: RelayModernSelector.getSelectorsFromObject,\n  getSingularSelector: RelayModernSelector.getSingularSelector,\n  getStorageKey: RelayStoreUtils.getStorageKey,\n  getVariablesFromFragment: RelayModernSelector.getVariablesFromFragment,\n  getVariablesFromObject: RelayModernSelector.getVariablesFromObject,\n  getVariablesFromPluralFragment: RelayModernSelector.getVariablesFromPluralFragment,\n  getVariablesFromSingularFragment: RelayModernSelector.getVariablesFromSingularFragment,\n  reportMissingRequiredFields: reportMissingRequiredFields,\n  graphql: GraphQLTag.graphql,\n  isFragment: GraphQLTag.isFragment,\n  isInlineDataFragment: GraphQLTag.isInlineDataFragment,\n  isRequest: GraphQLTag.isRequest,\n  readInlineData: readInlineData,\n  // Declarative mutation API\n  MutationTypes: RelayDeclarativeMutationConfig.MutationTypes,\n  RangeOperations: RelayDeclarativeMutationConfig.RangeOperations,\n  // Extensions\n  DefaultHandlerProvider: RelayDefaultHandlerProvider,\n  ConnectionHandler: ConnectionHandler,\n  MutationHandlers: MutationHandlers,\n  VIEWER_ID: ViewerPattern.VIEWER_ID,\n  VIEWER_TYPE: ViewerPattern.VIEWER_TYPE,\n  // Helpers (can be implemented via the above API)\n  applyOptimisticMutation: applyOptimisticMutation,\n  commitLocalUpdate: commitLocalUpdate,\n  commitMutation: commitMutation,\n  fetchQuery: fetchQuery,\n  fetchQuery_DEPRECATED: fetchQuery_DEPRECATED,\n  isRelayModernEnvironment: isRelayModernEnvironment,\n  requestSubscription: requestSubscription,\n  // Configuration interface for legacy or special uses\n  ConnectionInterface: ConnectionInterface,\n  // Utilities\n  PreloadableQueryRegistry: PreloadableQueryRegistry,\n  RelayProfiler: RelayProfiler,\n  createPayloadFor3DField: createPayloadFor3DField,\n  // INTERNAL-ONLY: These exports might be removed at any point.\n  RelayConcreteNode: RelayConcreteNode,\n  RelayError: RelayError,\n  RelayFeatureFlags: RelayFeatureFlags,\n  DEFAULT_HANDLE_KEY: RelayDefaultHandleKey.DEFAULT_HANDLE_KEY,\n  FRAGMENTS_KEY: RelayStoreUtils.FRAGMENTS_KEY,\n  FRAGMENT_OWNER_KEY: RelayStoreUtils.FRAGMENT_OWNER_KEY,\n  ID_KEY: RelayStoreUtils.ID_KEY,\n  REF_KEY: RelayStoreUtils.REF_KEY,\n  REFS_KEY: RelayStoreUtils.REFS_KEY,\n  ROOT_ID: RelayStoreUtils.ROOT_ID,\n  ROOT_TYPE: RelayStoreUtils.ROOT_TYPE,\n  TYPENAME_KEY: RelayStoreUtils.TYPENAME_KEY,\n  deepFreeze: deepFreeze,\n  generateClientID: generateClientID,\n  generateUniqueClientID: generateUniqueClientID,\n  getRelayHandleKey: getRelayHandleKey,\n  isClientID: isClientID,\n  isPromise: isPromise,\n  isScalarAndEqual: isScalarAndEqual,\n  recycleNodesInto: recycleNodesInto,\n  stableCopy: stableCopy,\n  getFragmentIdentifier: getFragmentIdentifier,\n  __internal: {\n    OperationTracker: RelayOperationTracker,\n    createRelayContext: createRelayContext,\n    getOperationVariables: RelayConcreteVariables.getOperationVariables,\n    fetchQuery: fetchQueryInternal.fetchQuery,\n    fetchQueryDeduped: fetchQueryInternal.fetchQueryDeduped,\n    getPromiseForActiveRequest: fetchQueryInternal.getPromiseForActiveRequest,\n    getObservableForActiveRequest: fetchQueryInternal.getObservableForActiveRequest\n  }\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 _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar RelayConcreteNode = require('../util/RelayConcreteNode');\n\nvar RelayFeatureFlags = require('../util/RelayFeatureFlags');\n\nvar RelayModernRecord = require('./RelayModernRecord');\n\nvar RelayStoreReactFlightUtils = require('./RelayStoreReactFlightUtils');\n\nvar RelayStoreUtils = require('./RelayStoreUtils');\n\nvar cloneRelayHandleSourceField = require('./cloneRelayHandleSourceField');\n\nvar getOperation = require('../util/getOperation');\n\nvar invariant = require('invariant');\n\nvar _require = require('./TypeID'),\n    generateTypeID = _require.generateTypeID;\n\nvar CONDITION = RelayConcreteNode.CONDITION,\n    CLIENT_COMPONENT = RelayConcreteNode.CLIENT_COMPONENT,\n    CLIENT_EXTENSION = RelayConcreteNode.CLIENT_EXTENSION,\n    DEFER = RelayConcreteNode.DEFER,\n    FLIGHT_FIELD = RelayConcreteNode.FLIGHT_FIELD,\n    FRAGMENT_SPREAD = RelayConcreteNode.FRAGMENT_SPREAD,\n    INLINE_FRAGMENT = RelayConcreteNode.INLINE_FRAGMENT,\n    LINKED_FIELD = RelayConcreteNode.LINKED_FIELD,\n    MODULE_IMPORT = RelayConcreteNode.MODULE_IMPORT,\n    LINKED_HANDLE = RelayConcreteNode.LINKED_HANDLE,\n    SCALAR_FIELD = RelayConcreteNode.SCALAR_FIELD,\n    SCALAR_HANDLE = RelayConcreteNode.SCALAR_HANDLE,\n    STREAM = RelayConcreteNode.STREAM,\n    TYPE_DISCRIMINATOR = RelayConcreteNode.TYPE_DISCRIMINATOR;\nvar ROOT_ID = RelayStoreUtils.ROOT_ID,\n    getStorageKey = RelayStoreUtils.getStorageKey,\n    getModuleOperationKey = RelayStoreUtils.getModuleOperationKey;\n\nfunction mark(recordSource, selector, references, operationLoader, shouldProcessClientComponents) {\n  var dataID = selector.dataID,\n      node = selector.node,\n      variables = selector.variables;\n  var marker = new RelayReferenceMarker(recordSource, variables, references, operationLoader, shouldProcessClientComponents);\n  marker.mark(node, dataID);\n}\n/**\n * @private\n */\n\n\nvar RelayReferenceMarker = /*#__PURE__*/function () {\n  function RelayReferenceMarker(recordSource, variables, references, operationLoader, shouldProcessClientComponents) {\n    this._operationLoader = operationLoader !== null && operationLoader !== void 0 ? operationLoader : null;\n    this._operationName = null;\n    this._recordSource = recordSource;\n    this._references = references;\n    this._variables = variables;\n    this._shouldProcessClientComponents = shouldProcessClientComponents;\n  }\n\n  var _proto = RelayReferenceMarker.prototype;\n\n  _proto.mark = function mark(node, dataID) {\n    if (node.kind === 'Operation' || node.kind === 'SplitOperation') {\n      this._operationName = node.name;\n    }\n\n    this._traverse(node, dataID);\n  };\n\n  _proto._traverse = function _traverse(node, dataID) {\n    this._references.add(dataID);\n\n    var record = this._recordSource.get(dataID);\n\n    if (record == null) {\n      return;\n    }\n\n    this._traverseSelections(node.selections, record);\n  };\n\n  _proto._getVariableValue = function _getVariableValue(name) {\n    !this._variables.hasOwnProperty(name) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReferenceMarker(): Undefined variable `%s`.', name) : invariant(false) : void 0; // $FlowFixMe[cannot-write]\n\n    return this._variables[name];\n  };\n\n  _proto._traverseSelections = function _traverseSelections(selections, record) {\n    var _this = this;\n\n    selections.forEach(function (selection) {\n      /* eslint-disable no-fallthrough */\n      switch (selection.kind) {\n        case LINKED_FIELD:\n          if (selection.plural) {\n            _this._traversePluralLink(selection, record);\n          } else {\n            _this._traverseLink(selection, record);\n          }\n\n          break;\n\n        case CONDITION:\n          var conditionValue = _this._getVariableValue(selection.condition);\n\n          if (conditionValue === selection.passingValue) {\n            _this._traverseSelections(selection.selections, record);\n          }\n\n          break;\n\n        case INLINE_FRAGMENT:\n          if (selection.abstractKey == null) {\n            var typeName = RelayModernRecord.getType(record);\n\n            if (typeName != null && typeName === selection.type) {\n              _this._traverseSelections(selection.selections, record);\n            }\n          } else if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {\n            var _typeName = RelayModernRecord.getType(record);\n\n            var typeID = generateTypeID(_typeName);\n\n            _this._references.add(typeID);\n\n            _this._traverseSelections(selection.selections, record);\n          } else {\n            _this._traverseSelections(selection.selections, record);\n          }\n\n          break;\n        // $FlowFixMe[incompatible-type]\n\n        case FRAGMENT_SPREAD:\n          _this._traverseSelections(selection.fragment.selections, record);\n\n          break;\n\n        case LINKED_HANDLE:\n          // The selections for a \"handle\" field are the same as those of the\n          // original linked field where the handle was applied. Reference marking\n          // therefore requires traversing the original field selections against\n          // the synthesized client field.\n          //\n          // TODO: Instead of finding the source field in `selections`, change\n          // the concrete structure to allow shared subtrees, and have the linked\n          // handle directly refer to the same selections as the LinkedField that\n          // it was split from.\n          var handleField = cloneRelayHandleSourceField(selection, selections, _this._variables);\n\n          if (handleField.plural) {\n            _this._traversePluralLink(handleField, record);\n          } else {\n            _this._traverseLink(handleField, record);\n          }\n\n          break;\n\n        case DEFER:\n        case STREAM:\n          _this._traverseSelections(selection.selections, record);\n\n          break;\n\n        case SCALAR_FIELD:\n        case SCALAR_HANDLE:\n          break;\n\n        case TYPE_DISCRIMINATOR:\n          {\n            if (RelayFeatureFlags.ENABLE_PRECISE_TYPE_REFINEMENT) {\n              var _typeName2 = RelayModernRecord.getType(record);\n\n              var _typeID = generateTypeID(_typeName2);\n\n              _this._references.add(_typeID);\n            }\n\n            break;\n          }\n\n        case MODULE_IMPORT:\n          _this._traverseModuleImport(selection, record);\n\n          break;\n\n        case CLIENT_EXTENSION:\n          _this._traverseSelections(selection.selections, record);\n\n          break;\n\n        case FLIGHT_FIELD:\n          if (RelayFeatureFlags.ENABLE_REACT_FLIGHT_COMPONENT_FIELD) {\n            _this._traverseFlightField(selection, record);\n          } else {\n            throw new Error('Flight fields are not yet supported.');\n          }\n\n          break;\n\n        case CLIENT_COMPONENT:\n          if (_this._shouldProcessClientComponents === false) {\n            break;\n          }\n\n          _this._traverseSelections(selection.fragment.selections, record);\n\n          break;\n\n        default:\n          selection;\n          !false ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReferenceMarker: Unknown AST node `%s`.', selection) : invariant(false) : void 0;\n      }\n    });\n  };\n\n  _proto._traverseModuleImport = function _traverseModuleImport(moduleImport, record) {\n    var _this$_operationName;\n\n    var operationLoader = this._operationLoader;\n    !(operationLoader !== null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'RelayReferenceMarker: Expected an operationLoader to be configured when using `@module`. ' + 'Could not load fragment `%s` in operation `%s`.', moduleImport.fragmentName, (_this$_operationName = this._operationName) !== null && _this$_operationName !== void 0 ? _this$_operationName : '(unknown)') : invariant(false) : void 0;\n    var operationKey = getModuleOperationKey(moduleImport.documentName);\n    var operationReference = RelayModernRecord.getValue(record, operationKey);\n\n    if (operationReference == null) {\n      return;\n    }\n\n    var normalizationRootNode = operationLoader.get(operationReference);\n\n    if (normalizationRootNode != null) {\n      var selections = getOperation(normalizationRootNode).selections;\n\n      this._traverseSelections(selections, record);\n    } // Otherwise, if the operation is not available, we assume that the data\n    // cannot have been processed yet and therefore isn't in the store to\n    // begin with.\n\n  };\n\n  _proto._traverseLink = function _traverseLink(field, record) {\n    var storageKey = getStorageKey(field, this._variables);\n    var linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);\n\n    if (linkedID == null) {\n      return;\n    }\n\n    this._traverse(field, linkedID);\n  };\n\n  _proto._traversePluralLink = function _traversePluralLink(field, record) {\n    var _this2 = this;\n\n    var storageKey = getStorageKey(field, this._variables);\n    var linkedIDs = RelayModernRecord.getLinkedRecordIDs(record, storageKey);\n\n    if (linkedIDs == null) {\n      return;\n    }\n\n    linkedIDs.forEach(function (linkedID) {\n      if (linkedID != null) {\n        _this2._traverse(field, linkedID);\n      }\n    });\n  };\n\n  _proto._traverseFlightField = function _traverseFlightField(field, record) {\n    var storageKey = getStorageKey(field, this._variables);\n    var linkedID = RelayModernRecord.getLinkedRecordID(record, storageKey);\n\n    if (linkedID == null) {\n      return;\n    }\n\n    this._references.add(linkedID);\n\n    var reactFlightClientResponseRecord = this._recordSource.get(linkedID);\n\n    if (reactFlightClientResponseRecord == null) {\n      return;\n    }\n\n    var reachableExecutableDefinitions = RelayModernRecord.getValue(reactFlightClientResponseRecord, RelayStoreReactFlightUtils.REACT_FLIGHT_EXECUTABLE_DEFINITIONS_STORAGE_KEY);\n\n    if (!Array.isArray(reachableExecutableDefinitions)) {\n      return;\n    }\n\n    var operationLoader = this._operationLoader;\n    !(operationLoader !== null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'DataChecker: Expected an operationLoader to be configured when using ' + 'React Flight') : invariant(false) : void 0; // In Flight, the variables that are in scope for reachable executable\n    // definitions aren't the same as what's in scope for the outer query.\n\n    var prevVariables = this._variables; // $FlowFixMe[incompatible-cast]\n\n    var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(reachableExecutableDefinitions),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var definition = _step.value;\n        this._variables = definition.variables;\n        var operationReference = definition.module;\n        var normalizationRootNode = operationLoader.get(operationReference);\n\n        if (normalizationRootNode != null) {\n          var operation = getOperation(normalizationRootNode);\n\n          this._traverse(operation, ROOT_ID);\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n\n    this._variables = prevVariables;\n  };\n\n  return RelayReferenceMarker;\n}();\n\nmodule.exports = {\n  mark: mark\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 _createForOfIteratorHelper2 = _interopRequireDefault(require(\"@babel/runtime/helpers/createForOfIteratorHelper\"));\n\nvar RelayRecordState = require('./RelayRecordState');\n\nvar EXISTENT = RelayRecordState.EXISTENT,\n    NONEXISTENT = RelayRecordState.NONEXISTENT,\n    UNKNOWN = RelayRecordState.UNKNOWN;\n/**\n * An implementation of the `MutableRecordSource` interface (defined in\n * `RelayStoreTypes`) that holds all records in memory (JS Map).\n */\n\nvar RelayMapRecordSourceMapImpl = /*#__PURE__*/function () {\n  function RelayMapRecordSourceMapImpl(records) {\n    var _this = this;\n\n    this._records = new Map();\n\n    if (records != null) {\n      Object.keys(records).forEach(function (key) {\n        _this._records.set(key, records[key]);\n      });\n    }\n  }\n\n  var _proto = RelayMapRecordSourceMapImpl.prototype;\n\n  _proto.clear = function clear() {\n    this._records = new Map();\n  };\n\n  _proto[\"delete\"] = function _delete(dataID) {\n    this._records.set(dataID, null);\n  };\n\n  _proto.get = function get(dataID) {\n    return this._records.get(dataID);\n  };\n\n  _proto.getRecordIDs = function getRecordIDs() {\n    return Array.from(this._records.keys());\n  };\n\n  _proto.getStatus = function getStatus(dataID) {\n    if (!this._records.has(dataID)) {\n      return UNKNOWN;\n    }\n\n    return this._records.get(dataID) == null ? NONEXISTENT : EXISTENT;\n  };\n\n  _proto.has = function has(dataID) {\n    return this._records.has(dataID);\n  };\n\n  _proto.remove = function remove(dataID) {\n    this._records[\"delete\"](dataID);\n  };\n\n  _proto.set = function set(dataID, record) {\n    this._records.set(dataID, record);\n  };\n\n  _proto.size = function size() {\n    return this._records.size;\n  };\n\n  _proto.toJSON = function toJSON() {\n    var obj = {};\n\n    var _iterator = (0, _createForOfIteratorHelper2[\"default\"])(this._records),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var _step$value = _step.value,\n            key = _step$value[0],\n            value = _step$value[1];\n        obj[key] = value;\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n\n    return obj;\n  };\n\n  return RelayMapRecordSourceMapImpl;\n}();\n\nmodule.exports = RelayMapRecordSourceMapImpl;","/**\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 _require = require('../query/GraphQLTag'),\n    getInlineDataFragment = _require.getInlineDataFragment;\n\nvar _require2 = require('./RelayStoreUtils'),\n    FRAGMENTS_KEY = _require2.FRAGMENTS_KEY;\n\nfunction readInlineData(fragment, fragmentRef) {\n  var _fragmentRef$FRAGMENT;\n\n  var inlineDataFragment = getInlineDataFragment(fragment);\n\n  if (fragmentRef == null) {\n    return fragmentRef;\n  }\n\n  !(typeof fragmentRef === 'object') ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'readInlineData(): Expected an object, got `%s`.', typeof fragmentRef) : invariant(false) : void 0; // $FlowFixMe[incompatible-use]\n\n  var inlineData = (_fragmentRef$FRAGMENT = fragmentRef[FRAGMENTS_KEY]) === null || _fragmentRef$FRAGMENT === void 0 ? void 0 : _fragmentRef$FRAGMENT[inlineDataFragment.name];\n  !(inlineData != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'readInlineData(): Expected fragment `%s` to be spread in the parent ' + 'fragment.', inlineDataFragment.name) : invariant(false) : void 0;\n  return inlineData;\n}\n\nmodule.exports = readInlineData;","/**\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 * Creates a copy of the provided value, ensuring any nested objects have their\n * keys sorted such that equivalent values would have identical JSON.stringify\n * results.\n */\n\nfunction stableCopy(value) {\n  if (!value || typeof value !== 'object') {\n    return value;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map(stableCopy);\n  }\n\n  var keys = Object.keys(value).sort();\n  var stable = {};\n\n  for (var i = 0; i < keys.length; i++) {\n    stable[keys[i]] = stableCopy(value[keys[i]]);\n  }\n\n  return stable;\n}\n\nmodule.exports = stableCopy;","/**\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 * Recursively \"deep\" freezes the supplied object.\n *\n * For convenience, and for consistency with the behavior of `Object.freeze`,\n * returns the now-frozen original object.\n */\n\nfunction deepFreeze(object) {\n  Object.freeze(object);\n  Object.getOwnPropertyNames(object).forEach(function (name) {\n    // $FlowFixMe[prop-missing]\n    var property = object[name];\n\n    if (property && typeof property === 'object' && !Object.isFrozen(property)) {\n      deepFreeze(property);\n    }\n  });\n  return object;\n}\n\nmodule.exports = deepFreeze;"],"sourceRoot":""}