{"version":3,"sources":["webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/core/types/Cache.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/core/cache.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/core/types/common.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/inmemory/helpers.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/inmemory/entityStore.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/inmemory/readFromStore.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/inmemory/writeToStore.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/inmemory/reactiveVars.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/inmemory/policies.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/cache/inmemory/inMemoryCache.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/core/MutationStore.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/core/LocalState.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/core/QueryInfo.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/core/QueryManager.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/core/ApolloClient.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/version.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/core/Reobserver.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/core/ObservableQuery.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/core/index.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/core/networkStatus.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/errors/index.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/context/index.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/core/ApolloLink.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/core/concat.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/core/empty.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/core/execute.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/core/from.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/core/split.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/error/index.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/http/serializeFetchParameter.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/http/selectHttpOptionsAndBody.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/http/createHttpLink.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/http/checkFetcher.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/http/selectURI.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/http/createSignalIfSupported.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/http/rewriteURIForGET.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/http/HttpLink.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/retry/retryLink.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/retry/delayFunction.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/retry/retryFunction.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/utils/fromError.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/utils/throwServerError.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/utils/validateOperation.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/utils/createOperation.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/link/utils/transformOperation.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/node_modules/tslib/tslib.es6.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/context/ApolloContext.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/context/ApolloConsumer.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/context/ApolloProvider.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/hooks/useApolloClient.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/parser/index.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/data/OperationData.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/data/SubscriptionData.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/data/MutationData.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/data/QueryData.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/hooks/utils/useBaseQuery.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/hooks/utils/useDeepMemo.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/hooks/useLazyQuery.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/hooks/useMutation.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/react/hooks/useQuery.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/graphql/directives.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/graphql/fragments.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/graphql/storeUtils.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/graphql/getFromAST.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/common/filterInPlace.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/graphql/transform.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/observables/Observable.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/common/mergeDeep.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/common/cloneDeep.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/common/maybeDeepFreeze.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/observables/iteration.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/observables/asyncMap.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/observables/Concast.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/common/arrays.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/common/errorHandling.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/common/canUse.js","webpack://@magento/venia-concept/../node_modules/@apollo/client/utilities/common/compact.js","webpack://@magento/venia-concept/../node_modules/apollo-cache-persist/Log.js","webpack://@magento/venia-concept/../node_modules/apollo-cache-persist/Cache.js","webpack://@magento/venia-concept/../node_modules/apollo-cache-persist/Storage.js","webpack://@magento/venia-concept/../node_modules/apollo-cache-persist/Persistor.js","webpack://@magento/venia-concept/../node_modules/apollo-cache-persist/onCacheWrite.js","webpack://@magento/venia-concept/../node_modules/apollo-cache-persist/Trigger.js","webpack://@magento/venia-concept/../node_modules/apollo-cache-persist/onAppBackground.js","webpack://@magento/venia-concept/../node_modules/apollo-cache-persist/CachePersistor.js","webpack://@magento/venia-concept/../node_modules/informed/dist/esm/index.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/constants.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/isArray.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/isString.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/getLastElement.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/camelCase.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/arrayToObject.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/flattenActionMap.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/isEmpty.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/unflattenActionCreators.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/isNull.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/createAction.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/createActions.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/flattenReducerMap.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/hasGeneratorInterface.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/isUndefined.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/toString.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/handleActions.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/handleAction.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/flattenWhenNode.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/get.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/identity.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/isFunction.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/isMap.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/isNil.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/isPlainObject.js","webpack://@magento/venia-concept/../node_modules/redux-actions/es/utils/ownKeys.js","webpack://@magento/venia-concept/../node_modules/redux-thunk/es/index.js","webpack://@magento/venia-concept/../node_modules/redux/es/redux.js"],"names":["Cache","ApolloCache","this","getFragmentDoc","prototype","recordOptimisticTransaction","transaction","optimisticId","performTransaction","transformDocument","document","identify","object","gc","modify","options","transformForLink","readQuery","optimistic","read","rootId","id","query","variables","readFragment","fragment","fragmentName","writeQuery","write","dataId","result","data","broadcast","writeFragment","MissingFieldError","message","path","hasOwn","Object","hasOwnProperty","FieldNamePattern","storeFieldName","match","storeValueIsStoreObject","value","Array","isArray","isFieldValueToBeMerged","field","__field","reconcileProcessedFields","existingObject","incomingObject","property","existing","incoming","__value","merge","DELETE","create","delModifier","EntityStore","policies","group","_this","rootIds","refs","getFieldValue","objectOrReference","get","__ref","canRead","objOrRef","has","toReference","objOrIdOrRef","mergeIntoStore","ref","toObject","lookup","fieldName","depend","call","storeObject","rootTypenamesById","Layer","parent","dependOnExistence","merged","storeObjectReconciler","caching","fieldsToDirty_1","__exists","keys","forEach","dirty","fields","changedFields_1","needToMerge_1","allDeleted_1","readField_1","fieldNameOrOptions","from","readField","store","fieldValue","newValue","isReference","delete","args","_a","typename","getStoreFieldName","evict","evicted","clear","replace","newData","retain","release","count","getRootIdSet","ids","Set","add","snapshot","findChildRefIds","idsToRemove","length","root_1","found_1","workSet_1","canTraverse_1","obj","values","filter","makeCacheKey","_i","arguments","keyMaker","lookupArray","CacheGroup","d","makeDepKey","Root","_super","_b","resultCaching","seed","sharedLayerGroup","addLayer","layerId","replay","removeLayer","fromParent","existingValue","incomingValue","supportsResultCaching","missingFromInvariant","err","context","slice","StoreReader","config","executeSelectionSet","execSelectionSetImpl","keyArgs","selectionSet","varString","knownResults","WeakMap","executeSubSelectedArray","execSubSelectedArrayImpl","array","addTypename","readQueryFromStore","diffQueryAgainstStore","returnPartialData","_c","cache","execResult","JSON","stringify","fragmentMap","hasMissingFields","missing","complete","isFresh","latest","peek","objectsToMerge","finalResult","getMissing","handleMissing","push","apply","rootIdsByTypename","__typename","workSet","selections","selection","name","resultName","pop","fragmentMatches","set","childResult","i","map","item","StoreWriter","reader","writeToStore","operationDefinition","merger","makeProcessedFieldsMerger","processSelectionSet","written","out","shouldApplyMerges","keyObject","sets","indexOf","mergedFields","resultFieldKey","processFieldValue","hasMergeFunction","usingPossibleTypes","entityRef_1","applyMerges","varDep","cacheSlot","makeVar","caches","rv","getValue","broadcastWatches","argsFromFieldSpecifier","spec","defaultDataIdFromObject","_id","nullKeyFieldsFn","simpleKeyArgsFn","_args","mergeTrueFn","mergeObjects","mergeFalseFn","_","Policies","typePolicies","storageTrie","dataIdFromObject","setRootTypename","possibleTypes","addPossibleTypes","addTypePolicies","ROOT_QUERY","policy","getTypePolicy","keyFn","specifierOrId","keyFieldsFnFromSpecifier","String","keyFields","queryType","mutationType","subscriptionType","getFieldPolicy","keyArgsFnFromSpecifier","which","toUpperCase","old","supertype","subtypeSet","getSubtypeSet","createIfMissing","subtypes","typePolicy","fieldPolicies","typeCondition","workQueue_1","subtype","subsubtypes","fieldSpec","specifierOrString","readOptions","makeFieldFunctionOptions","withValue","storageKeys","storage","newFields_1","e_1","i_1","firstStorageKey_1","appliedValue","eType","iType","typesDiffer","applied","specifier","computeKeyObject","trie","aliasMap","info","makeAliasMap","workQueue","alias","responseKey","storeKey","aliases","subsets","response","prevKey","keyObj","s","subset","responseName","defaultConfig","InMemoryCache","watches","typenameDocumentCache","Map","txCount","maybeBroadcastWatch","c","broadcastWatch","optimisticData","callback","watchDep","storeWriter","storeReader","restore","extract","diff","watch","immediate","reset","Promise","resolve","removeOptimistic","idToRemove","newOptimisticData","perform","layer","MutationStore","getStore","mutationId","initMutation","mutation","loading","error","markMutationError","markMutationResult","LocalState","client","resolvers","fragmentMatcher","addResolvers","setFragmentMatcher","resolverGroup","setResolvers","getResolvers","runResolvers","remoteResult","onlyRunForcedResolvers","resolveDocument","then","localResult","getFragmentMatcher","clientQuery","serverQuery","prepareContext","getCacheKey","addExportedVariables","buildRootValueFromCache","exportedVariables","shouldForceResolvers","forceResolvers","Directive","enter","node","some","arg","kind","rootValue","mainDefinition","fragments","definitionOperation","defaultOperationType","execContext","operation","charAt","resolveSelectionSet","resultsToMerge","execute","resolveField","fieldResult","fragmentResult","all","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","directives","directive","resolveSubSelectedArray","QueryInfo","listeners","lastRequestId","subscriptions","observableQuery","init","networkStatus","assign","networkError","graphQLErrors","setObservableQuery","getDiff","updateWatch","setDiff","oldDiff","notifyTimeout","setTimeout","notify","oq","oqListener","reobserve","clearTimeout","shouldNotify","listener","size","fetchPolicy","stop","cancel","stopPolling","lastWatch","markResult","allowCacheWrite","errors","ignoreErrors","errorPolicy","writeWithErrors","lastWrittenResult","lastWrittenVars","markReady","markError","QueryManager","link","queryDeduplication","onBroadcast","_d","ssrMode","_e","clientAwareness","localState","assumeImmutableResults","mutationStore","queries","fetchCancelFns","transformCache","queryIdCounter","requestIdCounter","mutationIdCounter","inFlightLinkObservables","_info","queryId","stopQueryNoBroadcast","cancelPendingFetches","mutate","optimisticResponse","updateQueriesByName","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","update","generateUpdateQueriesInfo","optimistic_1","self","_f","label","generateMutationId","transform","getVariables","hasClientExports","sent","ret","queryName","updater","queryInfo","queryUpdatersById","broadcastQueries","reject","storeResult","getObservableFromLink","subscribe","next","e","refetchQueryPromises","refetchQuery","refetch","queryOptions","fetchQuery","fetchQueryObservable","promise","getQueryStore","resetErrors","undefined","transformed","forLink","cacheEntry_1","hasForcedResolvers","defaultVars","doc","watchQuery","notifyOnNetworkStatusChange","observable","ObservableQuery","queryManager","pollInterval","generateQueryId","finally","stopQuery","generateRequestId","stopQueryInStore","stopQueryInStoreNoBroadcast","clearStore","resetStore","reFetchObservableQueries","includeStandby","observableQueryPromises","resetLastResults","getQuery","startGraphQLSubscription","makeObservable","observablePromise_1","observer","sub","unsubscribe","removeQuery","x","getLocalState","deduplication","inFlightLinkObservables_1","operationName","forceFetch","byVariables_1","varJson_1","concast","cleanup","getResultsFromLink","hasErrors","aqr","oldNetworkStatus","normalized","fromVariables","fetchQueryByPolicy","reason","nextFetchPolicy","readCache","resultsFromCache","fromData","partial","resolved","resultsFromLink","newContext","cacheWrites_1","queryUpdatersById_1","currentQueryResult","nextQueryResult","mutationResult","queryVariables","ApolloClient","defaultOptions","resetStoreCallbacks","clearStoreCallbacks","uri","credentials","headers","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","version","disableNetworkFetches","bind","window","__APOLLO_CLIENT__","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","__actionHookForDevTools","cb","__requestRaw","payload","fn","onResetStore","onClearStore","serializedState","setLocalStateFragmentMatcher","setLink","newLink","Reobserver","fetch","shouldFetch","newOptions","newNetworkStatus","updateOptions","updatePolling","removeObserver","addObserver","pollingInfo","timeout","interval","maybeFetch","poll","onSubscribe","observers","lastError","isDifferentFromLastResult","updateLastResult","lastResult","isTornDown","opDef","defineProperty","enumerable","configurable","subscription","getCurrentResult","newResult","lastResultSnapshot","getLastResult","getLastError","resetQueryStoreErrors","reobserveOptions","newReobserver","fetchMore","fetchMoreOptions","combinedOptions","qid","currentResult","fetchMoreResult","updateQuery","previous","subscribeToMore","subscriptionData","onError","setOptions","setVariables","mapFn","previousResult","startPolling","getReobserver","reobserver","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","first","catch","tearDownQuery","shareOptions","currentOptions","NetworkStatus","isNetworkRequestInFlight","isApolloError","ApolloError","errorMessage","extraInfo","graphQLError","__proto__","Error","setContext","setter","forward","request","handle","req","getContext","passthrough","op","toLink","handler","ApolloLink","isTerminating","LinkError","empty","links","reduce","y","concat","split","test","left","right","leftLink","rightLink","second","firstLink","nextLink","setOnError","errorHandler","retriedSub","retriedResult","ErrorLink","serializeFetchParameter","p","serialized","parseError","fallbackHttpConfig","http","includeQuery","includeExtensions","accept","method","createHttpLink","linkOptions","fetcher","useGETForQueries","requestOptions","checkFetcher","linkConfig","fetchOptions","chosenURI","fallbackURI","contextURI","selectURI","clientAwarenessHeaders","name_1","controller","contextHeaders","contextConfig","fallbackConfig","configs","extensions","body","selectHttpOptionsAndBody","signal","AbortController","createSignalIfSupported","_controller","definitions","rewriteURIForGET","queryParams","addQueryParam","key","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","newURI","join","parseAndCheckHttpResponse","operations","text","bodyText","parse","statusCode","status","abort","HttpLink","RetryableOperation","delayFor","retryIf","retryCount","canceled","currentSubscription","onNext","onComplete","scheduleRetry","index","every","o","start","try","timerId","delay","RetryLink","attempts","buildDelayFunction","delayOptions","initial","jitter","max","Infinity","baseDelay","delayFunction","Math","min","pow","random","buildRetryFunction","retryOptions","retryFunction","retryable","fromError","errorValue","throwServerError","validateOperation","OPERATION_FIELDS","createOperation","starting","transformOperation","transformedOperation","extendStatics","b","setPrototypeOf","__extends","__","constructor","__assign","t","n","__rest","getOwnPropertySymbols","propertyIsEnumerable","__awaiter","thisArg","_arguments","P","generator","fulfilled","step","rejected","done","adopt","__generator","f","g","trys","ops","verb","Symbol","iterator","v","TypeError","__spreadArrays","il","r","k","a","j","jl","contextSymbol","for","resetApolloContext","writable","ApolloProvider","children","ApolloContext","Consumer","Provider","useApolloClient","DocumentType","type","Query","Mutation","Subscription","OperationData","isMounted","previousOptions","getOptions","storePrevious","unmount","refreshClient","isNew","verifyDocumentType","parser","cached","definition","variableDefinitions","SubscriptionData","setResult","currentObservable","initialize","skip","getLoadingResult","shouldResubscribe","startSubscription","afterExecute","endSubscription","updateCurrentData","updateError","completeSubscription","updateResult","onSubscriptionData","onSubscriptionComplete","MutationData","runMutation","mutationFunctionOptions","onMutationStart","generateNewMutationId","onMutationCompleted","onMutationError","mostRecentMutationId","ignoreResults","called","onCompleted","isMostRecentMutation","QueryData","onNewData","previousData","runLazy","runLazyQuery","lazyOptions","getQueryResult","observableQueryFields","partialRefetch","obsRefetch","obsFetchMore","obsUpdateQuery","obsStartPolling","obsStopPolling","obsSubscribeToMore","removeQuerySubscription","updateObservableQuery","startQuerySubscription","getExecuteSsrResult","getExecuteResult","executeLazy","fetchData","ssr","lazy","handleErrorOrCompleted","ssrInitiated","renderPromises","ssrDisabled","fetchDisabled","ssrLoading","stale","addQueryPromise","prepareObservableQueryOptions","displayName","initializeObservableQuery","getSSRObservable","observableQueryOptions","registerSSRObservable","newObservableQueryOptions","resubscribeToQuery","useBaseQuery","useContext","useReducer","tick","forceUpdate","updatedOptions","queryDataRef","useRef","queryData","current","useDeepMemo","memoFn","queryResult","useEffect","useLazyQuery","useMutation","useState","mutationDataRef","mutationData","getMutationDataRef","useQuery","shouldInclude","getInclusionDirectives","isInclusionDirective","directiveArguments","ifArgument","ifValue","evaledValue","hasDirectives","names","root","getDirectiveNames","getFragmentQueryDocument","actualFragmentName","createFragmentMap","symTable","getFragmentFromSelection","makeReference","Boolean","valueToObjectRepresentation","argObj","isIntValue","isFloatValue","Number","isBooleanValue","isStringValue","isObjectValue","nestedArgObj_1","isVariable","variableValue","isListValue","listValue","nestedArgArrayObj","isEnumValue","isNullValue","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","filterKeys","sort","filteredArgs_1","completeFieldName","stringifiedArgs","argumentsObjectFromField","argObj_1","resultKeyNameFromField","getTypenameFromResult","isInlineFragment","checkDocument","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","queryDef","getMainDefinition","queryDoc","fragmentDefinition","getDefaultValues","defaultValues","defs","def","defaultValue","variable","filterInPlace","target","elem","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","getFragmentDefinition","fragmentDef","getDirectiveMatcher","directiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","_key","Field","remove","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","removeArgumentsFromDocument","argMatcher","getArgumentMatcher","argumentMatcher","argument","aConfig","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","fs","removeFragmentSpreadFromDocument","FragmentDefinition","addTypenameToDocument","SelectionSet","lastIndexOf","added","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","allFragments","buildQueryFromSelectionSet","removeClientSetsFromDocument","mergeDeep","sources","mergeDeepArray","DeepMerger","isObject","defaultReconciler","source","reconciler","pastCopies","sourceKey","targetValue","shallowCopyForMerge","getPrototypeOf","toString","cloneDeep","cloneDeepHelper","val","seen","copy_1","child","copy_2","maybeDeepFreeze","iterateObserversSafely","observersWithMethod","obs","asyncMap","catchFn","activeCallbackCount","completed","makeCallback","examiner","delegate","isPromiseLike","Concast","handlers","shift","iterable","nextOrError","quietly","once","isNonEmptyArray","graphQLResultHasError","species","canUseWeakMap","navigator","product","compact","objects","Log","debug","lines","emit","level","console","prefix","tailLogs","getLogs","buffer","warn","serialize","Storage","getItem","setItem","purge","removeItem","getSize","Persistor","log","maxSize","paused","persist","error_1","error_2","error_3","Trigger","persistor","fire","debounce","defaultDebounce","trigger","uninstall","onCacheWrite","onAppBackground","pause","resume","CachePersistor","print","_classCallCheck","instance","Constructor","_defineProperties","props","descriptor","_createClass","protoProps","staticProps","_defineProperty","_extends","ownKeys","enumerableOnly","symbols","sym","getOwnPropertyDescriptor","_objectSpread2","getOwnPropertyDescriptors","defineProperties","_inherits","subClass","superClass","_setPrototypeOf","_getPrototypeOf","_objectWithoutProperties","excluded","_objectWithoutPropertiesLoose","sourceKeys","sourceSymbolKeys","_assertThisInitialized","ReferenceError","_createSuper","Derived","hasNativeReflectConstruct","_isNativeReflectConstruct","Reflect","construct","sham","Proxy","Date","_createSuperInternal","Super","NewTarget","_possibleConstructorReturn","_slicedToArray","arr","_arrayWithHoles","_iterableToArrayLimit","_arr","_n","_s","_unsupportedIterableToArray","_nonIterableRest","_toConsumableArray","_arrayWithoutHoles","_arrayLikeToArray","_iterableToArray","iter","_nonIterableSpread","minLen","len","arr2","createCommonjsModule","module","exports","formatNodeArgs","namespace","useColors","color","formatBrowserArgs","lastC","splice","browserColors","createLogger","_len","unshift","namespaces","RegExp","regex","selectColor","colors","hash","charCodeAt","abs","process","browser","__nwjs","browserLogger","loadBrowser","localStorage","env","DEBUG","formatArgs","nodeLogger","loadNode","debug$1","ldtoPath","ldget","res","parentPath","ldhas","pPath","pathKey","parentObj","ldset","isInteger","ldunset","found","pathToArrayElem","pathArray","ObjectMap","ldvalues","_delete","pullOut","ldpullAt","pulled","FormRegisterContext","register","deregister","setValue","setTouched","setError","getField","expectRemoval","getInitialValue","FormStateContext","FormApiContext","getFullField","getValues","setInitialValue","getDerrivedValue","getSavedValue","removeSavedState","GroupContext","ArrayFieldStateContext","ArrayFieldApiContext","ArrayFieldItemApiContext","ArrayFieldItemStateContext","MultistepStepContext","useFormApi","useStateWithGetter","mounted","_useState2","setState","yupToFormErrors","yupError","inner","_step","_iterator","_createForOfIteratorHelper","allowArrayLike","it","F","normalCompletion","didErr","return","uuidv4","computeFieldFromProperty","propertyName","uiControl","informedProps","inputProps","uiBefore","uiAfter","oneOf","items","schemaEnum","title","minimum","maximum","minLength","maxLength","pattern","subProperties","properties","componentType","option","_option$inputProps","_options","_options2","_option$inputProps2","informedFormat","frmtr","offset","formatter","getFormatter","_char","prefixLength","findIndex","suffixStart","reverse","formatted","chars","vIndex","matchIndex","matchingIndex","mi","matching","matcher","curChar","useIsomorphicLayoutEffect","createElement","useLayoutEffect","logger","initializeValue","mask","validateRequired","required","useField","fieldProps","userRef","validationFunc","validate","asyncValidate","validationSchema","maskWithCursorOffset","format","initialValue","validateOnChange","validateOnBlur","validateOnMount","asyncValidateOnBlur","maskOnBlur","allowEmptyString","onValueChange","keepState","maintainCursor","shadow","fieldType","multiple","onChange","onBlur","formController","userRelevant","relevant","keepStateIfRelevant","userProps","fieldId","multistepContext","inMultistep","formApi","fieldApiRef","initialRenerRef","fieldObjectRef","getFormApi","initVal","initTouched","generateValidationFunction","_ref","validateYupField","schema","validateSync","abortEarly","yupToFormError","formInitialValue","savedState","touched","_useStateWithGetter2","setVal","getTheVal","_useStateWithGetter4","setErr","getErr","_useStateWithGetter6","setTouch","getTouch","_useStateWithGetter8","setCursor","getCursor","_useStateWithGetter10","setCursorOffset","getCursorOffset","_useState5","initializeMask","_useState6","maskedValue","setMaskedValue","initialValueRef","fieldRef","prevFieldRef","relevantFunc","params","rel","ff","_useStateWithGetter12","isRelevant","setIsRelevant","getIsRelevant","getVal","preventUpdate","getStep","formOptions","maskedVal","allowEmptyStrings","selectionStart","_res","fieldApi","fieldValidate","fieldAsyncValidate","getTouched","getError","getFieldState","multistepRelevant","checkRelevant","newRel","fieldState","internalRef","fullField","selectionEnd","style","border","borderWidth","borderStyle","borderColor","borderImage","shouldUpdate","changeHandler","generateOnChange","_ref2","selected","checked","blurHandler","generateOnBlur","_ref3","hookedValue","generateValue","_ref4","generateFieldType","render","useMemo","informed","asField","Component","forwardRef","_useField","forwardedRef","getChildDisplayName","WrappedComponent","logger$1","Text","_onChange","_onBlur","rest","background","htmlFor","Text$1","TextArea","TextArea$1","logger$2","Select","selectRef","handleChange","disabled","Select$1","Checkbox","Checkbox$1","Radio$1","withRadioGroup","radioGroupApi","radioGroupState","Radio","groupValue","groupOnChange","groupOnBlur","RadioGroup","_Component","_this$props","groupContext","RadioGroup$1","logger$3","useArrayField","arrayFieldApiRef","fieldsById","initialVals","initialValues","setInitialValues","getInitialValues","setKeys","getKeys","validateWithLength","onChangeHandler","emitter","on","removeListener","swap","newKeys","addWithInitialValue","newInitialValues","arrayFieldItemApi","initVals","_remove","arrayFieldItemState","arrayFieldApi","resetKeys","arrayFieldState","wrappedUpdator","fld","_len2","_key2","useScopedApi","scope","scopedFormApi","buildScopedFormApi","useFormState","Relevant","when","ArrayField","ArrayFieldWrapper","_useArrayField","ArrayFieldItem","scopedApi","itemState","getState","_formApi$getState","initialRender","arrayFieldItemApiValue","arrayFieldItemStateValue","Items","_ref5","_ref6","FormComponents","components","fieldMap","comp","logger$4","FormFields","onlyValidateSchema","schemaFields","computeFieldsFromSchema","_schema$properties","allOf","_schema$propertyOrder","propertyOrder","aIndex","bIndex","schemaField","ArrayField$1","conditional","subSchema","conditions","condition","defaultFieldMap","select","input","textarea","checkbox","radio","AddButton","useArrayFieldApi","onClick","useArrayFieldItemApi","debug$2","noop","FormController","_EventEmitter","ajv","allErrors","ajvValidate","compile","fieldsByName","fieldByName","onScreen","expectedRemovals","pulledOut","savedValues","pristine","invalid","submits","validating","submitting","dummyField","getErrors","setStep","back","setCurrent","setFormError","submitForm","screenValid","keyDown","getFormState","setValues","resetField","fieldExists","validateField","validated","touch","currentError","valid","component","Current","prevComponent","nextComponent","getAllTouched","_this2","notifier","JSPAN","toNotify","entries","_this3","validateYupSchema","_errors","validateAjvSchema","dataPath","keyword","missingProperty","validateFields","_errors2","keyCode","preventEnter","preventDefault","dontPreventDefault","alreadyRegistered","magicValue","expectedRemoval","isExpected","includedKey","find","includes","oldName","oldField","EventEmitter","logger$5","FormProvider","formState","useForm","logger$6","getApi","apiRef","onReset","onSubmit","onSubmitFailure","formControllerOptions","_useState4","setFormState","onResetHandler","onSubmitHandler","onValueHandler","onFailureHandler","onChangeHandlerRerender","debug$3","Form","renderProp","_useForm","onKeyDown","getContent","buildFieldApi","exists","useFieldApi","buildFieldState","useFieldState","Option","DEFAULT_NAMESPACE","ACTION_TYPE_DELIMITER","partialObject","element","isPlainObject","unflattenActionCreators","flatActionCreators","_temp","_ref$namespace","unflatten","flatActionType","partialNestedActionCreators","partialFlatActionTypePath","nextNamespace","camelCase","nestedActionCreators","getOwnPropertyNames","unprefixedType","createAction","payloadCreator","metaCreator","identity","isFunction","isNull","finalPayloadCreator","head","hasMeta","typeString","actionCreator","meta","_objectSpread","createActions","actionMap","identityActions","getLastElement","isString","actionCreatorsFromIdentityActions","actionCreatorsFromActionMap","flatActionMap","flattenActionMap","actionMapToActionCreators","arrayToObject","partialActionCreators","actionMapValue","isValidActionMapValue","isNil","_actionMapValue$","prefixedType","actionCreators","partialActionMap","_objectSpread3","_objectSpread4","isMap","hasGeneratorInterface","hasOnlyInterfaceNames","ownKey","handleActions","defaultState","flattenedReducerMap","flattenReducerMap","reducers","handleAction","reducer","types","isUndefined","throw","aReducer","nextReducer","throwReducer","actionType","predicate","flatten","partialFlatMap","partialFlatActionType","connectPrefix","connectNamespace","partials","mapValue","proto","createThunkMiddleware","extraArgument","dispatch","thunk","withExtraArgument","randomString","substring","ActionTypes","INIT","REPLACE","PROBE_UNKNOWN_ACTION","createStore","preloadedState","enhancer","currentReducer","currentState","currentListeners","nextListeners","isDispatching","ensureCanMutateNextListeners","isSubscribed","replaceReducer","outerSubscribe","observeState","getUndefinedStateErrorMessage","combineReducers","reducerKeys","finalReducers","shapeAssertionError","finalReducerKeys","assertReducerShape","combination","hasChanged","nextState","previousStateForKey","nextStateForKey","bindActionCreator","bindActionCreators","boundActionCreators","compose","funcs","applyMiddleware","middlewares","_dispatch","middlewareAPI","chain","middleware"],"mappings":";;;IAAWA,E,sBCEPC,EAAe,WACf,SAASA,cACLC,KAAKC,gBAAiB,QAAK,KAC/B,CAuDA,OAtDAF,YAAYG,UAAUC,4BAA8B,SAAUC,EAAaC,GACvEL,KAAKM,mBAAmBF,EAAaC,EACzC,EACAN,YAAYG,UAAUK,kBAAoB,SAAUC,GAChD,OAAOA,CACX,EACAT,YAAYG,UAAUO,SAAW,SAAUC,GAE3C,EACAX,YAAYG,UAAUS,GAAK,WACvB,MAAO,EACX,EACAZ,YAAYG,UAAUU,OAAS,SAAUC,GACrC,OAAO,CACX,EACAd,YAAYG,UAAUY,iBAAmB,SAAUN,GAC/C,OAAOA,CACX,EACAT,YAAYG,UAAUa,UAAY,SAAUF,EAASG,GAEjD,YADmB,IAAfA,IAAyBA,GAAa,GACnChB,KAAKiB,KAAK,CACbC,OAAQL,EAAQM,IAAM,aACtBC,MAAOP,EAAQO,MACfC,UAAWR,EAAQQ,UACnBL,WAAYA,GAEpB,EACAjB,YAAYG,UAAUoB,aAAe,SAAUT,EAASG,GAEpD,YADmB,IAAfA,IAAyBA,GAAa,GACnChB,KAAKiB,KAAK,CACbG,MAAOpB,KAAKC,eAAeY,EAAQU,SAAUV,EAAQW,cACrDH,UAAWR,EAAQQ,UACnBH,OAAQL,EAAQM,GAChBH,WAAYA,GAEpB,EACAjB,YAAYG,UAAUuB,WAAa,SAAUZ,GACzC,OAAOb,KAAK0B,MAAM,CACdC,OAAQd,EAAQM,IAAM,aACtBS,OAAQf,EAAQgB,KAChBT,MAAOP,EAAQO,MACfC,UAAWR,EAAQQ,UACnBS,UAAWjB,EAAQiB,WAE3B,EACA/B,YAAYG,UAAU6B,cAAgB,SAAUlB,GAC5C,OAAOb,KAAK0B,MAAM,CACdC,OAAQd,EAAQM,GAChBS,OAAQf,EAAQgB,KAChBR,UAAWR,EAAQQ,UACnBD,MAAOpB,KAAKC,eAAeY,EAAQU,SAAUV,EAAQW,cACrDM,UAAWjB,EAAQiB,WAE3B,EACO/B,WACX,CA3DkB;ADAfD,IAAUA,EAAQ,CAAC;AEFtB,IAAIkC,EACA,SAASA,EAAkBC,EAASC,EAAMd,EAAOC,GAC7CrB,KAAKiC,QAAUA,EACfjC,KAAKkC,KAAOA,EACZlC,KAAKoB,MAAQA,EACbpB,KAAKqB,UAAYA,CACrB,E,iCCLOc,EAASC,OAAOlC,UAAUmC;AAMrC,IAAIC,EAAmB;AAChB,SAAS,+BAAuBC,GACnC,IAAIC,EAAQD,EAAeC,MAAMF;AACjC,OAAOE,EAAQA,EAAM,GAAKD,CAC9B,CACO,SAASE,wBAAwBC,GACpC,OAAiB,OAAVA,GACc,iBAAVA,KACN,QAAYA,KACZC,MAAMC,QAAQF,EACvB,CACO,SAASG,uBAAuBH,GACnC,IAAII,EAAQJ,GAASA,EAAMK;AAC3B,OAAOD,IAAS,QAAQA,EAC5B,CAIA,IAAIE,yBAA2B,SAAUC,EAAgBC,EAAgBC,GACrE,IAAIC,EAAWH,EAAeE,GAC1BE,EAAWH,EAAeC;AAC9B,OAAIN,uBAAuBO,IACvBA,EAASE,QAAUtD,KAAKuD,MAAMH,EAASE,QAAST,uBAAuBQ,GACjEA,EAASC,QACTD,GACCD,GAEPP,uBAAuBQ,IACvBA,EAASC,QAAUtD,KAAKuD,MAAMH,EAAUC,EAASC,SAC1CD,GAEJrD,KAAKuD,MAAMH,EAAUC,EAChC,EClCIG,EAASpB,OAAOqB,OAAO,MACvBC,YAAc,WAAc,OAAOF,CAAQ,EAC3CG,EAAe,WACf,SAASA,YAAYC,EAAUC,GAC3B,IAAIC,EAAQ9D;AACZA,KAAK4D,SAAWA,EAChB5D,KAAK6D,MAAQA,EACb7D,KAAK6B,KAAOO,OAAOqB,OAAO,MAC1BzD,KAAK+D,QAAU3B,OAAOqB,OAAO,MAC7BzD,KAAKgE,KAAO5B,OAAOqB,OAAO,MAC1BzD,KAAKiE,cAAgB,SAAUC,EAAmB3B,GAAkB,OAAO,SAAgB,QAAY2B,GACjGJ,EAAMK,IAAID,EAAkBE,MAAO7B,GACnC2B,GAAqBA,EAAkB3B,GAAkB,EAC/DvC,KAAKqE,QAAU,SAAUC,GACrB,OAAO,QAAYA,GACbR,EAAMS,IAAID,EAASF,OACC,iBAAbE,CACjB,EACAtE,KAAKwE,YAAc,SAAUC,EAAcC,GACvC,GAA4B,iBAAjBD,EACP,OAAO,QAAcA;AAEzB,IAAI,QAAYA,GACZ,OAAOA;AAEX,IAAItD,EAAK2C,EAAMF,SAASnD,SAASgE,GAAc;AAC/C,GAAItD,EAAI,CACJ,IAAIwD,GAAM,QAAcxD;AAIxB,OAHIuD,GACAZ,EAAMP,MAAMpC,EAAIsD,GAEbE,CACX,CACJ,CACJ,CA2NA,OA1NAhB,YAAYzD,UAAU0E,SAAW,WAC7B,OAAO,QAAS,CAAC,EAAG5E,KAAK6B,KAC7B,EACA8B,YAAYzD,UAAUqE,IAAM,SAAU5C,GAClC,YAAqC,IAA9B3B,KAAK6E,OAAOlD,GAAQ,EAC/B,EACAgC,YAAYzD,UAAUiE,IAAM,SAAUxC,EAAQmD,GAE1C,GADA9E,KAAK6D,MAAMkB,OAAOpD,EAAQmD,GACtB3C,EAAO6C,KAAKhF,KAAK6B,KAAMF,GAAS,CAChC,IAAIsD,EAAcjF,KAAK6B,KAAKF;AAC5B,GAAIsD,GAAe9C,EAAO6C,KAAKC,EAAaH,GACxC,OAAOG,EAAYH,EAE3B,CACA,MAAkB,eAAdA,GACA3C,EAAO6C,KAAKhF,KAAK4D,SAASsB,kBAAmBvD,GACtC3B,KAAK4D,SAASsB,kBAAkBvD,GAEvC3B,gBAAgBmF,EACTnF,KAAKoF,OAAOjB,IAAIxC,EAAQmD,QADnC,CAGJ,EACAnB,YAAYzD,UAAU2E,OAAS,SAAUlD,EAAQ0D,GAG7C,OAFIA,GACArF,KAAK6D,MAAMkB,OAAOpD,EAAQ,YACvBQ,EAAO6C,KAAKhF,KAAK6B,KAAMF,GAAU3B,KAAK6B,KAAKF,GAC9C3B,gBAAgBmF,EAAQnF,KAAKoF,OAAOP,OAAOlD,EAAQ0D,QAAqB,CAChF,EACA1B,YAAYzD,UAAUqD,MAAQ,SAAU5B,EAAQ0B,GAC5C,IAAIS,EAAQ9D,KACRoD,EAAWpD,KAAK6E,OAAOlD,GACvB2D,EAAS,IAAI,KAAWC,uBAAuBhC,MAAMH,EAAUC;AAEnE,GADArD,KAAK6B,KAAKF,GAAU2D,EAChBA,IAAWlC,WACJpD,KAAKgE,KAAKrC,GACb3B,KAAK6D,MAAM2B,SAAS,CACpB,IAAIC,EAAkBrD,OAAOqB,OAAO;AAC/BL,IACDqC,EAAgBC,SAAW,GAC/BtD,OAAOuD,KAAKtC,GAAUuC,SAAQ,SAAUrD,GAC/Ba,GAAYA,EAASb,KAAoB+C,EAAO/C,KACjDkD,EAAgB,+BAAuBlD,IAAmB,OAC3B,IAA3B+C,EAAO/C,IAAgCuB,aAAiBqB,UACjDG,EAAO/C,GAG1B,IACAH,OAAOuD,KAAKF,GAAiBG,SAAQ,SAAUd,GAAa,OAAOhB,EAAMD,MAAMgC,MAAMlE,EAAQmD,EAAY,GAC7G,CAER,EACAnB,YAAYzD,UAAUU,OAAS,SAAUe,EAAQmE,GAC7C,IAAIhC,EAAQ9D,KACRiF,EAAcjF,KAAK6E,OAAOlD;AAC9B,GAAIsD,EAAa,CACb,IAAIc,EAAkB3D,OAAOqB,OAAO,MAChCuC,GAAgB,EAChBC,GAAe,EACfC,YAAc,SAAUC,EAAoBC,GAAQ,OAAOtC,EAAMF,SAASyC,UAAwC,iBAAvBF,EAAkC,CAC7HrB,UAAWqB,EACXC,KAAMA,IAAQ,QAAczE,IAC5BwE,EAAoB,CAAEG,MAAOxC,GAAU;AAgC3C,GA/BA1B,OAAOuD,KAAKV,GAAaW,SAAQ,SAAUrD,GACvC,IAAIuC,EAAY,+BAAuBvC,GACnCgE,EAAatB,EAAY1C;AAC7B,QAAmB,IAAfgE,EAAJ,CAEA,IAAI3F,EAA2B,mBAAXkF,EACdA,EACAA,EAAOvD,IAAmBuD,EAAOhB;AACvC,GAAIlE,EAAQ,CACR,IAAI4F,EAAW5F,IAAW8C,YAAcF,EACpC5C,GAAO,QAAgB2F,GAAa,CAChC/C,OAAQA,EACRsB,UAAWA,EACXvC,eAAgBA,EAChBkE,YAAa,KACbjC,YAAaV,EAAMU,YACnBH,QAASP,EAAMO,QACfgC,UAAWH;AAEfM,IAAahD,IACbgD,OAAW,GACXA,IAAaD,IACbR,EAAgBxD,GAAkBiE,EAClCR,GAAgB,EAChBO,EAAaC,EAErB,MACmB,IAAfD,IACAN,GAAe,EAxBT,CA0Bd,IACID,EAWA,OAVAhG,KAAKuD,MAAM5B,EAAQoE,GACfE,IACIjG,gBAAgBmF,EAChBnF,KAAK6B,KAAKF,QAAU,SAGb3B,KAAK6B,KAAKF,GAErB3B,KAAK6D,MAAMgC,MAAMlE,EAAQ,cAEtB,CAEf,CACA,OAAO,CACX,EACAgC,YAAYzD,UAAUwG,OAAS,SAAU/E,EAAQmD,EAAW6B,GACxD,IAAIC,EACA3B,EAAcjF,KAAK6E,OAAOlD;AAC9B,GAAIsD,EAAa,CACb,IAAI4B,EAAW7G,KAAKiE,cAAcgB,EAAa,cAC3C1C,EAAiBuC,GAAa6B,EAC5B3G,KAAK4D,SAASkD,kBAAkB,CAAED,SAAUA,EAAU/B,UAAWA,EAAW6B,KAAMA,IAClF7B;AACN,OAAO9E,KAAKY,OAAOe,EAAQY,IAAkBqE,EAAK,CAAC,GAC5CrE,GAAkBmB,YACrBkD,GAAMlD,YACd,CACA,OAAO,CACX,EACAC,YAAYzD,UAAU6G,MAAQ,SAAUlG,GACpC,IAAImG,GAAU;AAYd,OAXInG,EAAQM,KACJgB,EAAO6C,KAAKhF,KAAK6B,KAAMhB,EAAQM,MAC/B6F,EAAUhH,KAAK0G,OAAO7F,EAAQM,GAAIN,EAAQiE,UAAWjE,EAAQ8F,OAE7D3G,gBAAgBmF,IAChB6B,EAAUhH,KAAKoF,OAAO2B,MAAMlG,IAAYmG,IAExCnG,EAAQiE,WAAakC,IACrBhH,KAAK6D,MAAMgC,MAAMhF,EAAQM,GAAIN,EAAQiE,WAAa,aAGnDkC,CACX,EACArD,YAAYzD,UAAU+G,MAAQ,WAC1BjH,KAAKkH,QAAQ,KACjB,EACAvD,YAAYzD,UAAUgH,QAAU,SAAUC,GACtC,IAAIrD,EAAQ9D;AACZoC,OAAOuD,KAAK3F,KAAK6B,MAAM+D,SAAQ,SAAUjE,GAC/BwF,GAAWhF,EAAO6C,KAAKmC,EAASxF,IAClCmC,EAAM4C,OAAO/E,EAErB,IACIwF,GACA/E,OAAOuD,KAAKwB,GAASvB,SAAQ,SAAUjE,GACnCmC,EAAMP,MAAM5B,EAAQwF,EAAQxF,GAChC,GAER,EACAgC,YAAYzD,UAAUkH,OAAS,SAAUlG,GACrC,OAAOlB,KAAK+D,QAAQ7C,IAAWlB,KAAK+D,QAAQ7C,IAAW,GAAK,CAChE,EACAyC,YAAYzD,UAAUmH,QAAU,SAAUnG,GACtC,GAAIlB,KAAK+D,QAAQ7C,GAAU,EAAG,CAC1B,IAAIoG,IAAUtH,KAAK+D,QAAQ7C;AAG3B,OAFKoG,UACMtH,KAAK+D,QAAQ7C,GACjBoG,CACX,CACA,OAAO,CACX,EACA3D,YAAYzD,UAAUqH,aAAe,SAAUC,GAM3C,YALY,IAARA,IAAkBA,EAAM,IAAIC,KAChCrF,OAAOuD,KAAK3F,KAAK+D,SAAS6B,QAAQ4B,EAAIE,IAAKF,GACvCxH,gBAAgBmF,GAChBnF,KAAKoF,OAAOmC,aAAaC,GAEtBA,CACX,EACA7D,YAAYzD,UAAUS,GAAK,WACvB,IAAImD,EAAQ9D,KACRwH,EAAMxH,KAAKuH,eACXI,EAAW3H,KAAK4E;AACpB4C,EAAI5B,SAAQ,SAAUzE,GACdgB,EAAO6C,KAAK2C,EAAUxG,KACtBiB,OAAOuD,KAAK7B,EAAM8D,gBAAgBzG,IAAKyE,QAAQ4B,EAAIE,IAAKF,UACjDG,EAASxG,GAExB;AACA,IAAI0G,EAAczF,OAAOuD,KAAKgC;AAC9B,GAAIE,EAAYC,OAAQ,CAEpB,IADA,IAAIC,EAAS/H,KACN+H,aAAkB5C,GACrB4C,EAASA,EAAO3C;AACpByC,EAAYjC,SAAQ,SAAUzE,GAAM,OAAO4G,EAAOrB,OAAOvF,EAAK,GAClE,CACA,OAAO0G,CACX,EACAlE,YAAYzD,UAAU0H,gBAAkB,SAAUjG,GAC9C,IAAKQ,EAAO6C,KAAKhF,KAAKgE,KAAMrC,GAAS,CACjC,IAAIqG,EAAUhI,KAAKgE,KAAKrC,GAAUS,OAAOqB,OAAO,MAC5CwE,EAAY,IAAIR,IAAI,CAACzH,KAAK6B,KAAKF,KAC/BuG,cAAgB,SAAUC,GAAO,OAAe,OAARA,GAA+B,iBAARA,CAAkB;AACrFF,EAAUrC,SAAQ,SAAUuC,IACpB,QAAYA,GACZH,EAAQG,EAAI/D,QAAS,EAEhB8D,cAAcC,IACnB/F,OAAOgG,OAAOD,GACTE,OAAOH,eACPtC,QAAQqC,EAAUP,IAAKO,EAEpC,GACJ,CACA,OAAOjI,KAAKgE,KAAKrC,EACrB,EACAgC,YAAYzD,UAAUoI,aAAe,WAEjC,IADA,IAAI3B,EAAO,GACF4B,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpC5B,EAAK4B,GAAMC,UAAUD;AAEzB,OAAOvI,KAAK6D,MAAM4E,SAASC,YAAY/B,EAC3C,EACOhD,WACX,CA5PkB,GA8PdgF,EAAc,WACd,SAASA,WAAWnD,GAChBxF,KAAKwF,QAAUA,EACfxF,KAAK4I,EAAI,KACT5I,KAAKyI,SAAW,IAAI,KAAQ,MAC5BzI,KAAK4I,EAAIpD,GAAU,UAAQ,IAC/B,CAWA,OAVAmD,WAAWzI,UAAU6E,OAAS,SAAUpD,EAAQY,GACxCvC,KAAK4I,GACL5I,KAAK4I,EAAEC,WAAWlH,EAAQY,GAElC,EACAoG,WAAWzI,UAAU2F,MAAQ,SAAUlE,EAAQY,GACvCvC,KAAK4I,GACL5I,KAAK4I,EAAE/C,MAAMgD,WAAWlH,EAAQY,GAExC,EACOoG,UACX,CAlBiB;AAmBjB,SAASE,WAAWlH,EAAQY,GACxB,OAAO,+BAAuBA,GAAkB,IAAMZ,CAC1D,EACA,SAAWgC,GACP,IAAImF,EAAQ,SAAUC,GAElB,SAASD,KAAKlC,GACV,IAAIhD,EAAWgD,EAAGhD,SAAUoF,EAAKpC,EAAGqC,cAAeA,OAAuB,IAAPD,GAAuBA,EAAIE,EAAOtC,EAAGsC,KACpGpF,EAAQiF,EAAO/D,KAAKhF,KAAM4D,EAAU,IAAI+E,EAAWM,KAAmBjJ;AAI1E,OAHA8D,EAAMqF,iBAAmB,IAAIR,EAAWM,GACpCC,GACApF,EAAMoD,QAAQgC,GACXpF,CACX,CAOA,OAfA,QAAUgF,KAAMC,GAShBD,KAAK5I,UAAUkJ,SAAW,SAAUC,EAASC,GACzC,OAAO,IAAInE,EAAMkE,EAASrJ,KAAMsJ,EAAQtJ,KAAKmJ,iBACjD,EACAL,KAAK5I,UAAUqJ,YAAc,WACzB,OAAOvJ,IACX,EACO8I,IACX,CAjBW,CAiBTnF;AACFA,EAAYmF,KAAOA,CACtB,CApBD,CAoBGnF,IAAgBA,EAAc,CAAC;AAClC,IAAIwB,EAAS,SAAU4D,GAEnB,SAAS5D,MAAMhE,EAAIiE,EAAQkE,EAAQzF,GAC/B,IAAIC,EAAQiF,EAAO/D,KAAKhF,KAAMoF,EAAOxB,SAAUC,IAAU7D;AAMzD,OALA8D,EAAM3C,GAAKA,EACX2C,EAAMsB,OAASA,EACftB,EAAMwF,OAASA,EACfxF,EAAMD,MAAQA,EACdyF,EAAOxF,GACAA,CACX,CA4BA,OArCA,QAAUqB,MAAO4D,GAUjB5D,MAAMjF,UAAUkJ,SAAW,SAAUC,EAASC,GAC1C,OAAO,IAAInE,MAAMkE,EAASrJ,KAAMsJ,EAAQtJ,KAAK6D,MACjD,EACAsB,MAAMjF,UAAUqJ,YAAc,SAAUF,GACpC,IAAIvF,EAAQ9D,KACRoF,EAASpF,KAAKoF,OAAOmE,YAAYF;AACrC,OAAIA,IAAYrJ,KAAKmB,IACbnB,KAAK6D,MAAM2B,SACXpD,OAAOuD,KAAK3F,KAAK6B,MAAM+D,SAAQ,SAAUjE,GACjCmC,EAAMjC,KAAKF,KAAYyD,EAAOP,OAAOlD,IACrCmC,EAAM4C,OAAO/E,EAErB,IAEGyD,GAEPA,IAAWpF,KAAKoF,OACTpF,KACJoF,EAAOgE,SAASpJ,KAAKmB,GAAInB,KAAKsJ,OACzC,EACAnE,MAAMjF,UAAU0E,SAAW,WACvB,OAAO,SAAS,QAAS,CAAC,EAAG5E,KAAKoF,OAAOR,YAAa5E,KAAK6B,KAC/D,EACAsD,MAAMjF,UAAU0H,gBAAkB,SAAUjG,GACxC,IAAI6H,EAAaxJ,KAAKoF,OAAOwC,gBAAgBjG;AAC7C,OAAOQ,EAAO6C,KAAKhF,KAAK6B,KAAMF,IAAU,SAAS,QAAS,CAAC,EAAG6H,GAAaT,EAAO7I,UAAU0H,gBAAgB5C,KAAKhF,KAAM2B,IAAW6H,CACtI,EACOrE,KACX,CAvCY,CAuCVxB;AACF,SAAS4B,sBAAsBtC,EAAgBC,EAAgBC,GAC3D,IAAIsG,EAAgBxG,EAAeE,GAC/BuG,EAAgBxG,EAAeC;AACnC,OAAO,OAAMsG,EAAeC,GAAiBD,EAAgBC,CACjE,CACO,SAASC,sBAAsBrD,GAClC,SAAUA,aAAiB3C,GAAe2C,EAAMzC,MAAM2B,QAC1D,CCvVA,SAASoE,qBAAqBC,EAAKC,GAC/B,OAAO,IAAI9H,EAAkB6H,EAAI5H,QAAS6H,EAAQ5H,KAAK6H,QAASD,EAAQ1I,MAAO0I,EAAQzI,UAC3F,CACA,IAAI2I,EAAe,WACf,SAASA,YAAYC,GACjB,IAAInG,EAAQ9D;AACZA,KAAKiK,OAASA,EACdjK,KAAKkK,qBAAsB,SAAK,SAAUrJ,GAAW,OAAOiD,EAAMqG,qBAAqBtJ,EAAU,GAAG,CAChGuJ,QAAS,SAAUvJ,GACf,MAAO,CACHA,EAAQwJ,aACRxJ,EAAQqD,kBACRrD,EAAQiJ,QAEhB,EACAxB,aAAc,SAAU+B,EAAcjF,EAAQ0E,GAC1C,GAAIH,sBAAsBG,EAAQxD,OAC9B,OAAOwD,EAAQxD,MAAMgC,aAAa+B,GAAc,QAAYjF,GAAUA,EAAOhB,MAAQgB,EAAQ0E,EAAQQ,UAE7G,IAEJtK,KAAKuK,aAAe,IAAIC,QACxBxK,KAAKyK,yBAA0B,SAAK,SAAU5J,GAC1C,OAAOiD,EAAM4G,yBAAyB7J,EAC1C,GAAG,CACCyH,aAAc,SAAU1B,GACpB,IAAI9D,EAAQ8D,EAAG9D,MAAO6H,EAAQ/D,EAAG+D,MAAOb,EAAUlD,EAAGkD;AACrD,GAAIH,sBAAsBG,EAAQxD,OAC9B,OAAOwD,EAAQxD,MAAMgC,aAAaxF,EAAO6H,EAAOb,EAAQQ,UAEhE,IAEJtK,KAAKiK,QAAS,QAAS,CAAEW,aAAa,GAAQX,EAClD,CAqLA,OApLAD,YAAY9J,UAAU2K,mBAAqB,SAAUhK,GACjD,OAAOb,KAAK8K,uBAAsB,SAAS,QAAS,CAAC,EAAGjK,GAAU,CAAEkK,mBAAmB,KAAUnJ,MACrG,EACAoI,YAAY9J,UAAU4K,sBAAwB,SAAUlE,GACpD,IAAIN,EAAQM,EAAGN,MAAOlF,EAAQwF,EAAGxF,MAAO4H,EAAKpC,EAAG1F,OAAQA,OAAgB,IAAP8H,EAAgB,aAAeA,EAAI3H,EAAYuF,EAAGvF,UAAW2J,EAAKpE,EAAGmE,kBAAmBA,OAA2B,IAAPC,GAAuBA,EAChMpH,EAAW5D,KAAKiK,OAAOgB,MAAMrH;AACjCvC,GAAY,SAAS,QAAS,CAAC,GAAG,SAAiB,QAAmBD,KAAUC;AAChF,IAAI6J,EAAalL,KAAKkK,oBAAoB,CACtCG,cAAc,QAAkBjJ,GAAOiJ,aACvCnG,mBAAmB,QAAchD,GACjC4I,QAAS,CACLxD,MAAOA,EACPlF,MAAOA,EACPwC,SAAUA,EACVvC,UAAWA,EACXiJ,UAAWa,KAAKC,UAAU/J,GAC1BgK,aAAa,QAAkB,QAAuBjK,IACtDc,KAAM,MAGVoJ,EAAmBJ,EAAWK,SAAWL,EAAWK,QAAQzD,OAAS;AACzE,GAAIwD,IAAqBP,EACrB,MAAMG,EAAWK,QAAQ;AAE7B,MAAO,CACH3J,OAAQsJ,EAAWtJ,OACnB2J,QAASL,EAAWK,QACpBC,UAAWF,EAEnB,EACAtB,YAAY9J,UAAUuL,QAAU,SAAU7J,EAAQwD,EAAQiF,EAAcP,GACpE,GAAIH,sBAAsBG,EAAQxD,QAC9BtG,KAAKuK,aAAapG,IAAIvC,KAAYyI,EAAc,CAChD,IAAIqB,EAAS1L,KAAKkK,oBAAoByB,KAAKtB,EAAcjF,EAAQ0E;AACjE,GAAI4B,GAAU9J,IAAW8J,EAAO9J,OAC5B,OAAO,CAEf,CACA,OAAO,CACX,EACAoI,YAAY9J,UAAUiK,qBAAuB,SAAUvD,GACnD,IAAI9C,EAAQ9D,KACRqK,EAAezD,EAAGyD,aAAcnG,EAAoB0C,EAAG1C,kBAAmB4F,EAAUlD,EAAGkD;AAC3F,IAAI,QAAY5F,KACX4F,EAAQlG,SAASsB,kBAAkBhB,EAAkBE,SACrD0F,EAAQxD,MAAM/B,IAAIL,EAAkBE,OACrC,MAAO,CACHxC,OAAQ,CAAC,EACT2J,QAAS,CAAC3B,qBAA6D,IAAI,KAAe,GAAiGE;AAGnM,IAAIuB,EAAcvB,EAAQuB,YAAahK,EAAYyI,EAAQzI,UAAWuC,EAAWkG,EAAQlG,SAAU0C,EAAQwD,EAAQxD,MAC/GsF,EAAiB,GACjBC,EAAc,CAAEjK,OAAQ,MACxBiF,EAAWP,EAAMrC,cAAcC,EAAmB;AAMtD,SAAS4H,aACL,OAAOD,EAAYN,UAAYM,EAAYN,QAAU,GACzD,CACA,SAASQ,cAAcnK,GACnB,IAAIgF;AAGJ,OAFIhF,EAAO2J,UACN3E,EAAKkF,cAAcE,KAAKC,MAAMrF,EAAIhF,EAAO2J,SACvC3J,EAAOA,MAClB,CAbI5B,KAAKiK,OAAOW,aACQ,iBAAb/D,IACNjD,EAASsI,kBAAkBrF,IAC5B+E,EAAeI,KAAK,CAAEG,WAAYtF;AAWtC,IAAIuF,EAAU,IAAI3E,IAAI4C,EAAagC;AAgEnC,OA/DAD,EAAQxG,SAAQ,SAAU0G,GACtB,IAAI1F;AACJ,IAAK,QAAc0F,EAAWjL,GAE9B,IAAI,QAAQiL,GAAY,CACpB,IAAI/F,EAAa3C,EAASyC,UAAU,CAChCvB,UAAWwH,EAAUC,KAAK7J,MAC1BI,MAAOwJ,EACPjL,UAAWyI,EAAQzI,UACnB+E,KAAMlC,GACP4F,GACC0C,GAAa,QAAuBF;AACxCxC,EAAQ5H,KAAK8J,KAAKQ,QACC,IAAfjG,EACK,WAA4B+F,IAC7BR,aAAaE,KAAKpC,qBAA6D,IAAI,KAAe,GAElCE,IAG/DnH,MAAMC,QAAQ2D,GACnBA,EAAawF,cAAcjI,EAAM2G,wBAAwB,CACrD3H,MAAOwJ,EACP3B,MAAOpE,EACPuD,QAASA,KAGPwC,EAAUjC,cAMG,MAAd9D,IACLA,EAAawF,cAAcjI,EAAMoG,oBAAoB,CACjDG,aAAciC,EAAUjC,aACxBnG,kBAAmBqC,EACnBuD,QAASA,WAGE,IAAfvD,GACAqF,EAAeI,OAAMpF,EAAK,CAAC,GAAM4F,GAAcjG,EAAYK,KAE/D,QAAUkD,EAAQ5H,KAAKuK,QAAUD,EACrC,KACK,CACD,IAAIjL,OAAW,GACX,QAAiB+K,GACjB/K,EAAW+K,GAG6B,QAAU/K,EAAW8J,EAAYiB,EAAUC,KAAK7J,OAAQ,GAEhGkB,EAAS8I,gBAAgBnL,EAAUsF,IACnCtF,EAAS8I,aAAagC,WAAWzG,QAAQwG,EAAQ1E,IAAK0E,EAE9D,CACJ,IACAP,EAAYjK,QAAS,QAAegK,GAIpC5L,KAAKuK,aAAaoC,IAAId,EAAYjK,OAAQyI,GACnCwB,CACX,EACA7B,YAAY9J,UAAUwK,yBAA2B,SAAU9D,GACvD,IAEI2E,EAFAzH,EAAQ9D,KACR8C,EAAQ8D,EAAG9D,MAAO6H,EAAQ/D,EAAG+D,MAAOb,EAAUlD,EAAGkD;AAErD,SAASiC,cAAca,EAAaC,GAMhC,OALID,EAAYrB,UACZA,EAAUA,GAAW,IACbS,KAAKC,MAAMV,EAASqB,EAAYrB,UAE5C,QAAUzB,EAAQ5H,KAAKuK,QAAUI,GAC1BD,EAAYhL,MACvB,CAgCA,OA/BIkB,EAAMuH,eACNM,EAAQA,EAAMtC,OAAOyB,EAAQxD,MAAMjC,UA8BhC,CAAEzC,OA5BT+I,EAAQA,EAAMmC,KAAI,SAAUC,EAAMF,GAC9B,OAAa,OAATE,EACO,MAEXjD,EAAQ5H,KAAK8J,KAAKa,GACdlK,MAAMC,QAAQmK,GACPhB,cAAcjI,EAAM2G,wBAAwB,CAC/C3H,MAAOA,EACP6H,MAAOoC,EACPjD,QAASA,IACT+C,GAEJ/J,EAAMuH,aACC0B,cAAcjI,EAAMoG,oBAAoB,CAC3CG,aAAcvH,EAAMuH,aACpBnG,kBAAmB6I,EACnBjD,QAASA,IACT+C,KAKR,QAAU/C,EAAQ5H,KAAKuK,QAAUI,GAC1BE,GACX,IAIwBxB,QAASA,EACrC,EACOvB,WACX,CApNkB;ACLlB,IAAIgD,EAAe,WACf,SAASA,YAAY/B,EAAOgC,GACxBjN,KAAKiL,MAAQA,EACbjL,KAAKiN,OAASA,CAClB,CAiIA,OAhIAD,YAAY9M,UAAUgN,aAAe,SAAUtG,GAC3C,IAAIxF,EAAQwF,EAAGxF,MAAOQ,EAASgF,EAAGhF,OAAQD,EAASiF,EAAGjF,OAAQ2E,EAAQM,EAAGN,MAAOjF,EAAYuF,EAAGvF,UAC3F8L,GAAsB,QAAuB/L,GAC7CgM,EHQL,SAASC,4BACZ,OAAO,IAAI,KAAWrK,yBAC1B,CGVqBqK;AACbhM,GAAY,SAAS,QAAS,CAAC,GAAG,QAAiB8L,IAAuB9L;AAC1E,IAAIiD,EAAWtE,KAAKsN,oBAAoB,CACpC1L,OAAQA,GAAUQ,OAAOqB,OAAO,MAChC9B,OAAQA,EACR0I,aAAc8C,EAAoB9C,aAClCP,QAAS,CACLxD,MAAOA,EACPiH,QAASnL,OAAOqB,OAAO,MACvBF,MAAO,SAAUH,EAAUC,GACvB,OAAO+J,EAAO7J,MAAMH,EAAUC,EAClC,EACAhC,UAAWA,EACXiJ,UAAWa,KAAKC,UAAU/J,GAC1BgK,aAAa,QAAkB,QAAuBjK,OAG1DuD,GAAM,QAAYL,GAAYA,EAC9B3C,IAAU,QAAcA,SAAW;AAIvC,OAHIgD,GACA2B,EAAMc,OAAOzC,EAAIP,OAEdO,CACX,EACAqI,YAAY9M,UAAUoN,oBAAsB,SAAU1G,GAClD,IAAI9C,EAAQ9D,KACR2B,EAASiF,EAAGjF,OAAQC,EAASgF,EAAGhF,OAAQyI,EAAezD,EAAGyD,aAAcP,EAAUlD,EAAGkD,QAASd,EAAKpC,EAAG4G,IAAKA,OAAa,IAAPxE,EAAgB,CACjIyE,mBAAmB,GACnBzE,EACApF,EAAW5D,KAAKiL,MAAMrH,SACtBoH,EAAKpH,EAASnD,SAASmB,EAAQyI,EAAcP,EAAQuB,aAAclK,EAAK6J,EAAG,GAAI0C,EAAY1C,EAAG;AAElG,GAAI,iBADJrJ,EAASA,GAAUR,GACa,CAC5B,IAAIwM,EAAO7D,EAAQyD,QAAQ5L,KAAYmI,EAAQyD,QAAQ5L,GAAU,IAC7DgD,GAAM,QAAchD;AACxB,GAAIgM,EAAKC,QAAQvD,IAAiB,EAC9B,OAAO1F;AAEX,GADAgJ,EAAK3B,KAAK3B,GACNrK,KAAKiN,QAAUjN,KAAKiN,OAAOxB,QAAQ7J,EAAQ+C,EAAK0F,EAAcP,GAC9D,OAAOnF,CAEf,CACA,IAAIkJ,EAAezL,OAAOqB,OAAO;AAC7BiK,IACAG,EAAe/D,EAAQvG,MAAMsK,EAAcH;AAE/C,IAAI7G,EAAYlF,GAAUiC,EAASsB,kBAAkBvD,KACjD,QAAsBC,EAAQyI,EAAcP,EAAQuB,cACnD1J,GAAUmI,EAAQxD,MAAMnC,IAAIxC,EAAQ;AACrC,iBAAoBkF,IACpBgH,EAAa1B,WAAatF;AAE9B,IAAIuF,EAAU,IAAI3E,IAAI4C,EAAagC;AAwCnC,GAvCAD,EAAQxG,SAAQ,SAAU0G,GACtB,IAAI1F;AACJ,IAAK,QAAc0F,EAAWxC,EAAQzI,WAEtC,IAAI,QAAQiL,GAAY,CACpB,IAAIwB,GAAiB,QAAuBxB,GACxC5J,EAAQd,EAAOkM;AACnB,QAAqB,IAAVpL,EAAuB,CAC9B,IAAIH,EAAiBqB,EAASkD,kBAAkB,CAC5CD,SAAUA,EACV/B,UAAWwH,EAAUC,KAAK7J,MAC1BI,MAAOwJ,EACPjL,UAAWyI,EAAQzI,YAEnBqI,EAAgB5F,EAAMiK,kBAAkBrL,EAAO4J,EAAWxC,EAAS0D;AACnE5J,EAASoK,iBAAiBnH,EAAUyF,EAAUC,KAAK7J,SACnDgH,EAAgB,CACZ3G,QAASuJ,EACTH,WAAYtF,EACZvD,QAASoG,GAEb8D,EAAIC,mBAAoB,GAE5BI,EAAe/D,EAAQvG,MAAMsK,IAAejH,EAAK,CAAC,GAC3CrE,GAAkBmH,EACrB9C,GACR,MACK,GAAIhD,EAASqK,sBACb,QAAc,CAAC,QAAS,UAAW3B,GACpC,MAA8C,IAAI,KAAe,EAEzE,KACK,CACD,IAAI/K,GAAW,QAAyB+K,EAAWxC,EAAQuB;AACvD9J,GAAYqC,EAAS8I,gBAAgBnL,EAAUsF,IAC/CtF,EAAS8I,aAAagC,WAAWzG,QAAQwG,EAAQ1E,IAAK0E,EAE9D,CACJ,IACI,iBAAoBzK,EAAQ,CAC5B,IAAIuM,GAAc,QAAcvM;AAahC,OAZI6L,EAAIC,oBACJI,EAAejK,EAASuK,YAAYD,EAAaL,EAAc/D,IAUnEA,EAAQxD,MAAM/C,MAAM5B,EAAQkM,GACrBK,CACX,CACA,OAAOL,CACX,EACAb,YAAY9M,UAAU6N,kBAAoB,SAAUrL,EAAOI,EAAOgH,EAAS0D,GACvE,IAAI1J,EAAQ9D;AACZ,OAAK8C,EAAMuH,cAA0B,OAAV3H,EAGvBC,MAAMC,QAAQF,GACPA,EAAMoK,KAAI,SAAUC,GAAQ,OAAOjJ,EAAMiK,kBAAkBhB,EAAMjK,EAAOgH,EAAS0D,EAAM,IAE3FxN,KAAKsN,oBAAoB,CAC5B1L,OAAQc,EACR2H,aAAcvH,EAAMuH,aACpBP,QAASA,EACT0D,IAAKA,IAT0C9K,CAWvD,EACOsK,WACX,CAtIkB;AAwIH,IAAIvF;eC5If2G,GAAS,UACFC,EAAY,IAAI;AACpB,SAASC,QAAQ5L,GACpB,IAAI6L,EAAS,IAAI9G;AACjB,OAAO,SAAS+G,GAAGhI,GACf,GAAIgC,UAAUV,OAAS,EACfpF,IAAU8D,IACV9D,EAAQ8D,EACR4H,EAAOvI,MAAM2I,IACbD,EAAO3I,QAAQ9D;IAGlB,CACD,IAAImJ,EAAQoD,EAAUI;AAClBxD,GACAsD,EAAO7G,IAAIuD,GACfmD,EAAOI,GACX,CACA,OAAO9L,CACX,CACJ,CACA,SAASZ,UAAUmJ,GACXA,EAAMyD,kBACNzD,EAAMyD,kBAEd,CCrBA,SAASC,uBAAuBC,GAC5B,YAAqB,IAAdA,EAAKjI,KAAkBiI,EAAKjI,KAC/BiI,EAAK9L,OAAQ,QAAyB8L,EAAK9L,MAAO8L,EAAKvN,WAAa,IAC5E,CACO,IAAIwN,wBAA0B,SAAUjI,EAAIkD,GAC/C,IAAIqC,EAAavF,EAAGuF,WAAYhL,EAAKyF,EAAGzF,GAAI2N,EAAMlI,EAAGkI;AACrD,GAA0B,iBAAf3C,IACHrC,IACAA,EAAQ4D,eACG,IAAPvM,EAAgB,CAAEA,GAAIA,QACV,IAAR2N,EAAiB,CAAEA,IAAKA,QACpB,QAEL,IAAP3N,IACAA,EAAK2N,QACE,IAAP3N,GACA,OAAOgL,EAAa,KAAsB,iBAAPhL,GACjB,iBAAPA,EAAmBA,EAAKgK,KAAKC,UAAUjK,GAG9D,EACI4N,gBAAkB,WAA6B,EAC/CC,gBAAkB,SAAUC,EAAOnF,GAAW,OAAOA,EAAQhF,SAAW,EACxEoK,YAAc,SAAU9L,EAAUC,EAAUuD,GAE5C,OAAOuI,EADYvI,EAAGuI,cACF/L,EAAUC,EAClC,EACI+L,aAAe,SAAUC,EAAGhM,GAAY,OAAOA,CAAU,EACzDiM,EAAY,WACZ,SAASA,SAASrF,GACdjK,KAAKiK,OAASA,EACdjK,KAAKuP,aAAenN,OAAOqB,OAAO,MAClCzD,KAAKkM,kBAAoB9J,OAAOqB,OAAO,MACvCzD,KAAKkF,kBAAoB9C,OAAOqB,OAAO,MACvCzD,KAAKiO,oBAAqB,EAC1BjO,KAAKwP,YAAc,IAAI,MAAQ,GAC/BxP,KAAKiK,QAAS,QAAS,CAAEwF,iBAAkBZ,yBAA2B5E,GACtEjK,KAAKiL,MAAQjL,KAAKiK,OAAOgB,MACzBjL,KAAK0P,gBAAgB,SACrB1P,KAAK0P,gBAAgB,YACrB1P,KAAK0P,gBAAgB,gBACjBzF,EAAO0F,eACP3P,KAAK4P,iBAAiB3F,EAAO0F,eAE7B1F,EAAOsF,cACPvP,KAAK6P,gBAAgB5F,EAAOsF,aAEpC,CAgPA,OA/OAD,SAASpP,UAAUO,SAAW,SAAUC,EAAQ2J,EAAcgB,GAC1D,IAAIxE,EAAWwD,GAAgBgB,GACzB,QAAsB3K,EAAQ2J,EAAcgB,GAC5C3K,EAAOyL;AACb,GAAItF,IAAa7G,KAAKkF,kBAAkB4K,WACpC,MAAO,CAAC;AAUZ,IARA,IAKI3O,EALA2I,EAAU,CACVjD,SAAUA,EACVwD,aAAcA,EACdgB,YAAaA,GAGb0E,EAAS/P,KAAKgQ,cAAcnJ,GAAU,GACtCoJ,EAAQF,GAAUA,EAAOE,OAASjQ,KAAKiK,OAAOwF,iBAC3CQ,GAAO,CACV,IAAIC,EAAgBD,EAAMvP,EAAQoJ;AAClC,IAAInH,MAAMC,QAAQsN,GAGb,CACD/O,EAAK+O;AACL,KACJ,CALID,EAAQE,yBAAyBD,EAMzC,CAEA,OADA/O,EAAKA,GAAMiP,OAAOjP,GACX2I,EAAQ4D,UAAY,CAACvM,EAAI2I,EAAQ4D,WAAa,CAACvM,EAC1D,EACAmO,SAASpP,UAAU2P,gBAAkB,SAAUN,GAC3C,IAAIzL,EAAQ9D;AACZoC,OAAOuD,KAAK4J,GAAc3J,SAAQ,SAAUiB,GACxC,IAAIzD,EAAWU,EAAMkM,cAAcnJ,GAAU,GACzCxD,EAAWkM,EAAa1I,GACxBwJ,EAAYhN,EAASgN,UAAWvK,EAASzC,EAASyC;AAClDzC,EAASiN,WACTxM,EAAM4L,gBAAgB,QAAS7I,GAC/BxD,EAASkN,cACTzM,EAAM4L,gBAAgB,WAAY7I,GAClCxD,EAASmN,kBACT1M,EAAM4L,gBAAgB,eAAgB7I,GAC1CzD,EAAS6M,OACS,IAAdI,EAAsBtB,gBAClBpM,MAAMC,QAAQyN,GAAaF,yBAAyBE,GAC3B,mBAAdA,EAA2BA,EAC9BjN,EAAS6M,MACrBnK,GACA1D,OAAOuD,KAAKG,GAAQF,SAAQ,SAAUd,GAClC,IAAI1B,EAAWU,EAAM2M,eAAe5J,EAAU/B,GAAW,GACrDzB,EAAWyC,EAAOhB;AACtB,GAAwB,mBAAbzB,EACPD,EAASnC,KAAOoC;IAEf,CACD,IAAI+G,EAAU/G,EAAS+G,QAASnJ,EAAOoC,EAASpC,KAAMsC,EAAQF,EAASE;AACvEH,EAAS6M,OACO,IAAZ7F,EAAoB4E,gBAChBrM,MAAMC,QAAQwH,GAAWsG,uBAAuBtG,GACzB,mBAAZA,EAAyBA,EAC5BhH,EAAS6M,MACL,mBAAThP,IACPmC,EAASnC,KAAOA,GACpBmC,EAASG,MACY,mBAAVA,EAAuBA,GAChB,IAAVA,EAAiB2L,aACH,IAAV3L,EAAkB6L,aACdhM,EAASG,KAC7B,CACIH,EAASnC,MAAQmC,EAASG,QAC1BH,EAAS6M,MAAQ7M,EAAS6M,OAASjB,gBAE3C,GAER,GACJ,EACAM,SAASpP,UAAUwP,gBAAkB,SAAUiB,EAAO9J,QACjC,IAAbA,IAAuBA,EAAW8J;AACtC,IAAIzP,EAAS,QAAUyP,EAAMC,cACzBC,EAAM7Q,KAAKkF,kBAAkBhE;AAC7B2F,IAAagK,KAC2B,SAAWA,GAAOA,IAAQF,EAAO,GACrEE,UACO7Q,KAAKkM,kBAAkB2E,GAClC7Q,KAAKkM,kBAAkBrF,GAAY3F,EACnClB,KAAKkF,kBAAkBhE,GAAU2F,EAEzC,EACAyI,SAASpP,UAAU0P,iBAAmB,SAAUD,GAC5C,IAAI7L,EAAQ9D;AACZA,KAAKiO,oBAAqB,EAC1B7L,OAAOuD,KAAKgK,GAAe/J,SAAQ,SAAUkL,GACzC,IAAIC,EAAajN,EAAMkN,cAAcF,GAAW;AAChDnB,EAAcmB,GAAWlL,QAAQmL,EAAWrJ,IAAKqJ,EACrD,GACJ,EACAzB,SAASpP,UAAU8P,cAAgB,SAAUnJ,EAAUoK,GACnD,GAAIpK,EACA,OAAO7G,KAAKuP,aAAa1I,IAAcoK,IAAoBjR,KAAKuP,aAAa1I,GAAYzE,OAAOqB,OAAO,MAE/G,EACA6L,SAASpP,UAAU8Q,cAAgB,SAAUF,EAAWG,GACpD,IAAIlB,EAAS/P,KAAKgQ,cAAcc,EAAWG;AAC3C,GAAIlB,EACA,OAAOA,EAAOmB,WAAaD,EAAkBlB,EAAOmB,SAAW,IAAIzJ,SAAQ,EAEnF,EACA6H,SAASpP,UAAUuQ,eAAiB,SAAU5J,EAAU/B,EAAWmM,GAC/D,IAAIE,EAAanR,KAAKgQ,cAAcnJ,EAAUoK;AAC9C,GAAIE,EAAY,CACZ,IAAIC,EAAgBD,EAAWrL,QAAWmL,IAAoBE,EAAWrL,OAAS1D,OAAOqB,OAAO;AAChG,GAAI2N,EACA,OAAOA,EAActM,IAAemM,IAAoBG,EAActM,GAAa1C,OAAOqB,OAAO,MAEzG,CACJ,EACA6L,SAASpP,UAAUwM,gBAAkB,SAAUnL,EAAUsF,GACrD,IAAI/C,EAAQ9D;AACZ,IAAKuB,EAAS8P,cACV,OAAO;AACX,IAAKxK,EACD,OAAO;AACX,IAAIiK,EAAYvP,EAAS8P,cAAc9E,KAAK7J;AAC5C,GAAImE,IAAaiK,EACb,OAAO;AACX,GAAI9Q,KAAKiO,mBAEL,IADA,IAAIqD,EAAc,CAACtR,KAAKgR,cAAcF,GAAW,IACxCjE,EAAI,EAAGA,EAAIyE,EAAYxJ,SAAU+E,EAAG,CACzC,IAAIqE,EAAWI,EAAYzE;AAC3B,GAAIqE,EAAU,CACV,GAAIA,EAAS3M,IAAIsC,GACb,OAAO;AACXqK,EAAStL,SAAQ,SAAU2L,GACvB,IAAIC,EAAc1N,EAAMkN,cAAcO,GAAS;AAC3CC,GAAeF,EAAY1D,QAAQ4D,GAAe,GAClDF,EAAYtF,KAAKwF,EAEzB,GACJ,CACJ,CAEJ,OAAO,CACX,EACAlC,SAASpP,UAAU4G,kBAAoB,SAAU2K,GAC7C,IAEIlP,EAFAsE,EAAW4K,EAAU5K,SAAU/B,EAAY2M,EAAU3M,UACrDiL,EAAS/P,KAAKyQ,eAAe5J,EAAU/B,GAAW,GAElDmL,EAAQF,GAAUA,EAAOE;AAC7B,GAAIA,GAASpJ,EAQT,IAPA,IAAIiD,EAAU,CACVjD,SAAUA,EACV/B,UAAWA,EACXhC,MAAO2O,EAAU3O,OAAS,KAC1BzB,UAAWoQ,EAAUpQ,WAErBsF,EAAOgI,uBAAuB8C,GAC3BxB,GAAO,CACV,IAAIyB,EAAoBzB,EAAMtJ,EAAMmD;AACpC,IAAInH,MAAMC,QAAQ8O,GAGb,CACDnP,EAAiBmP,GAAqB5M;AACtC,KACJ,CALImL,EAAQS,uBAAuBgB,EAMvC,CAOJ,YALuB,IAAnBnP,IACAA,EAAiBkP,EAAU3O,OACrB,QAAsB2O,EAAU3O,MAAO2O,EAAUpQ,YACjD,QAAgByD,EAAW6J,uBAAuB8C,KAErD3M,IAAc,+BAAuBvC,GACtCA,EACAuC,EAAY,IAAMvC,CAC5B,EACA+M,SAASpP,UAAUmG,UAAY,SAAUxF,EAASiJ,GAC9C,IAAI5F,EAAoBrD,EAAQuF;AAChC,GAAKlC,IAEarD,EAAQiC,OAASjC,EAAQiE,WAC3C,CAEA,QAAyB,IAArBjE,EAAQgG,SAAqB,CAC7B,IAAIA,EAAWiD,EAAQxD,MAAMrC,cAAcC,EAAmB;AAC1D2C,IACAhG,EAAQgG,SAAWA,EAC3B,CACA,IAAItE,EAAiBvC,KAAK8G,kBAAkBjG,GACxCiE,EAAY,+BAAuBvC,GACnCa,EAAW0G,EAAQxD,MAAMrC,cAAcC,EAAmB3B,GAC1DwN,EAAS/P,KAAKyQ,eAAe5P,EAAQgG,SAAU/B,GAAW,GAC1D7D,EAAO8O,GAAUA,EAAO9O;AAC5B,GAAIA,EAAM,CACN,IAAI0Q,EAAcC,yBAAyB5R,KAAMkE,EAAmBrD,EAASiJ,EAAS9J,KAAKwP,YAAY3K,QAAO,QAAYX,GACpHA,EAAkBE,MAClBF,EAAmB3B;AACzB,OAAO8L,EAAUwD,UAAU7R,KAAKiL,MAAOhK,EAAM,CAACmC,EAAUuO,GAC5D,CACA,OAAOvO,CAjBG,CAkBd,EACAkM,SAASpP,UAAU8N,iBAAmB,SAAUnH,EAAU/B,GACtD,IAAIiL,EAAS/P,KAAKyQ,eAAe5J,EAAU/B,GAAW;AACtD,SAAUiL,IAAUA,EAAOxM,MAC/B,EACA+L,SAASpP,UAAUiO,YAAc,SAAU/K,EAAUC,EAAUyG,EAASgI,GACpE,IAAIhO,EAAQ9D;AACZ,GAAI6C,uBAAuBQ,GAAW,CAClC,IAAIP,EAAQO,EAASN,QACjB+B,EAAYhC,EAAMyJ,KAAK7J,MACvBa,EAAQvD,KAAKyQ,eAAepN,EAAS8I,WAAYrH,GAAW,GAAOvB,MACnEwO,EAAUD,EACR9R,KAAKwP,YAAY9G,YAAYoJ,GAC7B;AACNzO,EAAWE,EAAMH,EAAUC,EAASC,QAASsO,yBAAyB5R,UAAM,EAAQ,CAAE6G,SAAUxD,EAAS8I,WAAYrH,UAAWA,EAC5HhC,MAAOA,EAAOzB,UAAWyI,EAAQzI,WAAayI,EAASiI,GAC/D,CACA,GAAIpP,MAAMC,QAAQS,GACd,OAAOA,EAASyJ,KAAI,SAAUC,GAAQ,OAAOjJ,EAAMqK,iBAAY,EAAQpB,EAAMjD,EAAU;AAE3F,GAAIrH,wBAAwBY,GAAW,CACnC,IAKI2O,EALAC,EAAM7O,EACN8O,EAAM7O,EACN8O,GAAoB,QAAYF,GAC9BA,EAAI7N,MACW,iBAAR6N,GAAoBA;AAUjC,GARA7P,OAAOuD,KAAKuM,GAAKtM,SAAQ,SAAUrD,GAC/B,IAAImH,EAAgBwI,EAAI3P,GACpB6P,EAAetO,EAAMqK,YAAYrE,EAAQxD,MAAMrC,cAAcgO,EAAK1P,GAAiBmH,EAAeI,EAASqI,EAAoB,CAACA,EAAmB5P,QAAkB;AACrK6P,IAAiB1I,KACjBsI,EAAcA,GAAe5P,OAAOqB,OAAO,OAC/BlB,GAAkB6P,EAEtC,IACIJ,EACA,OAAO,SAAS,QAAS,CAAC,EAAGE,GAAMF,EAE3C,CACA,OAAO3O,CACX,EACOiM,QACX,CApQe;AAsQf,SAASsC,yBAAyBhO,EAAUM,EAAmBuN,EAAW3H,EAASiI,GAC/E,IAAIxP,EAAiBqB,EAASkD,kBAAkB2K,GAC5C3M,EAAY,+BAAuBvC,GACnClB,EAAYoQ,EAAUpQ,WAAayI,EAAQzI,UAC3CuF,EAAKkD,EAAQxD,MAAOrC,EAAgB2C,EAAG3C,cAAeO,EAAcoC,EAAGpC,YAAaH,EAAUuC,EAAGvC;AACrG,MAAO,CACHsC,KAAMgI,uBAAuB8C,GAC7B3O,MAAO2O,EAAU3O,OAAS,KAC1BgC,UAAWA,EACXvC,eAAgBA,EAChBlB,UAAWA,EACXoF,YAAa,KACbjC,YAAaA,EACbuN,QAASA,EACT9G,MAAOrH,EAASqH,MAChB5G,QAASA,EACTgC,UAAW,SAAUF,EAAoBC,GACrC,IAAIvF,EAAwC,iBAAvBsF,EAAkC,CACnDrB,UAAWqB,EACXC,KAAMA,IACN,QAAS,CAAC,EAAGD;AAOjB,YANI,IAAWtF,EAAQuF,OACnBvF,EAAQuF,KAAOlC,QAEf,IAAWrD,EAAQQ,YACnBR,EAAQQ,UAAYA,GAEjBuC,EAASyC,UAAUxF,EAASiJ,EACvC,EACAqF,aAAc,SAAU/L,EAAUC,GAC9B,GAAIV,MAAMC,QAAQQ,IAAaT,MAAMC,QAAQS,GACzC,MAA8C,IAAI,KAAe;AAErE,GAAID,GAAgC,iBAAbA,GACnBC,GAAgC,iBAAbA,EAAuB,CAC1C,IAAIgP,EAAQpO,EAAcb,EAAU,cAChCkP,EAAQrO,EAAcZ,EAAU,cAChCkP,EAAcF,GAASC,GAASD,IAAUC,EAC1CE,EAAU5O,EAASuK,YAAYoE,OAAc,EAASnP,EAAUC,EAAUyG;AAC9E,OAAIyI,GACC9P,wBAAwBW,IACxBX,wBAAwB+P,IAGtB,SAAS,QAAS,CAAC,EAAGpP,GAAWoP,GAF7BA,CAGf,CACA,OAAOnP,CACX,EAER,CACA,SAASqN,uBAAuB+B,GAC5B,OAAO,SAAU9L,EAAMmD,GACnB,OAAOnD,EAAOmD,EAAQhF,UAAY,IAAMqG,KAAKC,UAAUsH,iBAAiB/L,EAAM8L,IAAc3I,EAAQhF,SACxG,CACJ,CACA,SAASqL,yBAAyBsC,GAC9B,IAAIE,EAAO,IAAI,KAAQ;AACvB,OAAO,SAAUjS,EAAQoJ,GACrB,IAAI8I;AACJ,GAAI9I,EAAQO,cAAgBP,EAAQuB,YAAa,CAC7C,IAAIwH,EAAOF,EAAKjK,YAAY,CACxBoB,EAAQO,aACRP,EAAQuB;AAEZuH,EAAWC,EAAKD,WAAaC,EAAKD,SAAWE,aAAahJ,EAAQO,aAAcP,EAAQuB,aAC5F,CACA,IAAIqC,EAAY5D,EAAQ4D,UACpBgF,iBAAiBhS,EAAQ+R,EAAWG;AACxC,OAAO9I,EAAQjD,SAAW,IAAMsE,KAAKC,UAAUsC,EACnD,CACJ,CACA,SAASoF,aAAazI,EAAcgB,GAChC,IAAIyB,EAAM1K,OAAOqB,OAAO,MACpBsP,EAAY,IAAItL,IAAI,CAAC4C;AA0BzB,OAzBA0I,EAAUnN,SAAQ,SAAUyE,GACxBA,EAAagC,WAAWzG,SAAQ,SAAU0G,GACtC,IAAI,QAAQA,GAAY,CACpB,GAAIA,EAAU0G,MAAO,CACjB,IAAIC,EAAc3G,EAAU0G,MAAMtQ,MAC9BwQ,EAAW5G,EAAUC,KAAK7J;AAC9B,GAAIwQ,IAAaD,GACCnG,EAAIqG,UAAYrG,EAAIqG,QAAU/Q,OAAOqB,OAAO,QAClDyP,GAAYD,CAE5B,CACA,GAAI3G,EAAUjC,cACIyC,EAAIsG,UAAYtG,EAAIsG,QAAUhR,OAAOqB,OAAO,QAClD6I,EAAUC,KAAK7J,OACnBoQ,aAAaxG,EAAUjC,aAAcgB,EAEjD,KACK,CACD,IAAI9J,GAAW,QAAyB+K,EAAWjB;AAC/C9J,GACAwR,EAAUrL,IAAInG,EAAS8I,aAE/B,CACJ,GACJ,IACOyC,CACX,CACA,SAAS4F,iBAAiBW,EAAUZ,EAAWG,GAC3C,IACIU,EADAC,EAASnR,OAAOqB,OAAO;AAiB3B,OAfAgP,EAAU7M,SAAQ,SAAU4N,GACxB,GAAI7Q,MAAMC,QAAQ4Q,IACd,GAAuB,iBAAZF,EAAsB,CAC7B,IAAIF,EAAUR,GAAYA,EAASQ,QAC/BK,EAASL,GAAWA,EAAQE;AAChCC,EAAOD,GAAWZ,iBAAiBW,EAASC,GAAUE,EAAGC,EAC7D,MAEC,CACD,IAAIN,EAAUP,GAAYA,EAASO,QAC/BO,EAAeP,GAAWA,EAAQK,IAAMA,GACJ,QAAUrR,EAAO6C,KAAKqO,EAAUK,GAAe,GACvFH,EAAOD,EAAUE,GAAKH,EAASK,EACnC,CACJ,IACOH,CACX,CCrZA,IAAII,EAAgB,CAChBlE,iBAAkBZ,wBAClBjE,aAAa,EACb3B,eAAe,EACfsG,aAAc,CAAC,GAEfqE,EAAiB,SAAU7K,GAE3B,SAAS6K,cAAc3J,QACJ,IAAXA,IAAqBA,EAAS,CAAC;AACnC,IAAInG,EAAQiF,EAAO/D,KAAKhF,OAASA;AAkCjC,OAjCA8D,EAAM+P,QAAU,IAAIpM,IACpB3D,EAAMgQ,sBAAwB,IAAIC,IAClCjQ,EAAMwK,QAAUA,QAChBxK,EAAMkQ,QAAU,EAChBlQ,EAAMmQ,qBAAsB,SAAK,SAAUC,GACvC,OAAOpQ,EAAMqQ,eAAenP,KAAKlB,EAAOoQ,EAC5C,GAAG,CACC5L,aAAc,SAAU4L,GACpB,IAAI5N,EAAQ4N,EAAElT,WAAa8C,EAAMsQ,eAAiBtQ,EAAMjC;AACxD,GAAI8H,sBAAsBrD,GAAQ,CAC9B,IAAItF,EAAakT,EAAElT,WAAYE,EAASgT,EAAEhT,OAAQG,EAAY6S,EAAE7S;AAChE,OAAOiF,EAAMgC,aAAa4L,EAAE9S,MAAO8S,EAAEG,SAAUlJ,KAAKC,UAAU,CAAEpK,WAAYA,EAAYE,OAAQA,EAAQG,UAAWA,IACvH,CACJ,IAEJyC,EAAMwQ,UAAW,UACjBxQ,EAAMmG,QAAS,SAAS,QAAS,CAAC,EAAG0J,GAAgB1J,GACrDnG,EAAM8G,cAAgB9G,EAAMmG,OAAOW,YACnC9G,EAAMF,SAAW,IAAI0L,EAAS,CAC1BrE,MAAOnH,EACP2L,iBAAkB3L,EAAMmG,OAAOwF,iBAC/BE,cAAe7L,EAAMmG,OAAO0F,cAC5BJ,aAAczL,EAAMmG,OAAOsF,eAE/BzL,EAAMjC,KAAO,IAAI8B,EAAYmF,KAAK,CAC9BlF,SAAUE,EAAMF,SAChBqF,cAAenF,EAAMmG,OAAOhB,gBAEhCnF,EAAMsQ,eAAiBtQ,EAAMjC,KAC7BiC,EAAMyQ,YAAc,IAAIvH,EAAYlJ,EAAOA,EAAM0Q,YAAc,IAAIxK,EAAY,CAC3EiB,MAAOnH,EACP8G,YAAa9G,EAAM8G,eAEhB9G,CACX,CA+KA,OArNA,QAAU8P,cAAe7K,GAuCzB6K,cAAc1T,UAAUuU,QAAU,SAAU5S,GAGxC,OAFIA,GACA7B,KAAK6B,KAAKqF,QAAQrF,GACf7B,IACX,EACA4T,cAAc1T,UAAUwU,QAAU,SAAU1T,GAExC,YADmB,IAAfA,IAAyBA,GAAa,IAClCA,EAAahB,KAAKoU,eAAiBpU,KAAK6B,MAAM+C,UAC1D,EACAgP,cAAc1T,UAAUe,KAAO,SAAUJ,GACrC,IAAIyF,EAAQzF,EAAQG,WAAahB,KAAKoU,eAAiBpU,KAAK6B;AAC5D,OAA8B,iBAAnBhB,EAAQK,QAAwBoF,EAAM/B,IAAI1D,EAAQK,UAGtDlB,KAAKwU,YAAY3J,mBAAmB,CACvCvE,MAAOA,EACPlF,MAAOP,EAAQO,MACfC,UAAWR,EAAQQ,UACnBH,OAAQL,EAAQK,OAChB+I,OAAQjK,KAAKiK,UAPN,IASf,EACA2J,cAAc1T,UAAUwB,MAAQ,SAAUb,GACtC,IAEI,QADEb,KAAKgU,QACAhU,KAAKuU,YAAYrH,aAAa,CACjC5G,MAAOtG,KAAK6B,KACZT,MAAOP,EAAQO,MACfQ,OAAQf,EAAQe,OAChBD,OAAQd,EAAQc,OAChBN,UAAWR,EAAQQ,WAE3B,CACA,UACWrB,KAAKgU,UAAiC,IAAtBnT,EAAQiB,WAC3B9B,KAAK0O,kBAEb,CACJ,EACAkF,cAAc1T,UAAUU,OAAS,SAAUC,GACvC,GAAIsB,EAAO6C,KAAKnE,EAAS,QAAUA,EAAQM,GACvC,OAAO;AAEX,IAAImF,EAAQzF,EAAQG,WACdhB,KAAKoU,eACLpU,KAAK6B;AACX,IAEI,QADE7B,KAAKgU,QACA1N,EAAM1F,OAAOC,EAAQM,IAAM,aAAcN,EAAQiF,OAC5D,CACA,UACW9F,KAAKgU,UAAiC,IAAtBnT,EAAQiB,WAC3B9B,KAAK0O,kBAEb,CACJ,EACAkF,cAAc1T,UAAUyU,KAAO,SAAU9T,GACrC,OAAOb,KAAKwU,YAAY1J,sBAAsB,CAC1CxE,MAAOzF,EAAQG,WAAahB,KAAKoU,eAAiBpU,KAAK6B,KACvDX,OAAQL,EAAQM,IAAM,aACtBC,MAAOP,EAAQO,MACfC,UAAWR,EAAQQ,UACnB0J,kBAAmBlK,EAAQkK,kBAC3Bd,OAAQjK,KAAKiK,QAErB,EACA2J,cAAc1T,UAAU0U,MAAQ,SAAUA,GACtC,IAAI9Q,EAAQ9D;AAKZ,OAJAA,KAAK6T,QAAQnM,IAAIkN,GACbA,EAAMC,WACN7U,KAAKiU,oBAAoBW,GAEtB,WACH9Q,EAAM+P,QAAQnN,OAAOkO,EACzB,CACJ,EACAhB,cAAc1T,UAAUS,GAAK,WACzB,OAAOX,KAAKoU,eAAezT,IAC/B,EACAiT,cAAc1T,UAAUkH,OAAS,SAAUlG,EAAQF,GAC/C,OAAQA,EAAahB,KAAKoU,eAAiBpU,KAAK6B,MAAMuF,OAAOlG,EACjE,EACA0S,cAAc1T,UAAUmH,QAAU,SAAUnG,EAAQF,GAChD,OAAQA,EAAahB,KAAKoU,eAAiBpU,KAAK6B,MAAMwF,QAAQnG,EAClE,EACA0S,cAAc1T,UAAUO,SAAW,SAAUC,GACzC,OAAO,QAAYA,GAAUA,EAAO0D,MAChCpE,KAAK4D,SAASnD,SAASC,GAAQ,EACvC,EACAkT,cAAc1T,UAAU6G,MAAQ,SAAUlG,GACtC,IAAKA,EAAQM,GAAI,CACb,GAAIgB,EAAO6C,KAAKnE,EAAS,MACrB,OAAO;AAEXA,GAAU,SAAS,QAAS,CAAC,EAAGA,GAAU,CAAEM,GAAI,cACpD,CACA,IAEI,QADEnB,KAAKgU,QACAhU,KAAKoU,eAAerN,MAAMlG,EACrC,CACA,UACWb,KAAKgU,UAAiC,IAAtBnT,EAAQiB,WAC3B9B,KAAK0O,kBAEb,CACJ,EACAkF,cAAc1T,UAAU4U,MAAQ,WAI5B,OAHA9U,KAAK6B,KAAKoF,QACVjH,KAAKoU,eAAiBpU,KAAK6B,KAC3B7B,KAAK0O,mBACEqG,QAAQC,SACnB,EACApB,cAAc1T,UAAU+U,iBAAmB,SAAUC,GACjD,IAAIC,EAAoBnV,KAAKoU,eAAe7K,YAAY2L;AACpDC,IAAsBnV,KAAKoU,iBAC3BpU,KAAKoU,eAAiBe,EACtBnV,KAAK0O,mBAEb,EACAkF,cAAc1T,UAAUI,mBAAqB,SAAUF,EAAaC,GAChE,IAAIyD,EAAQ9D,KACRoV,QAAU,SAAUC,GACpB,IAAIzO,EAAK9C,EAAOjC,EAAO+E,EAAG/E,KAAMuS,EAAiBxN,EAAGwN,iBAClDtQ,EAAMkQ,QACJqB,IACAvR,EAAMjC,KAAOiC,EAAMsQ,eAAiBiB;AAExC,IACIjV,EAAY0D,EAChB,CACA,UACMA,EAAMkQ,QACRlQ,EAAMjC,KAAOA,EACbiC,EAAMsQ,eAAiBA,CAC3B,CACJ;AAC4B,iBAAjB/T,EACPL,KAAKoU,eAAiBpU,KAAKoU,eAAehL,SAAS/I,EAAc+U,SAE3C,OAAjB/U,EACL+U,QAAQpV,KAAK6B,MAGbuT,UAEJpV,KAAK0O,kBACT,EACAkF,cAAc1T,UAAUK,kBAAoB,SAAUC,GAClD,GAAIR,KAAK4K,YAAa,CAClB,IAAIhJ,EAAS5B,KAAK8T,sBAAsB3P,IAAI3D;AAM5C,OALKoB,IACDA,GAAS,QAAsBpB,GAC/BR,KAAK8T,sBAAsBnH,IAAInM,EAAUoB,GACzC5B,KAAK8T,sBAAsBnH,IAAI/K,EAAQA,IAEpCA,CACX,CACA,OAAOpB,CACX,EACAoT,cAAc1T,UAAUwO,iBAAmB,WACvC,IAAI5K,EAAQ9D;AACPA,KAAKgU,SACNhU,KAAK6T,QAAQjO,SAAQ,SAAUsO,GAAK,OAAOpQ,EAAMmQ,oBAAoBC,EAAI,GAEjF,EACAN,cAAc1T,UAAUiU,eAAiB,SAAUD,GAC/ClU,KAAKsU,SAASzO,MAAMqO,GACpBlU,KAAKsU,SAASJ,GACdA,EAAEG,SAASrU,KAAK2U,KAAK,CACjBvT,MAAO8S,EAAE9S,MACTC,UAAW6S,EAAE7S,UACbL,WAAYkT,EAAElT,aAEtB,EACO4S,aACX,CAvNoB,CAuNlB7T,E;;gFCxOEuV,EAAiB,WACjB,SAASA,gBACLtV,KAAKsG,MAAQ,CAAC,CAClB,CAgCA,OA/BAgP,cAAcpV,UAAUqV,SAAW,WAC/B,OAAOvV,KAAKsG,KAChB,EACAgP,cAAcpV,UAAUiE,IAAM,SAAUqR,GACpC,OAAOxV,KAAKsG,MAAMkP,EACtB,EACAF,cAAcpV,UAAUuV,aAAe,SAAUD,EAAYE,EAAUrU,GACnErB,KAAKsG,MAAMkP,GAAc,CACrBE,SAAUA,EACVrU,UAAWA,GAAa,CAAC,EACzBsU,SAAS,EACTC,MAAO,KAEf,EACAN,cAAcpV,UAAU2V,kBAAoB,SAAUL,EAAYI,GAC9D,IAAIF,EAAW1V,KAAKsG,MAAMkP;AACtBE,IACAA,EAASC,SAAU,EACnBD,EAASE,MAAQA,EAEzB,EACAN,cAAcpV,UAAU4V,mBAAqB,SAAUN,GACnD,IAAIE,EAAW1V,KAAKsG,MAAMkP;AACtBE,IACAA,EAASC,SAAU,EACnBD,EAASE,MAAQ,KAEzB,EACAN,cAAcpV,UAAU4U,MAAQ,WAC5B9U,KAAKsG,MAAQ,CAAC,CAClB,EACOgP,aACX,CApCoB,G,2CCKhBS,EAAc,WACd,SAASA,WAAWnP,GAChB,IAAIqE,EAAQrE,EAAGqE,MAAO+K,EAASpP,EAAGoP,OAAQC,EAAYrP,EAAGqP,UAAWC,EAAkBtP,EAAGsP;AACzFlW,KAAKiL,MAAQA,EACT+K,IACAhW,KAAKgW,OAASA,GAEdC,GACAjW,KAAKmW,aAAaF,GAElBC,GACAlW,KAAKoW,mBAAmBF,EAEhC,CAuPA,OAtPAH,WAAW7V,UAAUiW,aAAe,SAAUF,GAC1C,IAAInS,EAAQ9D;AACZA,KAAKiW,UAAYjW,KAAKiW,WAAa,CAAC,EAChCtT,MAAMC,QAAQqT,GACdA,EAAUrQ,SAAQ,SAAUyQ,GACxBvS,EAAMmS,WAAY,QAAUnS,EAAMmS,UAAWI,EACjD,IAGArW,KAAKiW,WAAY,QAAUjW,KAAKiW,UAAWA,EAEnD,EACAF,WAAW7V,UAAUoW,aAAe,SAAUL,GAC1CjW,KAAKiW,UAAY,CAAC,EAClBjW,KAAKmW,aAAaF,EACtB,EACAF,WAAW7V,UAAUqW,aAAe,WAChC,OAAOvW,KAAKiW,WAAa,CAAC,CAC9B,EACAF,WAAW7V,UAAUsW,aAAe,SAAU5P,GAC1C,IAAIpG,EAAWoG,EAAGpG,SAAUiW,EAAe7P,EAAG6P,aAAc3M,EAAUlD,EAAGkD,QAASzI,EAAYuF,EAAGvF,UAAW2H,EAAKpC,EAAG8P,uBAAwBA,OAAgC,IAAP1N,GAAwBA;AAC7L,OAAO,QAAUhJ,UAAM,OAAQ,GAAQ,WACnC,OAAO,QAAYA,MAAM,SAAUgL,GAC/B,OAAIxK,EACO,CAAC,EAAGR,KAAK2W,gBAAgBnW,EAAUiW,EAAa5U,KAAMiI,EAASzI,EAAWrB,KAAKkW,gBAAiBQ,GAAwBE,MAAK,SAAUC,GAAe,OAAQ,SAAS,QAAS,CAAC,EAAGJ,GAAe,CAAE5U,KAAMgV,EAAYjV,QAAY,KAEvO,CAAC,EAAG6U,EACf,GACJ,GACJ,EACAV,WAAW7V,UAAUkW,mBAAqB,SAAUF,GAChDlW,KAAKkW,gBAAkBA,CAC3B,EACAH,WAAW7V,UAAU4W,mBAAqB,WACtC,OAAO9W,KAAKkW,eAChB,EACAH,WAAW7V,UAAU6W,YAAc,SAAUvW,GACzC,OAAI,QAAc,CAAC,UAAWA,IACtBR,KAAKiW,UACEzV,EAGR,IACX,EACAuV,WAAW7V,UAAU8W,YAAc,SAAUxW,GACzC,OAAO,QAA6BA,EACxC,EACAuV,WAAW7V,UAAU+W,eAAiB,SAAUnN,GAC5C,IAAImB,EAAQjL,KAAKiL;AACjB,OAAO,SAAS,QAAS,CAAC,EAAGnB,GAAU,CAAEmB,MAAOA,EAC5CiM,YAAa,SAAU/O,GACnB,OAAO8C,EAAMxK,SAAS0H,EAC1B,GACR,EACA4N,WAAW7V,UAAUiX,qBAAuB,SAAU3W,EAAUa,EAAWyI,GAGvE,YAFkB,IAAdzI,IAAwBA,EAAY,CAAC,QACzB,IAAZyI,IAAsBA,EAAU,CAAC,IAC9B,QAAU9J,UAAM,OAAQ,GAAQ,WACnC,OAAO,QAAYA,MAAM,SAAU4G,GAC/B,OAAIpG,EACO,CAAC,EAAGR,KAAK2W,gBAAgBnW,EAAUR,KAAKoX,wBAAwB5W,EAAUa,IAAc,CAAC,EAAGrB,KAAKiX,eAAenN,GAAUzI,GAAWuV,MAAK,SAAU/U,GAAQ,OAAQ,SAAS,QAAS,CAAC,EAAGR,GAAYQ,EAAKwV,kBAAqB,KAEpO,CAAC,GAAG,QAAS,CAAC,EAAGhW,GAC5B,GACJ,GACJ,EACA0U,WAAW7V,UAAUoX,qBAAuB,SAAU9W,GAClD,IAAI+W,GAAiB;AAiBrB,OAhBA,QAAM/W,EAAU,CACZgX,UAAW,CACPC,MAAO,SAAUC,GACb,GAAwB,WAApBA,EAAKnL,KAAK7J,OAAsBgV,EAAKlP,YACrC+O,EAAiBG,EAAKlP,UAAUmP,MAAK,SAAUC,GAC3C,MAA0B,WAAnBA,EAAIrL,KAAK7J,OACO,iBAAnBkV,EAAIlV,MAAMmV,OACU,IAApBD,EAAIlV,MAAMA,KAClB,KAEI,OAAO,IAGnB,KAGD6U,CACX,EACAxB,WAAW7V,UAAUkX,wBAA0B,SAAU5W,EAAUa,GAC/D,OAAOrB,KAAKiL,MAAM0J,KAAK,CACnBvT,OAAO,QAA2BZ,GAClCa,UAAWA,EACX0J,mBAAmB,EACnB/J,YAAY,IACbY,MACP,EACAmU,WAAW7V,UAAUyW,gBAAkB,SAAUnW,EAAUsX,EAAWhO,EAASzI,EAAW6U,EAAiBQ,GAKvG,YAJgB,IAAZ5M,IAAsBA,EAAU,CAAC,QACnB,IAAdzI,IAAwBA,EAAY,CAAC,QACjB,IAApB6U,IAA8BA,EAAkB,WAAc,OAAO,CAAM,QAChD,IAA3BQ,IAAqCA,GAAyB,IAC3D,QAAU1W,UAAM,OAAQ,GAAQ,WACnC,IAAI+X,EAAgBC,EAAW3M,EAAa4M,EAAqBC,EAAsBtR,EAAIqE,EAAO+K,EAAQmC;AAC1G,OAAO,QAAYnY,MAAM,SAAUgJ,GAqB/B,OApBA+O,GAAiB,QAAkBvX,GACnCwX,GAAY,QAAuBxX,GACnC6K,GAAc,OAAkB2M,GAChCC,EAAsBF,EACjBK,UACLF,EAAuBD,EACjBA,EAAoBI,OAAO,GAAGzH,cAC5BqH,EAAoBlO,MAAM,GAC5B,QACKkB,GAAXrE,EAAK5G,MAAiBiL,MAAO+K,EAASpP,EAAGoP,OACzCmC,EAAc,CACV9M,YAAaA,EACbvB,SAAS,SAAS,QAAS,CAAC,EAAGA,GAAU,CAAEmB,MAAOA,EAC9C+K,OAAQA,IACZ3U,UAAWA,EACX6U,gBAAiBA,EACjBgC,qBAAsBA,EACtBb,kBAAmB,CAAC,EACpBX,uBAAwBA,GAErB,CAAC,EAAG1W,KAAKsY,oBAAoBP,EAAe1N,aAAcyN,EAAWK,GAAavB,MAAK,SAAUhV,GAAU,MAAO,CACjHA,OAAQA,EACRyV,kBAAmBc,EAAYd,kBAC/B,IACZ,GACJ,GACJ,EACAtB,WAAW7V,UAAUoY,oBAAsB,SAAUjO,EAAcyN,EAAWK,GAC1E,OAAO,QAAUnY,UAAM,OAAQ,GAAQ,WACnC,IAAIqL,EAAavB,EAASzI,EAAWkX,EAAgBC,EACjD1U,EAAQ9D;AACZ,OAAO,QAAYA,MAAM,SAAU4G,GAqC/B,OApCAyE,EAAc8M,EAAY9M,YAAavB,EAAUqO,EAAYrO,QAASzI,EAAY8W,EAAY9W,UAC9FkX,EAAiB,CAACT,GAClBU,EAAU,SAAUlM,GAAa,OAAO,QAAUxI,OAAO,OAAQ,GAAQ,WACrE,IAAIvC,EAAU8P;AACd,OAAO,QAAYrR,MAAM,SAAU4G,GAC/B,OAAK,QAAc0F,EAAWjL,IAG1B,QAAQiL,GACD,CAAC,EAAGtM,KAAKyY,aAAanM,EAAWwL,EAAWK,GAAavB,MAAK,SAAU8B,GACvE,IAAI9R;KACuB,IAAhB8R,GACPH,EAAevM,OAAMpF,EAAK,CAAC,IACpB,QAAuB0F,IAAcoM,EACxC9R,GAEZ,OAEJ,QAAiB0F,GACjB/K,EAAW+K,GAGX/K,EAAW8J,EAAYiB,EAAUC,KAAK7J,QACE,QAAUnB,EAAU,KAE5DA,GAAYA,EAAS8P,gBACrBA,EAAgB9P,EAAS8P,cAAc9E,KAAK7J,MACxCyV,EAAYjC,gBAAgB4B,EAAWzG,EAAevH,IAC/C,CAAC,EAAG9J,KAAKsY,oBAAoB/W,EAAS8I,aAAcyN,EAAWK,GAAavB,MAAK,SAAU+B,GAC1FJ,EAAevM,KAAK2M,EACxB,KAGL,CAAC,IA3BG,CAAC,EA4BhB,GACJ,GAAI,EACG,CAAC,EAAG5D,QAAQ6D,IAAIvO,EAAagC,WAAWS,IAAI0L,IAAU5B,MAAK,WAC1D,OAAO,QAAe2B,EAC1B,IACR,GACJ,GACJ,EACAxC,WAAW7V,UAAUuY,aAAe,SAAU3V,EAAOgV,EAAWK,GAC5D,OAAO,QAAUnY,UAAM,OAAQ,GAAQ,WACnC,IAAIqB,EAAWyD,EAAW+T,EAAkBC,EAAWC,EAAeC,EAAeC,EAAcC,EAAalE,EAC5GlR,EAAQ9D;AACZ,OAAO,QAAYA,MAAM,SAAU4G,GAuB/B,OAtBAvF,EAAY8W,EAAY9W,UACxByD,EAAYhC,EAAMyJ,KAAK7J,MACvBmW,GAAmB,QAAuB/V,GAC1CgW,EAAYhU,IAAc+T,EAC1BE,EAAgBjB,EAAUe,IAAqBf,EAAUhT,GACzDkU,EAAgBjE,QAAQC,QAAQ+D,GAC3BZ,EAAYzB,yBACb1W,KAAKsX,qBAAqBxU,KAC1BmW,EAAenB,EAAU3L,YAAcgM,EAAYD,sBACnDgB,EAAclZ,KAAKiW,WAAajW,KAAKiW,UAAUgD,MAE3CjE,EAAUkE,EAAYJ,EAAYhU,EAAY+T,MAE1CG,EAAgBjE,QAAQC,QAAQ/J,EAAA,aAAoBjL,KAAKiL,MAAO+J,EAAS,CACrE8C,GACA,QAAyBhV,EAAOzB,GAChC8W,EAAYrO,QACZ,CAAEhH,MAAOA,EAAOuI,YAAa8M,EAAY9M,kBAKlD,CAAC,EAAG2N,EAAcpC,MAAK,SAAUhV,GAahC,YAZe,IAAXA,IAAqBA,EAASmX,GAC9BjW,EAAMqW,YACNrW,EAAMqW,WAAWvT,SAAQ,SAAUwT,GACF,WAAzBA,EAAU7M,KAAK7J,OAAsB0W,EAAU5Q,WAC/C4Q,EAAU5Q,UAAU5C,SAAQ,SAAUgS,GACX,OAAnBA,EAAIrL,KAAK7J,OAAqC,gBAAnBkV,EAAIlV,MAAMmV,OACrCM,EAAYd,kBAAkBO,EAAIlV,MAAMA,OAASd,EAEzD,GAER,IAECkB,EAAMuH,aAGG,MAAVzI,EACOA,EAEPe,MAAMC,QAAQhB,GACPkC,EAAMuV,wBAAwBvW,EAAOlB,EAAQuW,GAEpDrV,EAAMuH,aACCvG,EAAMwU,oBAAoBxV,EAAMuH,aAAczI,EAAQuW,QADjE,EARWvW,CAWf,IACR,GACJ,GACJ,EACAmU,WAAW7V,UAAUmZ,wBAA0B,SAAUvW,EAAOlB,EAAQuW,GACpE,IAAIrU,EAAQ9D;AACZ,OAAO+U,QAAQ6D,IAAIhX,EAAOkL,KAAI,SAAUC,GACpC,OAAa,OAATA,EACO,KAEPpK,MAAMC,QAAQmK,GACPjJ,EAAMuV,wBAAwBvW,EAAOiK,EAAMoL,GAElDrV,EAAMuH,aACCvG,EAAMwU,oBAAoBxV,EAAMuH,aAAc0C,EAAMoL,QAD/D,CAGJ,IACJ,EACOpC,UACX,CArQiB,GCFbuD,EAAa,WACb,SAASA,UAAUrO,GACfjL,KAAKiL,MAAQA,EACbjL,KAAKuZ,UAAY,IAAI9R,IACrBzH,KAAKQ,SAAW,KAChBR,KAAKwZ,cAAgB,EACrBxZ,KAAKyZ,cAAgB,IAAIhS,IACzBzH,KAAK6F,OAAQ,EACb7F,KAAK2U,KAAO,KACZ3U,KAAK0Z,gBAAkB,IAC3B,CAsLA,OArLAJ,UAAUpZ,UAAUyZ,KAAO,SAAUvY,GACjC,IAAIwY,EAAgBxY,EAAMwY,eAAiB;AAsB3C,OArBI5Z,KAAKqB,WACLrB,KAAK4Z,gBAAkB,eACtB,OAAM5Z,KAAKqB,UAAWD,EAAMC,aAC7BuY,EAAgB,mBAEf,OAAMxY,EAAMC,UAAWrB,KAAKqB,aAC7BrB,KAAK2U,KAAO,MAEhBvS,OAAOyX,OAAO7Z,KAAM,CAChBQ,SAAUY,EAAMZ,SAChBa,UAAWD,EAAMC,UACjByY,aAAc,KACdC,cAAe/Z,KAAK+Z,eAAiB,GACrCH,cAAeA,IAEfxY,EAAMsY,iBACN1Z,KAAKga,mBAAmB5Y,EAAMsY,iBAE9BtY,EAAMoY,gBACNxZ,KAAKwZ,cAAgBpY,EAAMoY,eAExBxZ,IACX,EACAsZ,UAAUpZ,UAAU+Z,QAAU,SAAU5Y,GAEpC,YADkB,IAAdA,IAAwBA,EAAYrB,KAAKqB,WACzCrB,KAAK2U,OAAQ,OAAMtT,EAAWrB,KAAKqB,WAC5BrB,KAAK2U,MAEhB3U,KAAKka,YAAYla,KAAKqB,UAAYA,GAC3BrB,KAAK2U,KAAO3U,KAAKiL,MAAM0J,KAAK,CAC/BvT,MAAOpB,KAAKQ,SACZa,UAAWA,EACX0J,mBAAmB,EACnB/J,YAAY,IAEpB,EACAsY,UAAUpZ,UAAUia,QAAU,SAAUxF,GACpC,IAAI7Q,EAAQ9D,KACRoa,EAAUpa,KAAK2U;AACnB3U,KAAK2U,KAAOA,EACP3U,KAAK6F,QAAU8O,aAAmC,EAASA,EAAK/S,WAAawY,aAAyC,EAASA,EAAQxY,UACxI5B,KAAK6F,OAAQ,EACR7F,KAAKqa,gBACNra,KAAKqa,cAAgBC,YAAW,WAAc,OAAOxW,EAAMyW,QAAU,GAAG,IAGpF,EACAjB,UAAUpZ,UAAU8Z,mBAAqB,SAAUQ,GAC3CA,IAAOxa,KAAK0Z,kBAEZ1Z,KAAKya,YACLza,KAAKuZ,UAAU7S,OAAO1G,KAAKya,YAE/Bza,KAAK0Z,gBAAkBc,EACnBA,GACAA,EAAc,UAAIxa,KAClBA,KAAKuZ,UAAU7R,IAAI1H,KAAKya,WAAa,WAAc,OAAOD,EAAGE,WAAa,WAGnE1a,KAAKya,WAEpB,EACAnB,UAAUpZ,UAAUqa,OAAS,WACzB,IAAIzW,EAAQ9D;AACRA,KAAKqa,gBACLM,aAAa3a,KAAKqa,eAClBra,KAAKqa,mBAAgB,GAErBra,KAAK4a,gBACL5a,KAAKuZ,UAAU3T,SAAQ,SAAUiV,GAAY,OAAOA,EAAS/W,EAAQ,IAEzE9D,KAAK6F,OAAQ,CACjB,EACAyT,UAAUpZ,UAAU0a,aAAe,WAC/B,IAAK5a,KAAK6F,QAAU7F,KAAKuZ,UAAUuB,KAC/B,OAAO;AAEX,IAAI,OAAyB9a,KAAK4Z,gBAC9B5Z,KAAK0Z,gBAAiB,CACtB,IAAIqB,EAAc/a,KAAK0Z,gBAAgB7Y,QAAQka;AAC/C,GAAoB,eAAhBA,GACgB,sBAAhBA,EACA,OAAO,CAEf,CACA,OAAO,CACX,EACAzB,UAAUpZ,UAAU8a,KAAO,WACvBhb,KAAKib,gBACEjb,KAAKib;AACZ,IAAIT,EAAKxa,KAAK0Z;AACVc,GACAA,EAAGU,aACX,EACA5B,UAAUpZ,UAAU+a,OAAS,WAAc,EAC3C3B,UAAUpZ,UAAUga,YAAc,SAAU7Y,GACxC,IAAIyC,EAAQ9D;KACM,IAAdqB,IAAwBA,EAAYrB,KAAKqB;AAC7C,IAAImZ,EAAKxa,KAAK0Z;AACVc,GAAiC,aAA3BA,EAAG3Z,QAAQka,aAGhB/a,KAAKmb,WACNnb,KAAKmb,UAAU/Z,QAAUpB,KAAKQ,WAC7B,OAAMa,EAAWrB,KAAKmb,UAAU9Z,aACjCrB,KAAKib,SACLjb,KAAKib,OAASjb,KAAKiL,MAAM2J,MAAM5U,KAAKmb,UAAY,CAC5C/Z,MAAOpB,KAAKQ,SACZa,UAAWA,EACXL,YAAY,EACZqT,SAAU,SAAUM,GAAQ,OAAO7Q,EAAMqW,QAAQxF,EAAO,IAGpE,EACA2E,UAAUpZ,UAAUkb,WAAa,SAAUxZ,EAAQf,EAASwa,GACxD,IAAIvX,EAAQ9D;AAEZ,GADAA,KAAK+Z,eAAgB,QAAgBnY,EAAO0Z,QAAU1Z,EAAO0Z,OAAS,GAC1C,aAAxBza,EAAQka,YACR/a,KAAK2U,KAAO,CAAE/S,OAAQA,EAAOC,KAAM2J,UAAU;KAE5C,GAAI6P,EAAiB,CACtB,IAAIE,EAAuC,WAAxB1a,EAAQ2a,aACC,QAAxB3a,EAAQ2a,YACRC,IAAmB,QAAsB7Z;CACxC6Z,GAAmBF,GAAgB3Z,EAAOC,OAC3C4Z,GAAkB,GAElBA,EACAzb,KAAKiL,MAAM3K,oBAAmB,SAAU2K,GACpC,GAAInH,EAAM4X,oBACN,OAAM9Z,EAAOC,KAAMiC,EAAM4X,kBAAkB7Z,QAC3C,OAAMhB,EAAQQ,UAAWyC,EAAM6X,kBAC/B,GAAI7X,EAAM6Q,MAAQ7Q,EAAM6Q,KAAKnJ,SAEzB,YADA5J,EAAOC,KAAOiC,EAAM6Q,KAAK/S,aAK7BqJ,EAAMxJ,WAAW,CACbL,MAAO0C,EAAMtD,SACbqB,KAAMD,EAAOC,KACbR,UAAWR,EAAQQ,YAEvByC,EAAM4X,kBAAoB9Z,EAC1BkC,EAAM6X,gBAAkB9a,EAAQQ;AAEpC,IAAIsT,EAAO1J,EAAM0J,KAAK,CAClBvT,MAAO0C,EAAMtD,SACba,UAAWR,EAAQQ,UACnB0J,mBAAmB,EACnB/J,YAAY;AAEhB8C,EAAMoW,YAAYrZ,EAAQQ,WAC1ByC,EAAM6Q,KAAOA,EACTA,EAAKnJ,WACL5J,EAAOC,KAAO8S,EAAK/S,OAE3B,IAGA5B,KAAK0b,kBAAoB1b,KAAK2b,qBAAkB,CAExD,CACJ,EACArC,UAAUpZ,UAAU0b,UAAY,WAE5B,OADA5b,KAAK8Z,aAAe,KACb9Z,KAAK4Z,cAAgB,SAChC,EACAN,UAAUpZ,UAAU2b,UAAY,SAAUjG,GAStC,OARA5V,KAAK4Z,cAAgB,UACrB5Z,KAAK0b,kBAAoB1b,KAAK2b,qBAAkB,EAC5C/F,EAAMmE,gBACN/Z,KAAK+Z,cAAgBnE,EAAMmE,eAE3BnE,EAAMkE,eACN9Z,KAAK8Z,aAAelE,EAAMkE,cAEvBlE,CACX,EACO0D,SACX,CAjMgB,GCQZ,EAAiBlX,OAAOlC,UAAUmC,eAClCyZ,EAAgB,WAChB,SAASA,aAAalV,GAClB,IAAIqE,EAAQrE,EAAGqE,MAAO8Q,EAAOnV,EAAGmV,KAAM/S,EAAKpC,EAAGoV,mBAAoBA,OAA4B,IAAPhT,GAAwBA,EAAIgC,EAAKpE,EAAGqV,YAAaA,OAAqB,IAAPjR,EAAgB,WAAgC,EAAIA,EAAIkR,EAAKtV,EAAGuV,QAASA,OAAiB,IAAPD,GAAwBA,EAAIE,EAAKxV,EAAGyV,gBAAiBA,OAAyB,IAAPD,EAAgB,CAAC,EAAIA,EAAIE,EAAa1V,EAAG0V,WAAYC,EAAyB3V,EAAG2V;AACjYvc,KAAKwc,cAAgB,IAAIlH,EACzBtV,KAAKqc,gBAAkB,CAAC,EACxBrc,KAAKyc,QAAU,IAAI1I,IACnB/T,KAAK0c,eAAiB,IAAI3I,IAC1B/T,KAAK2c,eAAiB,IAAK,KAAgBnS,QAAUuJ,KACrD/T,KAAK4c,eAAiB,EACtB5c,KAAK6c,iBAAmB,EACxB7c,KAAK8c,kBAAoB,EACzB9c,KAAK+c,wBAA0B,IAAIhJ,IACnC/T,KAAKiL,MAAQA,EACbjL,KAAK+b,KAAOA,EACZ/b,KAAKgc,mBAAqBA,EAC1Bhc,KAAKic,YAAcA,EACnBjc,KAAKqc,gBAAkBA,EACvBrc,KAAKsc,WAAaA,GAAc,IAAIvG,EAAW,CAAE9K,MAAOA,IACxDjL,KAAKmc,QAAUA,EACfnc,KAAKuc,yBAA2BA,CACpC,CAslBA,OArlBAT,aAAa5b,UAAU8a,KAAO,WAC1B,IAAIlX,EAAQ9D;AACZA,KAAKyc,QAAQ7W,SAAQ,SAAUoX,EAAOC,GAClCnZ,EAAMoZ,qBAAqBD,EAC/B,IACAjd,KAAKmd,qBAA6D,IAAI,KAAe,IACzF,EACArB,aAAa5b,UAAUid,qBAAuB,SAAUvH,GACpD5V,KAAK0c,eAAe9W,SAAQ,SAAUqV,GAAU,OAAOA,EAAOrF,EAAQ,IACtE5V,KAAK0c,eAAezV,OACxB,EACA6U,aAAa5b,UAAUkd,OAAS,SAAUxW,GACtC,IAAI8O,EAAW9O,EAAG8O,SAAUrU,EAAYuF,EAAGvF,UAAWgc,EAAqBzW,EAAGyW,mBAAoBC,EAAsB1W,EAAG2W,cAAevU,EAAKpC,EAAG4W,eAAgBA,OAAwB,IAAPxU,EAAgB,GAAKA,EAAIgC,EAAKpE,EAAG6W,oBAAqBA,OAA6B,IAAPzS,GAAwBA,EAAI0S,EAAoB9W,EAAG+W,OAAQzB,EAAKtV,EAAG4U,YAAaA,OAAqB,IAAPU,EAAgB,OAASA,EAAInB,EAAcnU,EAAGmU,YAAaqB,EAAKxV,EAAGkD,QAASA,OAAiB,IAAPsS,EAAgB,CAAC,EAAIA;AACxc,OAAO,QAAUpc,UAAM,OAAQ,GAAQ,WACnC,IAAIwV,EAAYoI,EAA2BC,EAAcC,EACrDha,EAAQ9D;AACZ,OAAO,QAAYA,MAAM,SAAU+d,GAC/B,OAAQA,EAAGC,OACP,KAAK,EAMD,OALwC,QAAUtI,EAAU,KACpB,SAAWqF,GAA+B,aAAhBA,EAA4B,IAC9FvF,EAAaxV,KAAKie,qBAClBvI,EAAW1V,KAAKke,UAAUxI,GAAUlV,SACpCa,EAAYrB,KAAKme,aAAazI,EAAUrU,GACnCrB,KAAKke,UAAUxI,GAAU0I,iBACvB,CAAC,EAAGpe,KAAKsc,WAAWnF,qBAAqBzB,EAAUrU,EAAWyI,IADd,CAAC,EAAG;AAE/D,KAAK,EACDzI,EAAY0c,EAAGM,OACfN,EAAGC,MAAQ;AACf,KAAK,EA2CD,OA1CAJ,EAA4B,WACxB,IAAIU,EAAM,CAAC;AAgBX,OAfIhB,GACAxZ,EAAM2Y,QAAQ7W,SAAQ,SAAUgB,EAAIqW,GAChC,IAAIvD,EAAkB9S,EAAG8S;AACzB,GAAIA,EAAiB,CACjB,IAAI6E,EAAY7E,EAAgB6E;AAC5BA,GACA,EAAevZ,KAAKsY,EAAqBiB,KACzCD,EAAIrB,GAAW,CACXuB,QAASlB,EAAoBiB,GAC7BE,UAAW3a,EAAM2Y,QAAQtY,IAAI8Y,IAGzC,CACJ,IAEGqB,CACX,EACAte,KAAKwc,cAAc/G,aAAaD,EAAYE,EAAUrU,GAClDgc,IACAQ,EAA6C,mBAAvBR,EAChBA,EAAmBhc,GACnBgc,EACNrd,KAAKiL,MAAM9K,6BAA4B,SAAU8K,GAC7C,IACI6K,mBAAmB,CACfN,WAAYA,EACZ5T,OAAQ,CAAEC,KAAMgc,GAChBrd,SAAUkV,EACVrU,UAAWA,EACXqd,kBAAmBd,IACnBD,OAAQD,GACTzS,EACP,CACA,MAAO2K,GAEP,CACJ,GAAGJ,IAEPxV,KAAK2e,mBACLb,EAAO9d,KACA,CAAC,EAAG,IAAI+U,SAAQ,SAAUC,EAAS4J,GAClC,IAAIC,EACAjJ;AACJkI,EAAKgB,sBAAsBpJ,GAAU,SAAS,QAAS,CAAC,EAAG5L,GAAU,CAAEuT,mBAAoBA,IAAuBhc,GAAW,GAAO0d,UAAU,CAC1IC,KAAM,SAAUpd,GACZ,IAAI,QAAsBA,IAA2B,SAAhB4Z,EACjC5F,EAAQ,IAAI,IAAY,CACpBmE,cAAenY,EAAO0Z;IAF9B,CAOA,GADAwC,EAAKtB,cAAc1G,mBAAmBN,GAClB,aAAhBuF,EACA,IACIjF,mBAAmB,CACfN,WAAYA,EACZ5T,OAAQA,EACRpB,SAAUkV,EACVrU,UAAWA,EACXqd,kBAAmBd,IACnBD,OAAQD,GACTI,EAAK7S,MACZ,CACA,MAAOgU,GAIH,YAHArJ,EAAQ,IAAI,IAAY,CACpBkE,aAAcmF,IAGtB,CAEJJ,EAAcjd,CApBd,CAqBJ,EACAgU,MAAO,SAAU/L,GACbiU,EAAKtB,cAAc3G,kBAAkBL,EAAY3L,GAC7CwT,GACAS,EAAK7S,MAAMgK,iBAAiBO,GAEhCsI,EAAKa,mBACLC,EAAO,IAAI,IAAY,CACnB9E,aAAcjQ,IAEtB,EACA2B,SAAU,WAQN,GAPIoK,GACAkI,EAAKtB,cAAc3G,kBAAkBL,EAAYI,GAEjDyH,GACAS,EAAK7S,MAAMgK,iBAAiBO,GAEhCsI,EAAKa,mBACD/I,EACAgJ,EAAOhJ;IADX,CAI8B,mBAAnB4H,IACPA,EAAiBA,EAAeqB;AAEpC,IAAIK,EAAuB,IACvB,QAAgB1B,IAChBA,EAAe5X,SAAQ,SAAUuZ,GAC7B,GAA4B,iBAAjBA,EACPrB,EAAKrB,QAAQ7W,SAAQ,SAAUgB,GAC3B,IAAI8S,EAAkB9S,EAAG8S;AACrBA,GACAA,EAAgB6E,YAAcY,GAC9BD,EAAqBlT,KAAK0N,EAAgB0F,UAElD;IAEC,CACD,IAAIC,EAAe,CACfje,MAAO+d,EAAa/d,MACpBC,UAAW8d,EAAa9d,UACxB0Z,YAAa;AAEboE,EAAarV,UACbuV,EAAavV,QAAUqV,EAAarV,SAExCoV,EAAqBlT,KAAK8R,EAAK1c,MAAMie,GACzC,CACJ,IAEJtK,QAAQ6D,IAAI6E,EAAsByB,EAAuB,IAAItI,MAAK,WAC1C,WAAhB4E,GACAqD,IACA,QAAsBA,WACfA,EAAYvD,OAEvBtG,EAAQ6J,EACZ,GAAGD,EApCH,CAqCJ,GAER,KAEhB,GACJ,GACJ,EACA9C,aAAa5b,UAAUof,WAAa,SAAUrC,EAASpc,EAAS+Y,GAC5D,OAAO5Z,KAAKuf,qBAAqBtC,EAASpc,EAAS+Y,GAAe4F,OACtE,EACA1D,aAAa5b,UAAUuf,cAAgB,WACnC,IAAInZ,EAAQlE,OAAOqB,OAAO;AAS1B,OARAzD,KAAKyc,QAAQ7W,SAAQ,SAAUiN,EAAMoK,GACjC3W,EAAM2W,GAAW,CACb5b,UAAWwR,EAAKxR,UAChBuY,cAAe/G,EAAK+G,cACpBE,aAAcjH,EAAKiH,aACnBC,cAAelH,EAAKkH,cAE5B,IACOzT,CACX,EACAwV,aAAa5b,UAAUwf,YAAc,SAAUzC,GAC3C,IAAIwB,EAAYze,KAAKyc,QAAQtY,IAAI8Y;AAC7BwB,IACAA,EAAU3E,kBAAe6F,EACzBlB,EAAU1E,cAAgB,GAElC,EACA+B,aAAa5b,UAAUge,UAAY,SAAU1d,GACzC,IAAImc,EAAiB3c,KAAK2c;AAC1B,IAAKA,EAAepY,IAAI/D,GAAW,CAC/B,IAAIof,EAAc5f,KAAKiL,MAAM1K,kBAAkBC,GAC3Cqf,GAAU,QAAsC7f,KAAKiL,MAAMnK,iBAAiB8e,IAC5E7I,EAAc/W,KAAKsc,WAAWvF,YAAY6I,GAC1C5I,EAAc6I,GAAW7f,KAAKsc,WAAWtF,YAAY6I,GACrDC,EAAe,CACftf,SAAUof,EACVxB,kBAAkB,QAAiBwB,GACnCG,mBAAoB/f,KAAKsc,WAAWhF,qBAAqBsI,GACzD7I,YAAaA,EACbC,YAAaA,EACbgJ,aAAa,SAAiB,QAAuBJ,KAErDlY,IAAM,SAAUuY,GACZA,IAAQtD,EAAepY,IAAI0b,IAC3BtD,EAAehQ,IAAIsT,EAAKH,EAEhC;AACApY,IAAIlH,GACJkH,IAAIkY,GACJlY,IAAIqP,GACJrP,IAAIsP,EACR,CACA,OAAO2F,EAAexY,IAAI3D,EAC9B,EACAsb,aAAa5b,UAAUie,aAAe,SAAU3d,EAAUa,GACtD,OAAO,SAAS,QAAS,CAAC,EAAGrB,KAAKke,UAAU1d,GAAUwf,aAAc3e,EACxE,EACAya,aAAa5b,UAAUggB,WAAa,SAAUrf,QAES,KADnDA,GAAU,SAAS,QAAS,CAAC,EAAGA,GAAU,CAAEQ,UAAWrB,KAAKme,aAAatd,EAAQO,MAAOP,EAAQQ,cAC7E8e,8BACftf,EAAQsf,6BAA8B;AAE1C,IAAI1B,EAAY,IAAInF,EAAUtZ,KAAKiL,OAC/BmV,EAAa,IAAIC,EAAA,EAAgB,CACjCC,aAActgB,KACdye,UAAWA,EACX5d,QAASA;AAQb,OANAb,KAAKyc,QAAQ9P,IAAIyT,EAAWnD,QAASwB,GACrCA,EAAU9E,KAAK,CACXnZ,SAAUK,EAAQO,MAClBsY,gBAAiB0G,EACjB/e,UAAWR,EAAQQ,YAEhB+e,CACX,EACAtE,aAAa5b,UAAUkB,MAAQ,SAAUP,GACrC,IAAIiD,EAAQ9D,MAC4B,QAAUa,EAAQO,MAAO,KAEzB,QAAiC,aAAvBP,EAAQO,MAAMyW,KAAqB,KAC7C,SAAWhX,EAAQkK,kBAAmB,KACtC,SAAWlK,EAAQ0f,aAAc;AACzE,IAAItD,EAAUjd,KAAKwgB;AACnB,OAAOxgB,KAAKsf,WAAWrC,EAASpc,GAAS4f,SAAQ,WAAc,OAAO3c,EAAM4c,UAAUzD,EAAU,GACpG,EACAnB,aAAa5b,UAAUsgB,gBAAkB,WACrC,OAAOpQ,OAAOpQ,KAAK4c,iBACvB,EACAd,aAAa5b,UAAUygB,kBAAoB,WACvC,OAAO3gB,KAAK6c,kBAChB,EACAf,aAAa5b,UAAU+d,mBAAqB,WACxC,OAAO7N,OAAOpQ,KAAK8c,oBACvB,EACAhB,aAAa5b,UAAU0gB,iBAAmB,SAAU3D,GAChDjd,KAAK6gB,4BAA4B5D,GACjCjd,KAAK2e,kBACT,EACA7C,aAAa5b,UAAU2gB,4BAA8B,SAAU5D,GAC3D,IAAIwB,EAAYze,KAAKyc,QAAQtY,IAAI8Y;AAC7BwB,GACAA,EAAUzD,MAClB,EACAc,aAAa5b,UAAU4gB,WAAa,WAWhC,OAVA9gB,KAAKmd,qBAA6D,IAAI,KAAe,KACrFnd,KAAKyc,QAAQ7W,SAAQ,SAAU6Y,GACvBA,EAAU/E,gBACV+E,EAAU7E,cAAgB,YAG1B6E,EAAUzD,MAElB,IACAhb,KAAKwc,cAAc1H,QACZ9U,KAAKiL,MAAM6J,OACtB,EACAgH,aAAa5b,UAAU6gB,WAAa,WAChC,IAAIjd,EAAQ9D;AACZ,OAAOA,KAAK8gB,aAAalK,MAAK,WAC1B,OAAO9S,EAAMkd,0BACjB,GACJ,EACAlF,aAAa5b,UAAU8gB,yBAA2B,SAAUC,GACxD,IAAInd,EAAQ9D;KACW,IAAnBihB,IAA6BA,GAAiB;AAClD,IAAIC,EAA0B;AAc9B,OAbAlhB,KAAKyc,QAAQ7W,SAAQ,SAAUgB,EAAIqW,GAC/B,IAAIvD,EAAkB9S,EAAG8S;AACzB,GAAIA,EAAiB,CACjB,IAAIqB,EAAcrB,EAAgB7Y,QAAQka;AAC1CrB,EAAgByH,mBACI,eAAhBpG,IACCkG,GAAkC,YAAhBlG,GACnBmG,EAAwBlV,KAAK0N,EAAgB0F,WAEjDtb,EAAMsd,SAASnE,GAAS9C,QAAQ,KACpC,CACJ,IACAna,KAAK2e,mBACE5J,QAAQ6D,IAAIsI,EACvB,EACApF,aAAa5b,UAAU8Z,mBAAqB,SAAUN,GAClD1Z,KAAKohB,SAAS1H,EAAgBuD,SAASjD,mBAAmBN,EAC9D,EACAoC,aAAa5b,UAAUmhB,yBAA2B,SAAUza,GACxD,IAAI9C,EAAQ9D,KACRoB,EAAQwF,EAAGxF,MAAO2Z,EAAcnU,EAAGmU,YAAa1Z,EAAYuF,EAAGvF,UAAW2H,EAAKpC,EAAGkD,QAASA,OAAiB,IAAPd,EAAgB,CAAC,EAAIA;AAC9H5H,EAAQpB,KAAKke,UAAU9c,GAAOZ,SAC9Ba,EAAYrB,KAAKme,aAAa/c,EAAOC;AACrC,IAAIigB,eAAiB,SAAUjgB,GAC3B,OAAOyC,EAAMgb,sBAAsB1d,EAAO0I,EAASzI,GAAW,GAAOyL,KAAI,SAAUlL,GAY/E,GAXKmZ,GAA+B,aAAhBA,KACX,QAAsBnZ,IACvBkC,EAAMmH,MAAMvJ,MAAM,CACdN,MAAOA,EACPQ,OAAQA,EAAOC,KACfF,OAAQ,oBACRN,UAAWA,IAGnByC,EAAM6a,qBAEN,QAAsB/c,GACtB,MAAM,IAAI,IAAY,CAClBmY,cAAenY,EAAO0Z;AAG9B,OAAO1Z,CACX,GACJ;AACA,GAAI5B,KAAKke,UAAU9c,GAAOgd,iBAAkB,CACxC,IAAImD,EAAsBvhB,KAAKsc,WAAWnF,qBAAqB/V,EAAOC,EAAWyI,GAAS8M,KAAK0K;AAC/F,OAAO,IAAI,MAAW,SAAUE,GAC5B,IAAIC,EAAM;AAEV,OADAF,EAAoB3K,MAAK,SAAUwJ,GAAc,OAAOqB,EAAMrB,EAAWrB,UAAUyC,EAAW,GAAGA,EAAS5L,OACnG,WAAc,OAAO6L,GAAOA,EAAIC,aAAe,CAC1D,GACJ,CACA,OAAOJ,eAAejgB,EAC1B,EACAya,aAAa5b,UAAUwgB,UAAY,SAAUzD,GACzCjd,KAAKkd,qBAAqBD,GAC1Bjd,KAAK2e,kBACT,EACA7C,aAAa5b,UAAUgd,qBAAuB,SAAUD,GACpDjd,KAAK6gB,4BAA4B5D,GACjCjd,KAAK2hB,YAAY1E,EACrB,EACAnB,aAAa5b,UAAUyhB,YAAc,SAAU1E,GAC3Cjd,KAAK0c,eAAehW,OAAOuW,GAC3Bjd,KAAKohB,SAASnE,GAASxD,cAAc7T,SAAQ,SAAUgc,GAAK,OAAOA,EAAEF,aAAe,IACpF1hB,KAAKyc,QAAQ/V,OAAOuW,EACxB,EACAnB,aAAa5b,UAAUye,iBAAmB,WACtC3e,KAAKic,cACLjc,KAAKyc,QAAQ7W,SAAQ,SAAUiN,GAAQ,OAAOA,EAAK0H,QAAU,GACjE,EACAuB,aAAa5b,UAAU2hB,cAAgB,WACnC,OAAO7hB,KAAKsc,UAChB,EACAR,aAAa5b,UAAU4e,sBAAwB,SAAU1d,EAAO0I,EAASzI,EAAWygB,GAChF,IACIlb,EAEAwZ,EAHAtc,EAAQ9D;KAEU,IAAlB8hB,IAA4BA,EAAwG,QAAvFlb,EAAKkD,aAAyC,EAASA,EAAQkS,0BAAuC,IAAPpV,EAAgBA,EAAK5G,KAAKgc;AAE1K,IAAIhF,EAAchX,KAAKke,UAAU9c,GAAO4V;AACxC,GAAIA,EAAa,CACb,IAAe+K,EAAN/hB,KAAqC+c,wBAAyBhB,EAA9D/b,KAAwE+b,KAC7E3D,EAAY,CACZhX,MAAO4V,EACP3V,UAAWA,EACX2gB,eAAe,QAAiBhL,SAAgB,EAChDlN,QAAS9J,KAAKiX,gBAAe,SAAS,QAAS,CAAC,EAAGnN,GAAU,CAAEmY,YAAaH;AAGhF,GADAhY,EAAUsO,EAAUtO,QAChBgY,EAAe,CACf,IAAII,EAAgBH,EAA0B5d,IAAI6S,IAAgB,IAAIjD;AACtEgO,EAA0BpV,IAAIqK,EAAakL;AAC3C,IAAIC,EAAYhX,KAAKC,UAAU/J;AAE/B,KADA+e,EAAa8B,EAAc/d,IAAIge,IACd,CACb,IAAIC,EAAU,IAAI,KAAQ,EACtB,QAAQrG,EAAM3D;AAElB8J,EAAcvV,IAAIwV,EAAW/B,EAAagC,GAC1CA,EAAQC,SAAQ,WACRH,EAAcxb,OAAOyb,IACrBD,EAAcpH,KAAO,GACrBiH,EAA0Brb,OAAOsQ,EAEzC,GACJ,CACJ,MAEIoJ,EAAa,IAAI,KAAQ,EACrB,QAAQrE,EAAM3D,IAG1B,MAEIgI,EAAa,IAAI,KAAQ,CACrB,QAAc,CAAEve,KAAM,CAAC,MAE3BiI,EAAU9J,KAAKiX,eAAenN;AAElC,IAAIiN,EAAc/W,KAAKke,UAAU9c,GAAO2V;AAWxC,OAVIA,IACAqJ,GAAa,QAASA,GAAY,SAAUxe,GACxC,OAAOkC,EAAMwY,WAAW9F,aAAa,CACjChW,SAAUuW,EACVN,aAAc7U,EACdkI,QAASA,EACTzI,UAAWA,GAEnB,KAEG+e,CACX,EACAtE,aAAa5b,UAAUoiB,mBAAqB,SAAU7D,EAAWpD,EAAiBxa,GAC9E,IAAI2Y,EAAgBiF,EAAUjF;AAC9B,OAAO,QAASxZ,KAAK8e,sBAAsBL,EAAUje,SAAUK,EAAQiJ,QAASjJ,EAAQQ,YAAY,SAAUO,GAC1G,IAAI2gB,GAAY,QAAgB3gB,EAAO0Z;AACvC,GAAI9B,GAAiBiF,EAAUjF,cAAe,CAC1C,GAAI+I,GAAqC,SAAxB1hB,EAAQ2a,YACrB,MAAMiD,EAAU5C,UAAU,IAAI,IAAY,CACtC9B,cAAenY,EAAO0Z;AAG9BmD,EAAUrD,WAAWxZ,EAAQf,EAASwa,GACtCoD,EAAU7C,WACd,CACA,IAAI4G,EAAM,CACN3gB,KAAMD,EAAOC,KACb8T,SAAS,EACTiE,cAAe6E,EAAU7E,eAAiB;AAK9C,OAHI2I,GAAqC,WAAxB1hB,EAAQ2a,cACrBgH,EAAIlH,OAAS1Z,EAAO0Z,QAEjBkH,CACX,IAAG,SAAU1I,GACT,IAAIlE,GAAQ,OAAckE,GACpBA,EACA,IAAI,IAAY,CAAEA,aAAcA;AAItC,MAHIN,GAAiBiF,EAAUjF,eAC3BiF,EAAU5C,UAAUjG,GAElBA,CACV,GACJ,EACAkG,aAAa5b,UAAUqf,qBAAuB,SAAUtC,EAASpc,EAAS+Y,GACtE,IAAI9V,EAAQ9D;KACU,IAAlB4Z,IAA4BA,EAAgB;AAChD,IAAIxY,EAAQpB,KAAKke,UAAUrd,EAAQO,OAAOZ,SACtCa,EAAYrB,KAAKme,aAAa/c,EAAOP,EAAQQ,WAC7Cod,EAAYze,KAAKohB,SAASnE,GAC1BwF,EAAmBhE,EAAU7E,cAC7BhT,EAAK/F,EAAQka,YAAaA,OAAqB,IAAPnU,EAAgB,cAAgBA,EAAIoC,EAAKnI,EAAQ2a,YAAaA,OAAqB,IAAPxS,EAAgB,OAASA,EAAIgC,EAAKnK,EAAQkK,kBAAmBA,OAA2B,IAAPC,GAAwBA,EAAIkR,EAAKrb,EAAQsf,4BAA6BA,OAAqC,IAAPjE,GAAwBA,EAAIE,EAAKvb,EAAQiJ,QAASA,OAAiB,IAAPsS,EAAgB,CAAC,EAAIA,GACxV,gBAAhBrB,GACF,sBAAhBA,GACgB,iBAAhBA,GACgB,aAAhBA,IAEAoF,GAC4B,iBAArBsC,GACPA,IAAqB7I,IACrB,OAAyBA,KACL,gBAAhBmB,IACAA,EAAc,qBAElBhQ,GAAoB;AAExB,IAAI2X,EAAatgB,OAAOyX,OAAO,CAAC,EAAGhZ,EAAS,CACxCO,MAAOA,EACPC,UAAWA,EACX0Z,YAAaA,EACbS,YAAaA,EACbzQ,kBAAmBA,EACnBoV,4BAA6BA,EAC7BrW,QAASA,IAET6Y,cAAgB,SAAUthB,GAE1B,OADAqhB,EAAWrhB,UAAYA,EAChByC,EAAM8e,mBAAmBnE,EAAWiE,EAAY9I,EAC3D;AACA5Z,KAAK0c,eAAe/P,IAAIsQ,GAAS,SAAU4F,GACvC9N,QAAQC,UAAU4B,MAAK,WAAc,OAAOwL,EAAQnH,OAAO4H,EAAS,GACxE;AACA,IAAIT,EAAU,IAAI,KAAQpiB,KAAKke,UAAUwE,EAAWthB,OAAOgd,iBACrDpe,KAAKsc,WAAWnF,qBAAqBuL,EAAWthB,MAAOshB,EAAWrhB,UAAWqhB,EAAW5Y,SAAS8M,KAAK+L,eACtGA,cAAcD,EAAWrhB;AAQ/B,OAPA+gB,EAAQC,SAAQ,WACZve,EAAM4Y,eAAehW,OAAOuW,GACxBpc,EAAQiiB,kBACRjiB,EAAQka,YAAcla,EAAQiiB,gBAC9BjiB,EAAQiiB,qBAAkB,EAElC,IACOV,CACX,EACAtG,aAAa5b,UAAU0iB,mBAAqB,SAAUnE,EAAW5d,EAAS+Y,GACtE,IAAI9V,EAAQ9D,KACRoB,EAAQP,EAAQO,MAAOC,EAAYR,EAAQQ,UAAW0Z,EAAcla,EAAQka,YAAaS,EAAc3a,EAAQ2a,YAAazQ,EAAoBlK,EAAQkK,kBAAmBjB,EAAUjJ,EAAQiJ;AACjM2U,EAAU9E,KAAK,CACXnZ,SAAUY,EACVC,UAAWA,EACXmY,cAAexZ,KAAK2gB,oBACpB/G,cAAeA;AAEnB,IAAImJ,UAAY,WAAc,OAAOtE,EAAUxE,QAAQ5Y,EAAY,EAC/D2hB,iBAAmB,SAAUrO,EAAMiF,QACb,IAAlBA,IAA4BA,EAAgB6E,EAAU7E,eAAiB;AAC3E,IAAI/X,EAAO8S,EAAK/S;AAMhB,IAAIqhB,SAAW,SAAUphB,GAAQ,OAAO,SAAc,QAAS,CAAEA,KAAMA,EAAM8T,SAAS,OAAyBiE,GAAgBA,cAAeA,GAAkBjF,EAAKnJ,SAAW,KAAO,CAAE0X,SAAS,IAAW;AAC7M,OAAIpf,EAAMoa,UAAU9c,GAAO2e,mBAChBjc,EAAMwY,WAAW9F,aAAa,CACjChW,SAAUY,EACVqV,aAAc,CAAE5U,KAAMA,GACtBiI,QAASA,EACTzI,UAAWA,EACXqV,wBAAwB,IACzBE,MAAK,SAAUuM,GAAY,OAAOF,SAASE,EAASthB,KAAO,IAE3DohB,SAASphB,EACpB,EACIuhB,gBAAkB,SAAU/H,GAC5B,OAAOvX,EAAMwe,mBAAmB7D,EAAWpD,EAAiB,CACxDha,UAAWA,EACXyI,QAASA,EACTiR,YAAaA,EACbS,YAAaA,GAErB;AACA,OAAQT,GACJ,QACA,IAAK,cAED,OADIpG,EAAOoO,aACFvX,SACE,CACHwX,iBAAiBrO,EAAM8J,EAAU7C,cAGrC7Q,EACO,CACHiY,iBAAiBrO,GACjByO,iBAAgB,IAGjB,CACHA,iBAAgB;AAGxB,IAAK,oBACD,IAAIzO;AACJ,OADIA,EAAOoO,aACFvX,UAAYT,EACV,CACHiY,iBAAiBrO,GACjByO,iBAAgB,IAGjB,CACHA,iBAAgB;AAGxB,IAAK,aACD,MAAO,CACHJ,iBAAiBD,YAAatE,EAAU7C;AAEhD,IAAK,eACD,MAAO,CAACwH,iBAAgB;AAC5B,IAAK,WACD,MAAO,CAACA,iBAAgB;AAC5B,IAAK,UACD,MAAO,GAEnB,EACAtH,aAAa5b,UAAUkhB,SAAW,SAAUnE,GAIxC,OAHIA,IAAYjd,KAAKyc,QAAQlY,IAAI0Y,IAC7Bjd,KAAKyc,QAAQ9P,IAAIsQ,EAAS,IAAI3D,EAAUtZ,KAAKiL,QAE1CjL,KAAKyc,QAAQtY,IAAI8Y,EAC5B,EACAnB,aAAa5b,UAAU+W,eAAiB,SAAUnN,QAC9B,IAAZA,IAAsBA,EAAU,CAAC;AACrC,IAAIuZ,EAAarjB,KAAKsc,WAAWrF,eAAenN;AAChD,OAAO,SAAS,QAAS,CAAC,EAAGuZ,GAAa,CAAEhH,gBAAiBrc,KAAKqc,iBACtE,EACOP,YACX,CA3mBmB;AA6mBnB,SAAShG,mBAAmBJ,EAAUzK,GAClC,KAAK,QAAsByK,EAAS9T,QAAS,CACzC,IAAI0hB,EAAgB,CAAC,CACb1hB,OAAQ8T,EAAS9T,OAAOC,KACxBF,OAAQ,gBACRP,MAAOsU,EAASlV,SAChBa,UAAWqU,EAASrU,YAExBkiB,EAAsB7N,EAASgJ;AAC/B6E,GACAnhB,OAAOuD,KAAK4d,GAAqB3d,SAAQ,SAAUzE,GAC/C,IAAIyF,EAAK2c,EAAoBpiB,GAAKqd,EAAU5X,EAAG4X,QAASxV,EAAKpC,EAAG6X,UAAWje,EAAWwI,EAAGxI,SAAUa,EAAY2H,EAAG3H,UAC9G2J,EAAKC,EAAM0J,KAAK,CAChBvT,MAAOZ,EACPa,UAAWA,EACX0J,mBAAmB,EACnB/J,YAAY,IACZwiB,EAAqBxY,EAAGpJ;AAC5B,GAD+CoJ,EAAGQ,UAClCgY,EAAoB,CAChC,IAAIC,EAAkBjF,EAAQgF,EAAoB,CAC9CE,eAAgBhO,EAAS9T,OACzB2c,WAAW,QAAiB/d,SAAamf,EACzCgE,eAAgBtiB;AAEhBoiB,GACAH,EAActX,KAAK,CACfpK,OAAQ6hB,EACR9hB,OAAQ,aACRP,MAAOZ,EACPa,UAAWA,GAGvB,CACJ,IAEJ4J,EAAM3K,oBAAmB,SAAU4T,GAC/BoP,EAAc1d,SAAQ,SAAUlE,GAAS,OAAOwS,EAAExS,MAAMA,EAAQ;AAChE,IAAIic,EAASjI,EAASiI;AAClBA,GACAA,EAAOzJ,EAAGwB,EAAS9T,OAE3B,GAAG,KACP,CACJ,CC5pBA,IACIgiB,EAAgB,WAChB,SAASA,aAAa/iB,GAClB,IAAIiD,EAAQ9D;AACZA,KAAK6jB,eAAiB,CAAC,EACvB7jB,KAAK8jB,oBAAsB,GAC3B9jB,KAAK+jB,oBAAsB;AAC3B,IAAIC,EAAMnjB,EAAQmjB,IAAKC,EAAcpjB,EAAQojB,YAAaC,EAAUrjB,EAAQqjB,QAASjZ,EAAQpK,EAAQoK,MAAOrE,EAAK/F,EAAQsb,QAASA,OAAiB,IAAPvV,GAAwBA,EAAIoC,EAAKnI,EAAQsjB,mBAAoBA,OAA4B,IAAPnb,EAAgB,EAAIA,EAAIob,EAAoBvjB,EAAQujB,kBAAmBpZ,EAAKnK,EAAQmb,mBAAoBA,OAA4B,IAAPhR,GAAuBA,EAAI6Y,EAAiBhjB,EAAQgjB,eAAgB3H,EAAKrb,EAAQ0b,uBAAwBA,OAAgC,IAAPL,GAAwBA,EAAIjG,EAAYpV,EAAQoV,UAAWoO,EAAWxjB,EAAQwjB,SAAUnO,EAAkBrV,EAAQqV,gBAAiBoO,EAAsBzjB,EAAQ0L,KAAMgY,EAAyB1jB,EAAQ2jB,QACjqBzI,EAAOlb,EAAQkb;AAMnB,GALKA,IACDA,EAAOiI,EACD,IAAI,KAAS,CAAEA,IAAKA,EAAKC,YAAaA,EAAaC,QAASA,IAC5D,eAELjZ,EACD,MAA8C,IAAI,KAAe;AAIrEjL,KAAK+b,KAAOA,EACZ/b,KAAKiL,MAAQA,EACbjL,KAAKykB,sBAAwBtI,GAAWgI,EAAqB,EAC7DnkB,KAAKgc,mBAAqBA,EAC1Bhc,KAAK6jB,eAAiBA,GAAkB,CAAC,EACzC7jB,KAAKqkB,SAAWA,EACZF,GACA7J,YAAW,WAAc,OAAQxW,EAAM2gB,uBAAwB,CAAQ,GAAGN,GAE9EnkB,KAAKkgB,WAAalgB,KAAKkgB,WAAWwE,KAAK1kB,MACvCA,KAAKoB,MAAQpB,KAAKoB,MAAMsjB,KAAK1kB,MAC7BA,KAAKod,OAASpd,KAAKod,OAAOsH,KAAK1kB,MAC/BA,KAAK+gB,WAAa/gB,KAAK+gB,WAAW2D,KAAK1kB,MACvCA,KAAKghB,yBAA2BhhB,KAAKghB,yBAAyB0D,KAAK1kB;KAIlC,IAAtBokB,IAELA,GAAuC,oBAAXO,UAC9BA,OAAOC,kBAAoB5kB,MAkB/BA,KAAKwkB,QCjEQ,QDkEbxkB,KAAKsc,WAAa,IAAIvG,EAAW,CAC7B9K,MAAOA,EACP+K,OAAQhW,KACRiW,UAAWA,EACXC,gBAAiBA,IAErBlW,KAAKsgB,aAAe,IAAIxE,EAAa,CACjC7Q,MAAOjL,KAAKiL,MACZ8Q,KAAM/b,KAAK+b,KACXC,mBAAoBA,EACpBG,QAASA,EACTE,gBAAiB,CACb9P,KAAM+X,EACNE,QAASD,GAEbjI,WAAYtc,KAAKsc,WACjBC,uBAAwBA,EACxBN,YAAa,WACLnY,EAAM+gB,gBACN/gB,EAAM+gB,eAAe,CACjBC,OAAQ,CAAC,EACTC,MAAO,CACHtI,QAAS3Y,EAAMwc,aAAab,gBAC5BuF,UAAWlhB,EAAMwc,aAAa9D,cAAcjH,YAEhD0P,0BAA2BnhB,EAAMmH,MAAMyJ,SAAQ,IAG3D,GAER,CA8GA,OA7GAkP,aAAa1jB,UAAU8a,KAAO,WAC1Bhb,KAAKsgB,aAAatF,MACtB,EACA4I,aAAa1jB,UAAUggB,WAAa,SAAUrf,GAS1C,OARIb,KAAK6jB,eAAe3D,aACpBrf,GAAU,QAAQb,KAAK6jB,eAAe3D,WAAYrf,KAElDb,KAAKykB,uBACoB,iBAAxB5jB,EAAQka,aACmB,sBAAxBla,EAAQka,cACZla,GAAU,SAAS,QAAS,CAAC,EAAGA,GAAU,CAAEka,YAAa,iBAEtD/a,KAAKsgB,aAAaJ,WAAWrf,EACxC,EACA+iB,aAAa1jB,UAAUkB,MAAQ,SAAUP,GAWrC,OAVIb,KAAK6jB,eAAeziB,QACpBP,GAAU,QAAQb,KAAK6jB,eAAeziB,MAAOP,KAET,QAAkC,sBAAxBA,EAAQka,YAAqC,IAI3F/a,KAAKykB,uBAAiD,iBAAxB5jB,EAAQka,cACtCla,GAAU,SAAS,QAAS,CAAC,EAAGA,GAAU,CAAEka,YAAa,iBAEtD/a,KAAKsgB,aAAalf,MAAMP,EACnC,EACA+iB,aAAa1jB,UAAUkd,OAAS,SAAUvc,GAItC,OAHIb,KAAK6jB,eAAezG,SACpBvc,GAAU,QAAQb,KAAK6jB,eAAezG,OAAQvc,IAE3Cb,KAAKsgB,aAAalD,OAAOvc,EACpC,EACA+iB,aAAa1jB,UAAU6e,UAAY,SAAUle,GACzC,OAAOb,KAAKsgB,aAAae,yBAAyBxgB,EACtD,EACA+iB,aAAa1jB,UAAUa,UAAY,SAAUF,EAASG,GAElD,YADmB,IAAfA,IAAyBA,GAAa,GACnChB,KAAKiL,MAAMlK,UAAUF,EAASG,EACzC,EACA4iB,aAAa1jB,UAAUoB,aAAe,SAAUT,EAASG,GAErD,YADmB,IAAfA,IAAyBA,GAAa,GACnChB,KAAKiL,MAAM3J,aAAaT,EAASG,EAC5C,EACA4iB,aAAa1jB,UAAUuB,WAAa,SAAUZ,GAC1Cb,KAAKiL,MAAMxJ,WAAWZ,GACtBb,KAAKsgB,aAAa3B,kBACtB,EACAiF,aAAa1jB,UAAU6B,cAAgB,SAAUlB,GAC7Cb,KAAKiL,MAAMlJ,cAAclB,GACzBb,KAAKsgB,aAAa3B,kBACtB,EACAiF,aAAa1jB,UAAUglB,wBAA0B,SAAUC,GACvDnlB,KAAK6kB,eAAiBM,CAC1B,EACAvB,aAAa1jB,UAAUklB,aAAe,SAAUC,GAC5C,OAAO,QAAQrlB,KAAK+b,KAAMsJ,EAC9B,EACAzB,aAAa1jB,UAAU6gB,WAAa,WAChC,IAAIjd,EAAQ9D;AACZ,OAAO+U,QAAQC,UACV4B,MAAK,WAAc,OAAO9S,EAAMwc,aAAaQ,YAAc,IAC3DlK,MAAK,WAAc,OAAO7B,QAAQ6D,IAAI9U,EAAMggB,oBAAoBhX,KAAI,SAAUwY,GAAM,OAAOA,GAAM,IAAK,IACtG1O,MAAK,WAAc,OAAO9S,EAAMkd,0BAA4B,GACrE,EACA4C,aAAa1jB,UAAU4gB,WAAa,WAChC,IAAIhd,EAAQ9D;AACZ,OAAO+U,QAAQC,UACV4B,MAAK,WAAc,OAAO9S,EAAMwc,aAAaQ,YAAc,IAC3DlK,MAAK,WAAc,OAAO7B,QAAQ6D,IAAI9U,EAAMigB,oBAAoBjX,KAAI,SAAUwY,GAAM,OAAOA,GAAM,IAAK,GAC/G,EACA1B,aAAa1jB,UAAUqlB,aAAe,SAAUJ,GAC5C,IAAIrhB,EAAQ9D;AAEZ,OADAA,KAAK8jB,oBAAoB9X,KAAKmZ,GACvB,WACHrhB,EAAMggB,oBAAsBhgB,EAAMggB,oBAAoBzb,QAAO,SAAU6L,GAAK,OAAOA,IAAMiR,CAAI,GACjG,CACJ,EACAvB,aAAa1jB,UAAUslB,aAAe,SAAUL,GAC5C,IAAIrhB,EAAQ9D;AAEZ,OADAA,KAAK+jB,oBAAoB/X,KAAKmZ,GACvB,WACHrhB,EAAMigB,oBAAsBjgB,EAAMigB,oBAAoB1b,QAAO,SAAU6L,GAAK,OAAOA,IAAMiR,CAAI,GACjG,CACJ,EACAvB,aAAa1jB,UAAU8gB,yBAA2B,SAAUC,GACxD,OAAOjhB,KAAKsgB,aAAaU,yBAAyBC,EACtD,EACA2C,aAAa1jB,UAAUwU,QAAU,SAAU1T,GACvC,OAAOhB,KAAKiL,MAAMyJ,QAAQ1T,EAC9B,EACA4iB,aAAa1jB,UAAUuU,QAAU,SAAUgR,GACvC,OAAOzlB,KAAKiL,MAAMwJ,QAAQgR,EAC9B,EACA7B,aAAa1jB,UAAUiW,aAAe,SAAUF,GAC5CjW,KAAKsc,WAAWnG,aAAaF,EACjC,EACA2N,aAAa1jB,UAAUoW,aAAe,SAAUL,GAC5CjW,KAAKsc,WAAWhG,aAAaL,EACjC,EACA2N,aAAa1jB,UAAUqW,aAAe,WAClC,OAAOvW,KAAKsc,WAAW/F,cAC3B,EACAqN,aAAa1jB,UAAUwlB,6BAA+B,SAAUxP,GAC5DlW,KAAKsc,WAAWlG,mBAAmBF,EACvC,EACA0N,aAAa1jB,UAAUylB,QAAU,SAAUC,GACvC5lB,KAAK+b,KAAO/b,KAAKsgB,aAAavE,KAAO6J,CACzC,EACOhC,YACX,CAtMmB,E;;2DENfiC,EAAc,WACd,SAASA,WAAWrE,EAAU3gB,EAASilB,EAAOC,GAC1C/lB,KAAKwhB,SAAWA,EAChBxhB,KAAKa,QAAUA,EACfb,KAAK8lB,MAAQA,EACb9lB,KAAK+lB,YAAcA,CACvB,CAyEA,OAxEAF,WAAW3lB,UAAUwa,UAAY,SAAUsL,EAAYC,GAC/CD,EACAhmB,KAAKkmB,cAAcF,GAGnBhmB,KAAKmmB;AAET,IAAI/D,EAAUpiB,KAAK8lB,MAAM9lB,KAAKa,QAASolB;AAKvC,OAJIjmB,KAAKoiB,SACLpiB,KAAKoiB,QAAQgE,eAAepmB,KAAKwhB,UAAU,GAE/CY,EAAQiE,YAAYrmB,KAAKwhB,WACjBxhB,KAAKoiB,QAAUA,GAAS5C,OACpC,EACAqG,WAAW3lB,UAAUgmB,cAAgB,SAAUF,GAG3C,OAFA5jB,OAAOyX,OAAO7Z,KAAKa,SAAS,QAAQmlB,IACpChmB,KAAKmmB,gBACEnmB,IACX,EACA6lB,WAAW3lB,UAAU8a,KAAO,WACpBhb,KAAKoiB,UACLpiB,KAAKoiB,QAAQgE,eAAepmB,KAAKwhB,iBAC1BxhB,KAAKoiB,SAEZpiB,KAAKsmB,cACL3L,aAAa3a,KAAKsmB,YAAYC,SAC9BvmB,KAAKa,QAAQ0f,aAAe,EAC5BvgB,KAAKmmB,gBAEb,EACAN,WAAW3lB,UAAUimB,cAAgB,WACjC,IAAIriB,EAAQ9D,KACGsmB,EAANtmB,KAAuBsmB,YAAa/F,EAApCvgB,KAAsDa,QAAQ0f;AACvE,GAAKA,GAOL,KAAI+F,GACAA,EAAYE,WAAajG,MAGW,QAAUA,EAAc,KACvC,IAArBvgB,KAAK+lB,aAAT,EAGWO,IAAgBtmB,KAAKsmB,YAAc,CAAC,IAC1CE,SAAWjG;AAChB,IAAIkG,WAAa,WACT3iB,EAAMwiB,cACFxiB,EAAMiiB,aAAejiB,EAAMiiB,cAC3BjiB,EAAM4W,UAAU,CACZK,YAAa,gBACd,UAAoBnE,KAAK8P,KAAMA,MAGlCA,OAIZ,EACIA,KAAO,WACP,IAAI7T,EAAO/O,EAAMwiB;AACbzT,IACA8H,aAAa9H,EAAK0T,SAClB1T,EAAK0T,QAAUjM,WAAWmM,WAAY5T,EAAK2T,UAEnD;AACAE,MAvBA,OAbQJ,IACA3L,aAAa2L,EAAYC,gBAClBvmB,KAAKsmB,YAmCxB,EACOT,UACX,CAhFiB,GCIbxF,EAAmB,SAAUtX,GAE7B,SAASsX,gBAAgBzZ,GACrB,IAAI0Z,EAAe1Z,EAAG0Z,aAAc7B,EAAY7X,EAAG6X,UAAW5d,EAAU+F,EAAG/F,QACvEiD,EAAQiF,EAAO/D,KAAKhF,MAAM,SAAUwhB,GACpC,OAAO1d,EAAM6iB,YAAYnF,EAC7B,KAAMxhB;AACN8D,EAAM8iB,UAAY,IAAInf,IACtB3D,EAAM2V,cAAgB,IAAIhS,IAC1B3D,EAAM0d,SAAW,CACbxC,KAAM,SAAUpd,IACRkC,EAAM+iB,WAAa/iB,EAAMgjB,0BAA0BllB,MACnDkC,EAAMijB,iBAAiBnlB,IACvB,QAAuBkC,EAAM8iB,UAAW,OAAQhlB,GAExD,EACAgU,MAAO,SAAUA,GACb9R,EAAMijB,kBAAiB,SAAS,QAAS,CAAC,EAAGjjB,EAAMkjB,YAAa,CAAEpR,MAAOA,EAAO0F,OAAQ1F,EAAMmE,cAAeH,cAAe,UAAqBjE,SAAS,MAC1J,QAAuB7R,EAAM8iB,UAAW,QAAS9iB,EAAM+iB,UAAYjR,EACvE,GAEJ9R,EAAMmjB,YAAa,EACnBnjB,EAAMjD,QAAUA,EAChBiD,EAAMmZ,QAAUqD,EAAaE;AAC7B,IAAI0G,GAAQ,QAAuBrmB,EAAQO;AAI3C,OAHA0C,EAAMya,UAAY2I,GAASA,EAAM3a,MAAQ2a,EAAM3a,KAAK7J,MACpDoB,EAAMwc,aAAeA,EACrBxc,EAAM2a,UAAYA,EACX3a,CACX,CAiSA,OA7TA,QAAUuc,gBAAiBtX,GA6B3B3G,OAAO+kB,eAAe9G,gBAAgBngB,UAAW,YAAa,CAC1DiE,IAAK,WACD,OAAOnE,KAAKa,QAAQQ,SACxB,EACA+lB,YAAY,EACZC,cAAc,IAElBhH,gBAAgBngB,UAAU0B,OAAS,WAC/B,IAAIkC,EAAQ9D;AACZ,OAAO,IAAI+U,SAAQ,SAAUC,EAAS4J,GAClC,IAAI4C,EAAW,CACXxC,KAAM,SAAUpd,GACZoT,EAAQpT,GACRkC,EAAM8iB,UAAUlgB,OAAO8a,GAClB1d,EAAM8iB,UAAU9L,MACjBhX,EAAMwc,aAAaqB,YAAY7d,EAAMmZ,SAEzC3C,YAAW,WACPgN,EAAa5F,aACjB,GAAG,EACP,EACA9L,MAAOgJ,GAEP0I,EAAexjB,EAAMib,UAAUyC,EACvC,GACJ,EACAnB,gBAAgBngB,UAAUqnB,iBAAmB,WACzC,IAAIP,EAAahnB,KAAKgnB,WAClBpN,EAAgB5Z,KAAKye,UAAU7E,eAC9BoN,GAAcA,EAAWpN,eAC1B,UACAhY,GAAS,SAAS,QAAS,CAAC,EAAGolB,GAAa,CAAErR,SAAS,OAAyBiE,GAAgBA,cAAeA;AACnH,GAAI5Z,KAAKinB,WACL,OAAOrlB;AAEX,IAAIgF,EAAK5G,KAAKa,QAAQka,YAAaA,OAAqB,IAAPnU,EAAgB,cAAgBA;AACjF,GAAoB,aAAhBmU,GACgB,iBAAhBA,EACAnZ,EAAOshB,SAAU;KAEhB,IAAKthB,EAAOC,OACZ7B,KAAKsgB,aAAapC,UAAUle,KAAKa,QAAQO,OAAO2e,mBAAoB,CACrE,IAAIpL,EAAO3U,KAAKye,UAAUxE;AAC1BrY,EAAOshB,SAAWvO,EAAKnJ,SACvB5J,EAAOC,KAAQ8S,EAAKnJ,UAChBxL,KAAKa,QAAQkK,kBAAqB4J,EAAK/S,YAAS,GAChD+S,EAAKnJ,UACL5J,EAAOgY,gBAAkB,aACR,gBAAhBmB,GACmB,eAAhBA,IACJnZ,EAAOgY,cAAgB,UACvBhY,EAAO+T,SAAU,EAEzB,CAEA,OADA3V,KAAK+mB,iBAAiBnlB,GACfA,CACX,EACAye,gBAAgBngB,UAAU4mB,0BAA4B,SAAUU,GAC5D,QAAQ,OAAMxnB,KAAKynB,mBAAoBD,EAC3C,EACAnH,gBAAgBngB,UAAUwnB,cAAgB,WACtC,OAAO1nB,KAAKgnB,UAChB,EACA3G,gBAAgBngB,UAAUynB,aAAe,WACrC,OAAO3nB,KAAK6mB,SAChB,EACAxG,gBAAgBngB,UAAUihB,iBAAmB,kBAClCnhB,KAAKgnB,kBACLhnB,KAAKynB,0BACLznB,KAAK6mB,UACZ7mB,KAAKinB,YAAa,CACtB,EACA5G,gBAAgBngB,UAAU0nB,sBAAwB,WAC9C5nB,KAAKsgB,aAAaZ,YAAY1f,KAAKid,QACvC,EACAoD,gBAAgBngB,UAAUkf,QAAU,SAAU/d,GAC1C,IAAI0Z,EAAc/a,KAAKa,QAAQka;AAC/B,GAAoB,eAAhBA,EACA,OAAOhG,QAAQ6J,OAA+C,IAAI,KAAe;AAErF,IAAIiJ,EAAmB,CACnBtH,aAAc;AAUlB,MARoB,aAAhBxF,GACgB,sBAAhBA,IACA8M,EAAiB9M,YAAc,eAC/B8M,EAAiB/E,gBAAkB/H,GAEnC1Z,KAAc,OAAMrB,KAAKa,QAAQQ,UAAWA,KAC5CwmB,EAAiBxmB,UAAYrB,KAAKa,QAAQQ,WAAY,SAAS,QAAS,CAAC,EAAGrB,KAAKa,QAAQQ,WAAYA,IAElGrB,KAAK8nB,eAAc,GAAOpN,UAAUmN,EAAkB,YACjE,EACAxH,gBAAgBngB,UAAU6nB,UAAY,SAAUC,GAC5C,IAAIlkB,EAAQ9D,KACRioB,GAAkB,SAAS,QAAS,CAAC,EAAID,EAAiB5mB,MAAQ4mB,GAAmB,SAAS,SAAS,QAAS,CAAC,EAAGhoB,KAAKa,SAAUmnB,GAAmB,CAAE3mB,WAAW,SAAS,QAAS,CAAC,EAAGrB,KAAKa,QAAQQ,WAAY2mB,EAAiB3mB,cAAiB,CAAE0Z,YAAa,aACnQmN,EAAMloB,KAAKsgB,aAAaE;AAC5B,GAAIyH,EAAgB9H,4BAA6B,CAC7C,IAAIgI,EAAgBnoB,KAAKunB;AACzBvnB,KAAKye,UAAU7E,cAAgB,cAC/B5Z,KAAKwhB,SAASxC,MAAK,SAAS,QAAS,CAAC,EAAGmJ,GAAgB,CAAExS,SAAS,EAAMiE,cAAe,gBAC7F,CACA,OAAO5Z,KAAKsgB,aAAahB,WAAW4I,EAAKD,EAAiB,eAAyBrR,MAAK,SAAUwR,GAC9F,IAAIvmB,EAAOumB,EAAgBvmB,KACvBwmB,EAAcL,EAAiBK;AAmBnC,OAlBIA,EAMAvkB,EAAMukB,aAAY,SAAUC,GAAY,OAAOD,EAAYC,EAAU,CACjEF,gBAAiBvmB,EACjBR,UAAW4mB,EAAgB5mB,WAC3B,IAGJyC,EAAMwc,aAAarV,MAAMxJ,WAAW,CAChCL,MAAO6mB,EAAgB7mB,MACvBC,UAAW4mB,EAAgB5mB,UAC3BQ,KAAMA,IAGPumB,CACX,IAAG3H,SAAQ,WACP3c,EAAMwc,aAAaI,UAAUwH,GAC7BpkB,EAAM4W,WACV,GACJ,EACA2F,gBAAgBngB,UAAUqoB,gBAAkB,SAAU1nB,GAClD,IAAIiD,EAAQ9D,KACRsnB,EAAetnB,KAAKsgB,aACnBe,yBAAyB,CAC1BjgB,MAAOP,EAAQL,SACfa,UAAWR,EAAQQ,UACnByI,QAASjJ,EAAQiJ,UAEhBiV,UAAU,CACXC,KAAM,SAAUwJ,GACZ,IAAIH,EAAcxnB,EAAQwnB;AACtBA,GACAvkB,EAAMukB,aAAY,SAAUC,EAAU1hB,GAClC,IAAIvF,EAAYuF,EAAGvF;AACnB,OAAOgnB,EAAYC,EAAU,CACzBE,iBAAkBA,EAClBnnB,UAAWA,GAEnB,GAER,EACAuU,MAAO,SAAU/L,GACThJ,EAAQ4nB,SACR5nB,EAAQ4nB,QAAQ5e,EAIxB;AAGJ,OADA7J,KAAKyZ,cAAc/R,IAAI4f,GAChB,WACCxjB,EAAM2V,cAAc/S,OAAO4gB,IAC3BA,EAAa5F,aAErB,CACJ,EACArB,gBAAgBngB,UAAUwoB,WAAa,SAAU1C,GAC7C,OAAOhmB,KAAK0a,UAAUsL,EAC1B,EACA3F,gBAAgBngB,UAAUyoB,aAAe,SAAUtnB,GAC/C,IAAI,OAAMrB,KAAKqB,UAAWA,GACtB,OAAOrB,KAAK4mB,UAAU9L,KAChB9a,KAAK4B,SACLmT,QAAQC;AAGlB,GADAhV,KAAKa,QAAQQ,UAAYA,GACpBrB,KAAK4mB,UAAU9L,KAChB,OAAO/F,QAAQC;AAEnB,IAAIpO,EAAK5G,KAAKa,QAAQka,YAAaA,OAAqB,IAAPnU,EAAgB,cAAgBA;AAMjF,MALoB,gBAAhBmU,GACgB,aAAhBA,GACgB,iBAAhBA,IACAA,EAAc,qBAEX/a,KAAK0a,UAAU,CAClBK,YAAaA,EACb1Z,UAAWA,GACZ,iBACP,EACAgf,gBAAgBngB,UAAUmoB,YAAc,SAAUO,GAC9C,IAAIhiB,EACA0Z,EAAetgB,KAAKsgB,aAQpBkH,EAAYoB,EAPHtI,EAAarV,MAAM0J,KAAK,CACjCvT,MAAOpB,KAAKa,QAAQO,MACpBC,UAAWrB,KAAKqB,UAChBwnB,eAA2C,QAA1BjiB,EAAK5G,KAAKgnB,kBAA+B,IAAPpgB,OAAgB,EAASA,EAAG/E,KAC/EkJ,mBAAmB,EACnB/J,YAAY,IACbY,OAC2B,CAC1BP,UAAWrB,KAAKqB;AAEhBmmB,IACAlH,EAAarV,MAAMxJ,WAAW,CAC1BL,MAAOpB,KAAKa,QAAQO,MACpBS,KAAM2lB,EACNnmB,UAAWrB,KAAKqB,YAEpBif,EAAa3B,mBAErB,EACA0B,gBAAgBngB,UAAU4oB,aAAe,SAAUvI,GAC/CvgB,KAAK+oB,gBAAgB7C,cAAc,CAAE3F,aAAcA,GACvD,EACAF,gBAAgBngB,UAAUgb,YAAc,WAChClb,KAAKgpB,YACLhpB,KAAKgpB,WAAW9C,cAAc,CAAE3F,aAAc,GAEtD,EACAF,gBAAgBngB,UAAU6mB,iBAAmB,SAAUS,GACnD,IAAIqB,EAAiB7oB,KAAKgnB;AAQ1B,OAPAhnB,KAAKgnB,WAAaQ,EAClBxnB,KAAKynB,mBAAqBznB,KAAKsgB,aAAa/D,uBACtCiL,GACA,QAAUA,IACX,QAAgBA,EAAUlM,gBACpBtb,KAAK6mB,UAETgC,CACX,EACAxI,gBAAgBngB,UAAUymB,YAAc,SAAUnF,GAC9C,IAAI1d,EAAQ9D;AACZ,GAAIwhB,IAAaxhB,KAAKwhB,SAClB,OAAO,WAAc;AAEzB,IACI,IAAIyH,EAAczH,EAAS0H,cAAcC;AACrCF,IAAgBA,EAAYrT,QAC5BqT,EAAYrT,MAAQwT,yCAE5B,CACA,MAAOxiB,GAAM,CACb,IAAIyiB,GAASrpB,KAAK4mB,UAAU9L;AAY5B,OAXA9a,KAAK4mB,UAAUlf,IAAI8Z,GACfxhB,KAAK6mB,UACLrF,EAAS5L,OAAS4L,EAAS5L,MAAM5V,KAAK6mB,WAEjC7mB,KAAKgnB,YACVxF,EAASxC,MAAQwC,EAASxC,KAAKhf,KAAKgnB,YAEpCqC,GACArpB,KAAK0a,YAAY4O,OAAM,SAAUja,GACjC,IAEG,WACCvL,EAAM8iB,UAAUlgB,OAAO8a,KAAc1d,EAAM8iB,UAAU9L,MACrDhX,EAAMylB,eAEd,CACJ,EACAlJ,gBAAgBngB,UAAU6oB,cAAgB,WACtC,OAAO/oB,KAAKgpB,aAAehpB,KAAKgpB,WAAahpB,KAAK8nB,eAAc,GACpE,EACAzH,gBAAgBngB,UAAU4nB,cAAgB,SAAU0B,GAChD,IAAI1lB,EAAQ9D,KACGsgB,EAANtgB,KAAwBsgB,aAAcrD,EAAtCjd,KAAmDid;AAE5D,OADAqD,EAAatG,mBAAmBha,MACzB,IAAI6lB,EAAW7lB,KAAKwhB,SAAUgI,EAAexpB,KAAKa,SAAU,QAAS,CAAC,EAAGb,KAAKa,UAAU,SAAU4oB,EAAgBxD,GAErH,OADA3F,EAAatG,mBAAmBlW,GACzBwc,EAAaf,qBAAqBtC,EAASwM,EAAgBxD,EACtE,IAAI3F,EAAanE,SAAW,WAAe,QAAQ,OAAyBrY,EAAM2a,UAAU7E,cAAiB,EACjH,EACAyG,gBAAgBngB,UAAUwa,UAAY,SAAUsL,EAAYC,GAExD,OADAjmB,KAAKinB,YAAa,EACXjnB,KAAK+oB,gBAAgBrO,UAAUsL,EAAYC,EACtD,EACA5F,gBAAgBngB,UAAUqpB,cAAgB,WACtC,IAAIjJ,EAAetgB,KAAKsgB;AACpBtgB,KAAKgpB,aACLhpB,KAAKgpB,WAAWhO,cACThb,KAAKgpB,YAEhBhpB,KAAKinB,YAAa,EAClBjnB,KAAKyZ,cAAc7T,SAAQ,SAAU6b,GAAO,OAAOA,EAAIC,aAAe,IACtE1hB,KAAKyZ,cAAcxS,QACnBqZ,EAAaI,UAAU1gB,KAAKid,SAC5Bjd,KAAK4mB,UAAU3f,OACnB,EACOoZ,eACX,CA/TsB,CA+TpB;AAEF,SAAS+I,yCAAyCxT,GAElD,C;;;;;;;;;;AC9TyB,iBAA2C,6BAAmE,yCAAgF,yC;ACZhN,IAAI8T;AAUJ,SAASC,yBAAyB/P,GACrC,QAAOA,GAAgBA,EAAgB,CAC3C,C,gDAXA,SAAW8P,GACPA,EAAcA,EAAuB,QAAI,GAAK,UAC9CA,EAAcA,EAA4B,aAAI,GAAK,eACnDA,EAAcA,EAAyB,UAAI,GAAK,YAChDA,EAAcA,EAAuB,QAAI,GAAK,UAC9CA,EAAcA,EAAoB,KAAI,GAAK,OAC3CA,EAAcA,EAAqB,MAAI,GAAK,QAC5CA,EAAcA,EAAqB,MAAI,GAAK,OAC/C,CARD,CAQGA,IAAkBA,EAAgB,CAAC,G;;;ACP/B,SAASE,cAAc/f,GAC1B,OAAOA,EAAIxH,eAAe,gBAC9B,CACA,IAgBIwnB,EAAe,SAAU9gB,GAEzB,SAAS8gB,YAAYjjB,GACjB,IAnB6BiD,EAC7B5H,EAkBI8X,EAAgBnT,EAAGmT,cAAeD,EAAelT,EAAGkT,aAAcgQ,EAAeljB,EAAGkjB,aAAcC,EAAYnjB,EAAGmjB,UACjHjmB,EAAQiF,EAAO/D,KAAKhF,KAAM8pB,IAAiB9pB;AAM/C,OALA8D,EAAMiW,cAAgBA,GAAiB,GACvCjW,EAAMgW,aAAeA,GAAgB,KACrChW,EAAM7B,QAAU6nB,IAvBajgB,EAuBwB/F,EAtBrD7B,EAAU,IACV,QAAgB4H,EAAIkQ,gBACpBlQ,EAAIkQ,cAAcnU,SAAQ,SAAUokB,GAChC,IAAIF,EAAeE,EACbA,EAAa/nB,QACb;AACNA,GAAW6nB,EAAe,IAC9B,IAEAjgB,EAAIiQ,eACJ7X,GAAW4H,EAAIiQ,aAAa7X,QAAU,MAE1CA,EAAUA,EAAQiF,QAAQ,MAAO,KAW7BpD,EAAMimB,UAAYA,EAClBjmB,EAAMmmB,UAAYJ,YAAY3pB,UACvB4D,CACX,CACA,OAXA,QAAU+lB,YAAa9gB,GAWhB8gB,WACX,CAbkB,CAahBK,M;;;;;;;AC/BK,SAASC,WAAWC,GACvB,OAAO,IAAI,MAAW,SAAUhS,EAAWiS,GACvC,IAAIC,GAAU,QAAOlS,EAAW;AAChC,OAAO,IAAI,MAAW,SAAUoJ,GAC5B,IAAI+I;AAYJ,OAXAxV,QAAQC,QAAQsV,GACX1T,MAAK,SAAU4T,GAAO,OAAOJ,EAAOI,EAAKpS,EAAUqS,aAAe,IAClE7T,KAAKwB,EAAU+R,YACfvT,MAAK,WACN2T,EAASF,EAAQjS,GAAW2G,UAAU,CAClCC,KAAMwC,EAASxC,KAAK0F,KAAKlD,GACzB5L,MAAO4L,EAAS5L,MAAM8O,KAAKlD,GAC3BhW,SAAUgW,EAAShW,SAASkZ,KAAKlD,IAEzC,IACK8H,MAAM9H,EAAS5L,MAAM8O,KAAKlD,IACxB,WACC+I,GACAA,EAAO7I,aACf,CACJ,GACJ,GACJ,C;;;ACrBA,SAASgJ,YAAYC,EAAIN,GACrB,OAAQA,EAAUA,EAAQM,GAAM,SACpC,CACA,SAASC,OAAOC,GACZ,MAA0B,mBAAZA,EAAyB,IAAIC,EAAWD,GAAWA,CACrE,CACA,SAASE,cAAchP,GACnB,OAAOA,EAAKuO,QAAQxiB,QAAU,CAClC,EACiB,SAAUiB,GAEvB,SAASiiB,UAAU/oB,EAAS8Z,GACxB,IAAIjY,EAAQiF,EAAO/D,KAAKhF,KAAMiC,IAAYjC;AAE1C,OADA8D,EAAMiY,KAAOA,EACNjY,CACX,EALA,QAAUknB,UAAWjiB,EAOzB,CARgB,CAQdmhB;AARF,IASIY,EAAc,WACd,SAASA,WAAWR,GACZA,IACAtqB,KAAKsqB,QAAUA,EACvB,CAkEA,OAjEAQ,WAAWG,MAAQ,WACf,OAAO,IAAIH,YAAW,WAAc,OAAO,SAAiB,GAChE,EACAA,WAAW1kB,KAAO,SAAU8kB,GACxB,OAAqB,IAAjBA,EAAMpjB,OACCgjB,WAAWG,QACfC,EAAMpe,IAAI8d,QAAQO,QAAO,SAAUvJ,EAAGwJ,GAAK,OAAOxJ,EAAEyJ,OAAOD,EAAI,GAC1E,EACAN,WAAWQ,MAAQ,SAAUC,EAAMC,EAAMC,GACrC,IAAIC,EAAWd,OAAOY,GAClBG,EAAYf,OAAOa,GAAS,IAAIX,WAAWJ;AAC/C,OAAIK,cAAcW,IAAaX,cAAcY,GAClC,IAAIb,YAAW,SAAU1S,GAC5B,OAAOmT,EAAKnT,GACNsT,EAASpB,QAAQlS,IAAc,UAC/BuT,EAAUrB,QAAQlS,IAAc,SAC1C,IAGO,IAAI0S,YAAW,SAAU1S,EAAWiS,GACvC,OAAOkB,EAAKnT,GACNsT,EAASpB,QAAQlS,EAAWiS,IAAY,UACxCsB,EAAUrB,QAAQlS,EAAWiS,IAAY,SACnD,GAER,EACAS,WAAWtS,QAAU,SAAUuD,EAAM3D,GACjC,OAAQ2D,EAAKuO,SAAQ,QAAgBlS,EAAUtO,SAAS,SAAmB,QAAkBsO,OAAiB,SAClH,EACA0S,WAAWO,OAAS,SAAUhC,EAAOuC,GACjC,IAAIC,EAAYjB,OAAOvB;AACvB,GAAI0B,cAAcc,GAEd,OAAOA;AAEX,IAAIC,EAAWlB,OAAOgB;AACtB,OAAIb,cAAce,GACP,IAAIhB,YAAW,SAAU1S,GAC5B,OAAOyT,EAAUvB,QAAQlS,GAAW,SAAUuS,GAAM,OAAOmB,EAASxB,QAAQK,IAAO,SAAiB,KAAM,SAC9G,IAGO,IAAIG,YAAW,SAAU1S,EAAWiS,GACvC,OAAQwB,EAAUvB,QAAQlS,GAAW,SAAUuS,GAC3C,OAAOmB,EAASxB,QAAQK,EAAIN,IAAY,SAC5C,KAAM,SACV,GAER,EACAS,WAAW5qB,UAAUorB,MAAQ,SAAUC,EAAMC,EAAMC,GAC/C,OAAOzrB,KAAKqrB,OAAOP,WAAWQ,MAAMC,EAAMC,EAAMC,GAAS,IAAIX,WAAWJ,cAC5E,EACAI,WAAW5qB,UAAUmrB,OAAS,SAAUrM,GACpC,OAAO8L,WAAWO,OAAOrrB,KAAMgf,EACnC,EACA8L,WAAW5qB,UAAUoqB,QAAU,SAAUlS,EAAWiS,GAChD,MAA8C,IAAI,KAAe,GACrE,EACAS,WAAW5qB,UAAUuoB,QAAU,SAAU5F,GACrC,MAAMA,CACV,EACAiI,WAAW5qB,UAAU6rB,WAAa,SAAUzG,GAExC,OADAtlB,KAAKyoB,QAAUnD,EACRtlB,IACX,EACO8qB,UACX,CAvEiB,E;SCrBG,Q;SCAD,O;;ICARtS,E,SAAU,S;SCAH,M;;;;;SCAC,O;;;ACEZ,SAASiQ,QAAQuD,GACpB,OAAO,IAAI,MAAW,SAAU5T,EAAWiS,GACvC,OAAO,IAAI,MAAW,SAAU7I,GAC5B,IAAIC,EACAwK,EACAC;AACJ,IACIzK,EAAM4I,EAAQjS,GAAW2G,UAAU,CAC/BC,KAAM,SAAUpd,GACRA,EAAO0Z,SACP4Q,EAAgBF,EAAa,CACzBjS,cAAenY,EAAO0Z,OACtBjI,SAAUzR,EACVwW,UAAWA,EACXiS,QAASA,KAGT4B,EAAaC,EAAcnN,UAAU,CACjCC,KAAMwC,EAASxC,KAAK0F,KAAKlD,GACzB5L,MAAO4L,EAAS5L,MAAM8O,KAAKlD,GAC3BhW,SAAUgW,EAAShW,SAASkZ,KAAKlD,KAK7CA,EAASxC,KAAKpd,EAClB,EACAgU,MAAO,SAAUkE,IACboS,EAAgBF,EAAa,CACzB5T,UAAWA,EACX0B,aAAcA,EACdC,cAAeD,GACXA,EAAalY,QACbkY,EAAalY,OAAO0Z,OACxB+O,QAASA,KAGT4B,EAAaC,EAAcnN,UAAU,CACjCC,KAAMwC,EAASxC,KAAK0F,KAAKlD,GACzB5L,MAAO4L,EAAS5L,MAAM8O,KAAKlD,GAC3BhW,SAAUgW,EAAShW,SAASkZ,KAAKlD,KAIzCA,EAAS5L,MAAMkE,EACnB,EACAtO,SAAU,WACD0gB,GACD1K,EAAShW,SAASkZ,KAAKlD,EAAvBA,EAER,GAER,CACA,MAAOvC,GACH+M,EAAa,CAAElS,aAAcmF,EAAG7G,UAAWA,EAAWiS,QAASA,IAC/D7I,EAAS5L,MAAMqJ,EACnB,CACA,OAAO,WACCwC,GACAA,EAAIC,cACJuK,GACAxK,EAAIC,aACZ,CACJ,GACJ,GACJ,EACiB,SAAU3Y,GAEvB,SAASojB,UAAUH,GACf,IAAIloB,EAAQiF,EAAO/D,KAAKhF,OAASA;AAEjC,OADA8D,EAAMiY,KAAO0M,QAAQuD,GACdloB,CACX,EALA,QAAUqoB,UAAWpjB,GAMrBojB,UAAUjsB,UAAUoqB,QAAU,SAAUlS,EAAWiS,GAC/C,OAAOrqB,KAAK+b,KAAKuO,QAAQlS,EAAWiS,EACxC,CAEJ,CAXgB,CAWd,K;;eC/EE,EAAiBjoB,OAAOlC,UAAUmC;eCA3B+pB,wBAA0B,SAAUC,EAAGrO,GAC9C,IAAIsO;AACJ,IACIA,EAAanhB,KAAKC,UAAUihB,EAChC,CACA,MAAOpN,GACH,IAAIsN,EAAqD,IAAI,KAAe;AAE5E,MADAA,EAAWA,WAAatN,EAClBsN,CACV,CACA,OAAOD,CACX,E,sBCCWE,EAAqB,CAC5BC,KAZqB,CACrBC,cAAc,EACdC,mBAAmB,GAWnBzI,QATiB,CACjB0I,OAAQ,MACR,eAAgB,oBAQhB/rB,QANiB,CACjBgsB,OAAQ,S;ACAL,IAAIC,eAAiB,SAAUC,QACd,IAAhBA,IAA0BA,EAAc,CAAC;AAC7C,IAAInmB,EAAKmmB,EAAY/I,IAAKA,OAAa,IAAPpd,EAAgB,WAAaA,EAAIomB,EAAUD,EAAYjH,MAAO6G,EAAoBI,EAAYJ,kBAAmBM,EAAmBF,EAAYE,iBAAkBC,GAAiB,QAAOH,EAAa,CAAC,MAAO,QAAS,oBAAqB;CCZvP,SAAUC,GAChC,IAAKA,GAA4B,oBAAVlH,MACnB,MAA8C,IAAI,KAAe,GAEzE,CDSIqH,CAAaH,GACRA,IACDA,EAAUlH;AAEd,IAAIsH,EAAa,CACbX,KAAM,CAAEE,kBAAmBA,GAC3B9rB,QAASqsB,EAAeG,aACxBpJ,YAAaiJ,EAAejJ,YAC5BC,QAASgJ,EAAehJ;AAE5B,OAAO,IAAI,MAAW,SAAU9L,GAC5B,IAAIkV,EEzBW,SAAUlV,EAAWmV,GACxC,IACIC,EADUpV,EAAUqS,aACCzG;AACzB,OAAIwJ,IAG4B,mBAAhBD,EACLA,EAAYnV,GAGZmV,GAAe,WAE9B,CFawBE,CAAUrV,EAAW4L,GACjCla,EAAUsO,EAAUqS,aACpBiD,EAAyB,CAAC;AAC9B,GAAI5jB,EAAQuS,gBAAiB,CACzB,IAAIzV,EAAKkD,EAAQuS,gBAAiBsR,EAAS/mB,EAAG2F,KAAMiY,EAAU5d,EAAG4d;AAC7DmJ,IACAD,EAAuB,6BAA+BC,GAEtDnJ,IACAkJ,EAAuB,gCAAkClJ,EAEjE,CACA,IAQIoJ,EARAC,GAAiB,SAAS,QAAS,CAAC,EAAGH,GAAyB5jB,EAAQoa,SACxE4J,EAAgB,CAChBrB,KAAM3iB,EAAQ2iB,KACd5rB,QAASiJ,EAAQujB,aACjBpJ,YAAana,EAAQma,YACrBC,QAAS2J,GAET7kB,ED1B0B,SAAUoP,EAAW2V,GAEvD,IADA,IAAIC,EAAU,GACLzlB,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpCylB,EAAQzlB,EAAK,GAAKC,UAAUD;AAEhC,IAAI1H,GAAU,SAAS,QAAS,CAAC,EAAGktB,EAAeltB,SAAU,CAAEqjB,QAAS6J,EAAe7J,QAASD,YAAa8J,EAAe9J,cACxHwI,EAAOsB,EAAetB,MAAQ,CAAC;AACnCuB,EAAQpoB,SAAQ,SAAUqE,GACtBpJ,GAAU,SAAS,SAAS,QAAS,CAAC,EAAGA,GAAUoJ,EAAOpJ,SAAU,CAAEqjB,SAAS,SAAS,QAAS,CAAC,EAAGrjB,EAAQqjB,SAAUja,EAAOia,WAC1Hja,EAAOga,cACPpjB,EAAQojB,YAAcha,EAAOga,aACjCwI,GAAO,SAAS,QAAS,CAAC,EAAGA,GAAOxiB,EAAOwiB,KAC/C;AACA,IAAIzK,EAAgB5J,EAAU4J,cAAeiM,EAAa7V,EAAU6V,WAAY5sB,EAAY+W,EAAU/W,UAAWD,EAAQgX,EAAUhX,MAC/H8sB,EAAO,CAAElM,cAAeA,EAAe3gB,UAAWA;AAKtD,OAJIorB,EAAKE,oBACLuB,EAAKD,WAAaA,GAClBxB,EAAKC,eACLwB,EAAK9sB,OAAQ,OAAMA,IAChB,CACHP,QAASA,EACTqtB,KAAMA,EAEd,CCGiBC,CAAyB/V,EAAWoU,EAAoBY,EAAYU,GAAgBjtB,EAAUmI,EAAGnI,QAASqtB,EAAOllB,EAAGklB;AAE7H,IAAKrtB,EAAQutB,OAAQ,CACjB,IAAIpjB,EG/CqB,WACjC,GAA+B,oBAApBqjB,gBACP,MAAO,CAAET,YAAY,EAAOQ,QAAQ;AACxC,IAAIR,EAAa,IAAIS;AAErB,MAAO,CAAET,WAAYA,EAAYQ,OADpBR,EAAWQ,OAE5B,CHyCqBE,GAA2BC,EAAcvjB,EAAG4iB,WAAYQ,EAASpjB,EAAGojB,QAC7ER,EAAaW,KAET1tB,EAAQutB,OAASA,EACzB,CAQA,GAJInB,IACC7U,EAAUhX,MAAMotB,YAAY7W,MAJN,SAAU/O,GACjC,MAAkB,wBAAXA,EAAEiP,MAAkD,aAAhBjP,EAAEwP,SACjD,MAGIvX,EAAQgsB,OAAS,OAEE,QAAnBhsB,EAAQgsB,OAAkB,CAC1B,IAAI3Q,EI3DT,SAASuS,iBAAiBnB,EAAWY,GACxC,IAAIQ,EAAc,GACdC,cAAgB,SAAUC,EAAKlsB,GAC/BgsB,EAAY1iB,KAAK4iB,EAAM,IAAMC,mBAAmBnsB,GACpD;AAOA,GANI,UAAWwrB,GACXS,cAAc,QAAST,EAAK9sB,OAE5B8sB,EAAKlM,eACL2M,cAAc,gBAAiBT,EAAKlM,eAEpCkM,EAAK7sB,UAAW,CAChB,IAAIytB,OAAsB;AAC1B,IACIA,EAAsB1C,wBAAwB8B,EAAK7sB,UACvD,CACA,MAAOkrB,GACH,MAAO,CAAEA,WAAYA,EACzB,CACAoC,cAAc,YAAaG,EAC/B,CACA,GAAIZ,EAAKD,WAAY,CACjB,IAAIc,OAAuB;AAC3B,IACIA,EAAuB3C,wBAAwB8B,EAAKD,WACxD,CACA,MAAO1B,GACH,MAAO,CAAEA,WAAYA,EACzB,CACAoC,cAAc,aAAcI,EAChC,CACA,IAAIxtB,EAAW,GAAIytB,EAAc1B,EAC7B2B,EAAgB3B,EAAU1f,QAAQ,MACf,IAAnBqhB,IACA1tB,EAAW+rB,EAAU4B,OAAOD,GAC5BD,EAAc1B,EAAU4B,OAAO,EAAGD;AAEtC,IAAIE,GAAkD,IAA9BH,EAAYphB,QAAQ,KAAc,IAAM;AAEhE,MAAO,CAAEwhB,OADIJ,EAAcG,EAAoBT,EAAYW,KAAK,KAAO9tB,EAE3E,CJmBqBktB,CAAiBnB,EAAWY,GAAOkB,EAASlT,EAAGkT,OAAQ7C,EAAarQ,EAAGqQ;AAChF,GAAIA,EACA,OAAO,QAAUA;AAErBe,EAAY8B,CAChB,MAEI,IACIvuB,EAAQqtB,KAAO9B,wBAAwB8B,EAC3C,CACA,MAAO3B,GACH,OAAO,QAAUA,EACrB,CAEJ,OAAO,IAAI,MAAW,SAAU/K,GAoB5B,OAnBAwL,EAAQM,EAAWzsB,GACd+V,MAAK,SAAUvD,GAEhB,OADA+E,EAAU+R,WAAW,CAAE9W,SAAUA,IAC1BA,CACX,IACKuD,KH9EV,SAAS0Y,0BAA0BC,GACtC,OAAO,SAAUlc,GAAY,OAAOA,EAC/Bmc,OACA5Y,MAAK,SAAU6Y,GAChB,IACI,OAAOtkB,KAAKukB,MAAMD,EACtB,CACA,MAAO5lB,GACH,IAAI0iB,EAAa1iB;AAKjB,MAJA0iB,EAAWhgB,KAAO,mBAClBggB,EAAWlZ,SAAWA,EACtBkZ,EAAWoD,WAAatc,EAASuc,OACjCrD,EAAWkD,SAAWA,EAChBlD,CACV,CACJ,IACK3V,MAAK,SAAUhV,GAWhB,OAVIyR,EAASuc,QAAU,MACnB,QAAiBvc,EAAUzR,EAAQ,iDAAmDyR,EAASuc,QAE9FjtB,MAAMC,QAAQhB,IACd,EAAeoD,KAAKpD,EAAQ,SAC5B,EAAeoD,KAAKpD,EAAQ,YAC7B,QAAiByR,EAAUzR,EAAQ,2CAA6Ce,MAAMC,QAAQ2sB,GACxFA,EAAWziB,KAAI,SAAU6d,GAAM,OAAOA,EAAG3I,aAAe,IACxDuN,EAAWvN,eAAiB,MAE/BpgB,CACX,GAAI,CACR,CGiDsB0tB,CAA0BlX,IAC/BxB,MAAK,SAAUhV,GAGhB,OAFA4f,EAASxC,KAAKpd,GACd4f,EAAShW,WACF5J,CACX,IACK0nB,OAAM,SAAUzf,GACA,eAAbA,EAAI0C,OAEJ1C,EAAIjI,QAAUiI,EAAIjI,OAAO0Z,QAAUzR,EAAIjI,OAAOC,MAC9C2f,EAASxC,KAAKnV,EAAIjI,QAEtB4f,EAAS5L,MAAM/L,GACnB,IACO,WACC+jB,GACAA,EAAWiC,OACnB,CACJ,GACJ,GACJ,EKjGIC,EAAY,SAAU/mB,GAEtB,SAAS+mB,SAASjvB,QACE,IAAZA,IAAsBA,EAAU,CAAC;AACrC,IAAIiD,EAAQiF,EAAO/D,KAAKhF,KAAM8sB,eAAejsB,GAASypB,UAAYtqB;AAElE,OADA8D,EAAMjD,QAAUA,EACTiD,CACX,CACA,OAPA,QAAUgsB,SAAU/mB,GAOb+mB,QACX,CATe,CASb,K;;;ACPF,IAAIC,EAAsB,WACtB,SAASA,mBAAmB3X,EAAW0T,EAAUkE,EAAUC,GACvD,IAAInsB,EAAQ9D;AACZA,KAAKoY,UAAYA,EACjBpY,KAAK8rB,SAAWA,EAChB9rB,KAAKgwB,SAAWA,EAChBhwB,KAAKiwB,QAAUA,EACfjwB,KAAKkwB,WAAa,EAClBlwB,KAAKoI,OAAS,GACdpI,KAAKwL,UAAW,EAChBxL,KAAKmwB,UAAW,EAChBnwB,KAAK4mB,UAAY,GACjB5mB,KAAKowB,oBAAsB,KAC3BpwB,KAAKqwB,OAAS,SAAU3tB,GACpBoB,EAAMsE,OAAO4D,KAAKtJ;AAClB,IAAK,IAAI6F,EAAK,EAAG3B,EAAK9C,EAAM8iB,UAAWre,EAAK3B,EAAGkB,OAAQS,IAAM,CACzD,IAAIiZ,EAAW5a,EAAG2B;AACbiZ,GAELA,EAASxC,KAAKtc,EAClB,CACJ,EACA1C,KAAKswB,WAAa,WACdxsB,EAAM0H,UAAW;AACjB,IAAK,IAAIjD,EAAK,EAAG3B,EAAK9C,EAAM8iB,UAAWre,EAAK3B,EAAGkB,OAAQS,IAAM,CACzD,IAAIiZ,EAAW5a,EAAG2B;AACbiZ,GAELA,EAAShW,UACb,CACJ,EACAxL,KAAKyoB,QAAU,SAAU7S,GAAS,OAAO,QAAU9R,OAAO,OAAQ,GAAQ,WACtE,IAAiByE,EAAI3B,EAAI4a;AACzB,OAAO,QAAYxhB,MAAM,SAAUgJ,GAC/B,OAAQA,EAAGgV,OACP,KAAK,EAED,OADAhe,KAAKkwB,YAAc,EACZ,CAAC,EAAGlwB,KAAKiwB,QAAQjwB,KAAKkwB,WAAYlwB,KAAKoY,UAAWxC;AAC7D,KAAK,EAED,GADc5M,EAAGqV,OAGb,OADAre,KAAKuwB,cAAcvwB,KAAKgwB,SAAShwB,KAAKkwB,WAAYlwB,KAAKoY,UAAWxC,IAC3D,CAAC;AAGZ,IADA5V,KAAK4V,MAAQA,EACRrN,EAAK,EAAG3B,EAAK5G,KAAK4mB,UAAWre,EAAK3B,EAAGkB,OAAQS,KAC9CiZ,EAAW5a,EAAG2B,KAGdiZ,EAAS5L,MAAMA;AAEnB,MAAO,CAAC,GAEpB,GACJ,GAAI,CACR,CA0DA,OAzDAma,mBAAmB7vB,UAAU6e,UAAY,SAAUyC,GAC/C,GAAIxhB,KAAKmwB,SACL,MAAM,IAAIjG,MAAM;AAEpBlqB,KAAK4mB,UAAU5a,KAAKwV;AACpB,IAAK,IAAIjZ,EAAK,EAAG3B,EAAK5G,KAAKoI,OAAQG,EAAK3B,EAAGkB,OAAQS,IAAM,CACrD,IAAI7F,EAAQkE,EAAG2B;AACfiZ,EAASxC,KAAKtc,EAClB,CACI1C,KAAKwL,SACLgW,EAAShW,WAEJxL,KAAK4V,OACV4L,EAAS5L,MAAM5V,KAAK4V,MAE5B,EACAma,mBAAmB7vB,UAAUwhB,YAAc,SAAUF,GACjD,IAAIgP,EAAQxwB,KAAK4mB,UAAUhZ,QAAQ4T;AACnC,GAAIgP,EAAQ,EACR,MAAM,IAAItG,MAAM;AAEpBlqB,KAAK4mB,UAAU4J,GAAS,KACpBxwB,KAAK4mB,UAAU6J,OAAM,SAAUC,GAAK,OAAa,OAANA,CAAY,KACvD1wB,KAAKib,QAEb,EACA8U,mBAAmB7vB,UAAUywB,MAAQ,WAC7B3wB,KAAKowB,qBAETpwB,KAAK4wB,KACT,EACAb,mBAAmB7vB,UAAU+a,OAAS,WAC9Bjb,KAAKowB,qBACLpwB,KAAKowB,oBAAoB1O,cAE7B/G,aAAa3a,KAAK6wB,SAClB7wB,KAAK6wB,aAAUlR,EACf3f,KAAKowB,oBAAsB,KAC3BpwB,KAAKmwB,UAAW,CACpB,EACAJ,mBAAmB7vB,UAAU0wB,IAAM,WAC/B5wB,KAAKowB,oBAAsBpwB,KAAK8rB,SAAS9rB,KAAKoY,WAAW2G,UAAU,CAC/DC,KAAMhf,KAAKqwB,OACXza,MAAO5V,KAAKyoB,QACZjd,SAAUxL,KAAKswB,YAEvB,EACAP,mBAAmB7vB,UAAUqwB,cAAgB,SAAUO,GACnD,IAAIhtB,EAAQ9D;AACZ,GAAIA,KAAK6wB,QACL,MAAM,IAAI3G,MAAM;AAEpBlqB,KAAK6wB,QAAUvW,YAAW,WACtBxW,EAAM+sB,aAAUlR,EAChB7b,EAAM8sB,KACV,GAAGE,EACP,EACOf,kBACX,CAlHyB,GAmHrBgB,EAAa,SAAUhoB,GAEvB,SAASgoB,UAAUlwB,GACf,IAAIiD,EAAQiF,EAAO/D,KAAKhF,OAASA,KAC7B4G,EAAK/F,GAAW,CAAC,EAAGmwB,EAAWpqB,EAAGoqB,SAAUF,EAAQlqB,EAAGkqB;AAK3D,OAJAhtB,EAAMksB,SACe,mBAAVc,EAAuBA,EC9HnC,SAASG,mBAAmBC,GAC/B,IAAItqB,EAAKsqB,GAAgB,CAAC,EAAGloB,EAAKpC,EAAGuqB,QAASA,OAAiB,IAAPnoB,EAAgB,IAAMA,EAAIgC,EAAKpE,EAAGwqB,OAAQA,OAAgB,IAAPpmB,GAAuBA,EAAIkR,EAAKtV,EAAGyqB,IAAKA,OAAa,IAAPnV,EAAgBoV,IAAWpV,EAChLqV,EAAYH,EAASD,EAAUA,EAAU;AAC7C,OAAO,SAASK,cAAclqB,GAC1B,IAAIwpB,EAAQW,KAAKC,IAAIL,EAAKE,EAAYE,KAAKE,IAAI,EAAGrqB;AAIlD,OAHI8pB,IACAN,EAAQW,KAAKG,SAAWd,GAErBA,CACX,CACJ,CDoHkDG,CAAmBH,GAC7DhtB,EAAMmsB,QACkB,mBAAbe,EAA0BA,EEhItC,SAASa,mBAAmBC,GAC/B,IAAIlrB,EAAKkrB,GAAgB,CAAC,EAAG7B,EAAUrpB,EAAGqpB,QAASjnB,EAAKpC,EAAGyqB,IAAKA,OAAa,IAAProB,EAAgB,EAAIA;AAC1F,OAAO,SAAS+oB,cAAczqB,EAAO8Q,EAAWxC,GAC5C,QAAItO,GAAS+pB,KAENpB,EAAUA,EAAQra,EAAOwC,KAAexC,EACnD,CACJ,CFyHwDic,CAAmBb,GAC5DltB,CACX,CAWA,OApBA,QAAUitB,UAAWhoB,GAUrBgoB,UAAU7wB,UAAUoqB,QAAU,SAAUlS,EAAW0T,GAC/C,IAAIkG,EAAY,IAAIjC,EAAmB3X,EAAW0T,EAAU9rB,KAAKgwB,SAAUhwB,KAAKiwB;AAEhF,OADA+B,EAAUrB,QACH,IAAI,MAAW,SAAUnP,GAE5B,OADAwQ,EAAUjT,UAAUyC,GACb,WACHwQ,EAAUtQ,YAAYF,EAC1B,CACJ,GACJ,EACOuP,SACX,CAtBgB,CAsBd,K;;;AG7IK,SAASkB,UAAUC,GACtB,OAAO,IAAI,MAAW,SAAU1Q,GAC5BA,EAAS5L,MAAMsc,EACnB,GACJ,C;ACLO,IAAIC,iBAAmB,SAAU9e,EAAUzR,EAAQK,GACtD,IAAI2T,EAAQ,IAAIsU,MAAMjoB;AAKtB,MAJA2T,EAAMrJ,KAAO,cACbqJ,EAAMvC,SAAWA,EACjBuC,EAAM+Z,WAAatc,EAASuc,OAC5Bha,EAAMhU,OAASA,EACTgU,CACV;ACNO,SAASwc,kBAAkBha,GAQ9B,IAPA,IAAIia,EAAmB,CACnB,QACA,gBACA,YACA,aACA,WAEK9pB,EAAK,EAAG3B,EAAKxE,OAAOuD,KAAKyS,GAAY7P,EAAK3B,EAAGkB,OAAQS,IAAM,CAChE,IAAIqmB,EAAMhoB,EAAG2B;AACb,GAAI8pB,EAAiBzkB,QAAQghB,GAAO,EAChC,MAA8C,IAAI,KAAe,GAEzE,CACA,OAAOxW,CACX,C;ACfO,SAASka,gBAAgBC,EAAUna,GACtC,IAAItO,GAAU,QAAS,CAAC,EAAGyoB;AAkB3B,OARAnwB,OAAO+kB,eAAe/O,EAAW,aAAc,CAC3CgP,YAAY,EACZ1kB,MAXa,SAAUsc,GAEnBlV,EADgB,mBAATkV,GACG,SAAS,QAAS,CAAC,EAAGlV,GAAUkV,EAAKlV,KAGrC,SAAS,QAAS,CAAC,EAAGA,GAAUkV,EAElD,IAMA5c,OAAO+kB,eAAe/O,EAAW,aAAc,CAC3CgP,YAAY,EACZ1kB,MAPa,WAAc,OAAQ,QAAS,CAAC,EAAGoH,EAAW,IASxDsO,CACX,CCpBO,SAASoa,mBAAmBpa,GAC/B,IAAIqa,EAAuB,CACvBpxB,UAAW+W,EAAU/W,WAAa,CAAC,EACnC4sB,WAAY7V,EAAU6V,YAAc,CAAC,EACrCjM,cAAe5J,EAAU4J,cACzB5gB,MAAOgX,EAAUhX;AAQrB,OANKqxB,EAAqBzQ,gBACtByQ,EAAqBzQ,cACqB,iBAA/ByQ,EAAqBrxB,OACtB,QAAiBqxB,EAAqBrxB,aAAUue,EAChD,IAEP8S,CACX,C;;ACCA,IAAIC,cAAgB,SAAS9pB,EAAG+pB,GAI5B,OAHAD,cAAgBtwB,OAAOwwB,gBAClB,CAAE3I,UAAW,cAAgBtnB,OAAS,SAAUiG,EAAG+pB,GAAK/pB,EAAEqhB,UAAY0I,CAAG,GAC1E,SAAU/pB,EAAG+pB,GAAK,IAAK,IAAItG,KAAKsG,EAAOA,EAAEtwB,eAAegqB,KAAIzjB,EAAEyjB,GAAKsG,EAAEtG,GAAI,EACtEqG,cAAc9pB,EAAG+pB,EAC5B;AAEO,SAASE,UAAUjqB,EAAG+pB,GAEzB,SAASG,KAAO9yB,KAAK+yB,YAAcnqB,CAAG,CADtC8pB,cAAc9pB,EAAG+pB,GAEjB/pB,EAAE1I,UAAkB,OAANyyB,EAAavwB,OAAOqB,OAAOkvB,IAAMG,GAAG5yB,UAAYyyB,EAAEzyB,UAAW,IAAI4yB,GACnF,CAEO,IAAIE,SAAW,WAQlB,OAPAA,SAAW5wB,OAAOyX,QAAU,SAASmZ,SAASC,GAC1C,IAAK,IAAIzf,EAAG3G,EAAI,EAAGqmB,EAAI1qB,UAAUV,OAAQ+E,EAAIqmB,EAAGrmB,IAE5C,IAAK,IAAIwf,KADT7Y,EAAIhL,UAAUqE,GACOzK,OAAOlC,UAAUmC,eAAe2C,KAAKwO,EAAG6Y,KAAI4G,EAAE5G,GAAK7Y,EAAE6Y;AAE9E,OAAO4G,CACX,EACOD,SAAS/mB,MAAMjM,KAAMwI,UAChC;AAEO,SAAS2qB,OAAO3f,EAAGyL,GACtB,IAAIgU,EAAI,CAAC;AACT,IAAK,IAAI5G,KAAK7Y,EAAOpR,OAAOlC,UAAUmC,eAAe2C,KAAKwO,EAAG6Y,IAAMpN,EAAErR,QAAQye,GAAK,IAC9E4G,EAAE5G,GAAK7Y,EAAE6Y;AACb,GAAS,MAAL7Y,GAAqD,mBAAjCpR,OAAOgxB,sBACtB,KAAIvmB,EAAI;AAAb,IAAgBwf,EAAIjqB,OAAOgxB,sBAAsB5f,GAAI3G,EAAIwf,EAAEvkB,OAAQ+E,IAC3DoS,EAAErR,QAAQye,EAAExf,IAAM,GAAKzK,OAAOlC,UAAUmzB,qBAAqBruB,KAAKwO,EAAG6Y,EAAExf,MACvEomB,EAAE5G,EAAExf,IAAM2G,EAAE6Y,EAAExf,IAF4B,CAItD,OAAOomB,CACX,CAiBO,SAASK,UAAUC,EAASC,EAAYC,EAAGC,GAE9C,OAAO,IAAKD,IAAMA,EAAI1e,WAAU,SAAUC,EAAS4J,GAC/C,SAAS+U,UAAUjxB,GAAS,IAAMkxB,KAAKF,EAAU1U,KAAKtc,GAAS,CAAE,MAAOuc,GAAKL,EAAOK,EAAI,CAAE,CAC1F,SAAS4U,SAASnxB,GAAS,IAAMkxB,KAAKF,EAAiB,MAAEhxB,GAAS,CAAE,MAAOuc,GAAKL,EAAOK,EAAI,CAAE,CAC7F,SAAS2U,KAAKhyB,GAAUA,EAAOkyB,KAAO9e,EAAQpT,EAAOc,OAJzD,SAASqxB,MAAMrxB,GAAS,OAAOA,aAAiB+wB,EAAI/wB,EAAQ,IAAI+wB,GAAE,SAAUze,GAAWA,EAAQtS,EAAQ,GAAI,CAIzCqxB,CAAMnyB,EAAOc,OAAOkU,KAAK+c,UAAWE,SAAW,CAC7GD,MAAMF,EAAYA,EAAUznB,MAAMsnB,EAASC,GAAc,KAAKxU,OAClE,GACJ,CAEO,SAASgV,YAAYT,EAASrF,GACjC,IAAsG+F,EAAG7I,EAAG6H,EAAGiB,EAA3G7kB,EAAI,CAAE2O,MAAO,EAAGK,KAAM,WAAa,GAAW,EAAP4U,EAAE,GAAQ,MAAMA,EAAE;AAAI,OAAOA,EAAE,EAAI,EAAGkB,KAAM,GAAIC,IAAK;AAChG,OAAOF,EAAI,CAAElV,KAAMqV,KAAK,GAAI,MAASA,KAAK,GAAI,OAAUA,KAAK,IAAwB,mBAAXC,SAA0BJ,EAAEI,OAAOC,UAAY,WAAa,OAAOv0B,IAAM,GAAIk0B;AACvJ,SAASG,KAAKnB,GAAK,OAAO,SAAUsB,GAAK,OACzC,SAASZ,KAAKjJ,GACV,GAAIsJ,EAAG,MAAM,IAAIQ,UAAU;AAC3B,KAAOplB,OACH,GAAI4kB,EAAI,EAAG7I,IAAM6H,EAAY,EAARtI,EAAG,GAASS,EAAU,OAAIT,EAAG,GAAKS,EAAS,SAAO6H,EAAI7H,EAAU,SAAM6H,EAAEjuB,KAAKomB,GAAI,GAAKA,EAAEpM,SAAWiU,EAAIA,EAAEjuB,KAAKomB,EAAGT,EAAG,KAAKmJ,KAAM,OAAOb;AAE3J,OADI7H,EAAI,EAAG6H,IAAGtI,EAAK,CAAS,EAARA,EAAG,GAAQsI,EAAEvwB,QACzBioB,EAAG,IACP,KAAK,EAAG,KAAK,EAAGsI,EAAItI;AAAI;AACxB,KAAK,EAAc,OAAXtb,EAAE2O,QAAgB,CAAEtb,MAAOioB,EAAG,GAAImJ,MAAM;AAChD,KAAK,EAAGzkB,EAAE2O,QAASoN,EAAIT,EAAG,GAAIA,EAAK,CAAC;AAAI;AACxC,KAAK,EAAGA,EAAKtb,EAAE+kB,IAAI3nB,MAAO4C,EAAE8kB,KAAK1nB;AAAO;AACxC,QACI,KAAMwmB,EAAI5jB,EAAE8kB,MAAMlB,EAAIA,EAAEnrB,OAAS,GAAKmrB,EAAEA,EAAEnrB,OAAS,KAAkB,IAAV6iB,EAAG,IAAsB,IAAVA,EAAG,IAAW,CAAEtb,EAAI;AAAG,QAAU,CAC3G,GAAc,IAAVsb,EAAG,MAAcsI,GAAMtI,EAAG,GAAKsI,EAAE,IAAMtI,EAAG,GAAKsI,EAAE,IAAM,CAAE5jB,EAAE2O,MAAQ2M,EAAG;AAAI,KAAO,CACrF,GAAc,IAAVA,EAAG,IAAYtb,EAAE2O,MAAQiV,EAAE,GAAI,CAAE5jB,EAAE2O,MAAQiV,EAAE,GAAIA,EAAItI;AAAI,KAAO,CACpE,GAAIsI,GAAK5jB,EAAE2O,MAAQiV,EAAE,GAAI,CAAE5jB,EAAE2O,MAAQiV,EAAE,GAAI5jB,EAAE+kB,IAAIpoB,KAAK2e;AAAK,KAAO,CAC9DsI,EAAE,IAAI5jB,EAAE+kB,IAAI3nB,MAChB4C,EAAE8kB,KAAK1nB;AAAO,SAEtBke,EAAKuD,EAAKlpB,KAAKuuB,EAASlkB,EAC5B,CAAE,MAAO4P,GAAK0L,EAAK,CAAC,EAAG1L,GAAImM,EAAI,CAAG,CAAE,QAAU6I,EAAIhB,EAAI,CAAG,CACzD,GAAY,EAARtI,EAAG,GAAQ,MAAMA,EAAG;AAAI,MAAO,CAAEjoB,MAAOioB,EAAG,GAAKA,EAAG,QAAK,EAAQmJ,MAAM,EAC9E,CAtBgDF,CAAK,CAACV,EAAGsB,GAAK,CAAG,CAuBrE,CA8CO,SAASE,iBACZ,IAAK,IAAIlhB,EAAI,EAAG3G,EAAI,EAAG8nB,EAAKnsB,UAAUV,OAAQ+E,EAAI8nB,EAAI9nB,IAAK2G,GAAKhL,UAAUqE,GAAG/E;AACxE,IAAI8sB,EAAIjyB,MAAM6Q,GAAIqhB,EAAI;AAA3B,IAA8BhoB,EAAI,EAAGA,EAAI8nB,EAAI9nB,IACzC,IAAK,IAAIioB,EAAItsB,UAAUqE,GAAIkoB,EAAI,EAAGC,EAAKF,EAAEhtB,OAAQitB,EAAIC,EAAID,IAAKF,IAC1DD,EAAEC,GAAKC,EAAEC;AACjB,OAAOH,CACX,C;;yBC1JIK,EAAkC,mBAAXX,QAAyBA,OAAOY,IACvDZ,OAAOY,IAAI,sBACX;AASG,SAAS,iCAIZ,OAHK,EAAMD,IATR,SAASE,qBACZ/yB,OAAO+kB,eAAe,EAAO8N,EAAe,CACxCvyB,MAAO,gBAAoB,CAAC,GAC5B0kB,YAAY,EACZC,cAAc,EACd+N,UAAU,GAElB,CAGQD,GAEG,EAAMF,EACjB,CCdO,ICAII,eAAiB,SAAUzuB,GAClC,IAAIoP,EAASpP,EAAGoP,OAAQsf,EAAW1uB,EAAG0uB,SAClCC,EAAgB;AACpB,OAAO,gBAAoBA,EAAcC,SAAU,MAAM,SAAU1rB,GAO/D,YANgB,IAAZA,IAAsBA,EAAU,CAAC,GACjCkM,GAAUlM,EAAQkM,SAAWA,IAC7BlM,EAAU1H,OAAOyX,OAAO,CAAC,EAAG/P,EAAS,CAAEkM,OAAQA,MAEX,QAAUlM,EAAQkM,OAAQ,IAE1D,gBAAoBuf,EAAcE,SAAU,CAAE/yB,MAAOoH,GAAWwrB,EAC5E,GACJ;ACZO,SAASI,kBACZ,IAAI1f,EAAS,aAAiB,kCAAoBA;AAGlD,OAFwC,QAAUA,EAAQ,IAEnDA,CACX,C,ICPW2f,E;CACX,SAAWA,GACPA,EAAaA,EAAoB,MAAI,GAAK,QAC1CA,EAAaA,EAAuB,SAAI,GAAK,WAC7CA,EAAaA,EAA2B,aAAI,GAAK,cACpD,CAJD,CAIGA,IAAiBA,EAAe,CAAC;AACpC,IAAI1qB,EAAQ,IAAI8I;AACT,SAASiO,cAAc4T,GAC1B,IAAIrpB;AACJ,OAAQqpB,GACJ,KAAKD,EAAaE,MACdtpB,EAAO;AACP;AACJ,KAAKopB,EAAaG,SACdvpB,EAAO;AACP;AACJ,KAAKopB,EAAaI,aACdxpB,EAAO,eAGf,OAAOA,CACX,CCnBA,IAAIypB,EAAiB,WACjB,SAASA,cAAcn1B,EAASiJ,GAC5B9J,KAAKi2B,WAAY,EACjBj2B,KAAKk2B,gBAAkB,CAAC,EACxBl2B,KAAK8J,QAAU,CAAC,EAChB9J,KAAKa,QAAU,CAAC,EAChBb,KAAKa,QAAUA,GAAW,CAAC,EAC3Bb,KAAK8J,QAAUA,GAAW,CAAC,CAC/B,CAsCA,OArCAksB,cAAc91B,UAAUi2B,WAAa,WACjC,OAAOn2B,KAAKa,OAChB,EACAm1B,cAAc91B,UAAUwoB,WAAa,SAAU1C,EAAYoQ,QACjC,IAAlBA,IAA4BA,GAAgB,GAC5CA,KAAkB,OAAMp2B,KAAKa,QAASmlB,KACtChmB,KAAKk2B,gBAAkBl2B,KAAKa,SAEhCb,KAAKa,QAAUmlB,CACnB,EACAgQ,cAAc91B,UAAUm2B,QAAU,WAC9Br2B,KAAKi2B,WAAY,CACrB,EACAD,cAAc91B,UAAUo2B,cAAgB,WACpC,IAAItgB,EAAUhW,KAAKa,SAAWb,KAAKa,QAAQmV,QACtChW,KAAK8J,SAAW9J,KAAK8J,QAAQkM,QACM,UAAYA,EAAQ;AAG5D,IAAIugB,GAAQ;AAMZ,OALIvgB,IAAWhW,KAAKgW,SAChBugB,GAAQ,EACRv2B,KAAKgW,OAASA,EACdhW,KAAKqiB,WAEF,CACHrM,OAAQhW,KAAKgW,OACbugB,MAAOA,EAEf,EACAP,cAAc91B,UAAUs2B,mBAAqB,SAAUh2B,EAAUo1B,GAC7D,IAAIxd,EDpBL,SAASqe,OAAOj2B,GACnB,IAGIa,EAAWu0B,EAHXc,EAASzrB,EAAM9G,IAAI3D;AACvB,GAAIk2B,EACA,OAAOA,GAE6B,UAAYl2B,KAAcA,EAASqX,KAAM;AAGjF,IAAIG,EAAYxX,EAASguB,YAAYnmB,QAAO,SAAUuZ,GAAK,MAAkB,uBAAXA,EAAE/J,IAA+B,IAC/F4E,EAAUjc,EAASguB,YAAYnmB,QAAO,SAAUuZ,GAChD,MAAkB,wBAAXA,EAAE/J,MAAkD,UAAhB+J,EAAExJ,SACjD,IACI4M,EAAYxkB,EAASguB,YAAYnmB,QAAO,SAAUuZ,GAClD,MAAkB,wBAAXA,EAAE/J,MAAkD,aAAhB+J,EAAExJ,SACjD,IACIqB,EAAgBjZ,EAASguB,YAAYnmB,QAAO,SAAUuZ,GACtD,MAAkB,wBAAXA,EAAE/J,MAAkD,iBAAhB+J,EAAExJ,SACjD,KACwC,SAAWJ,EAAUlQ,QACxD2U,EAAQ3U,QAAUkd,EAAUld,QAAU2R,EAAc3R,OAAS,KAG1B,QAAU2U,EAAQ3U,OAASkd,EAAUld,OAAS2R,EAAc3R,QAAU,EAAG,IAIjH8tB,EAAOnZ,EAAQ3U,OAAS6tB,EAAaE,MAAQF,EAAaG,SACrDrZ,EAAQ3U,QAAWkd,EAAUld,SAC9B8tB,EAAOD,EAAaI;AACxB,IAAIvH,EAAc/R,EAAQ3U,OACpB2U,EACAuI,EAAUld,OACNkd,EACAvL,GAC8B,QAAiC,IAAvB+U,EAAY1mB,OAAc;AAG5E,IAAI6uB,EAAanI,EAAY;AAC7BntB,EAAYs1B,EAAWC,qBAAuB;AAO9C,IAAIvR,EAAU,CAAE9Y,KANZoqB,EAAWpqB,MAAiC,SAAzBoqB,EAAWpqB,KAAKsL,KAC5B8e,EAAWpqB,KAAK7J,MAGhB,OAEiBkzB,KAAMA,EAAMv0B,UAAWA;AAEnD,OADA4J,EAAM0B,IAAInM,EAAU6kB,GACbA,CACX,CC5BwBoR,CAAOj2B;AACKwhB,cAAc4T,GAClB5T,cAAc5J,EAAUwd,OACR,QAAUxd,EAAUwd,OAASA,EAAM,GAE/E,EACOI,aACX,CA/CoB,G,GCAI,SAAUjtB,GAE9B,SAAS8tB,iBAAiBjwB,GACtB,IAAI/F,EAAU+F,EAAG/F,QAASiJ,EAAUlD,EAAGkD,QAASgtB,EAAYlwB,EAAGkwB,UAC3DhzB,EAAQiF,EAAO/D,KAAKhF,KAAMa,EAASiJ,IAAY9J;AAInD,OAHA8D,EAAMizB,kBAAoB,CAAC,EAC3BjzB,EAAMgzB,UAAYA,EAClBhzB,EAAMkzB,WAAWn2B,GACViD,CACX,EARA,QAAU+yB,iBAAkB9tB,GAS5B8tB,iBAAiB32B,UAAUsY,QAAU,SAAU5W,GAC3C,IAA+B,IAA3B5B,KAAKm2B,aAAac,KAElB,OADAj3B,KAAKqiB,UACE,CACH1M,SAAS,EACTC,WAAO+J,EACP9d,UAAM8d,EACNte,UAAWrB,KAAKm2B,aAAa90B;AAGrC,IAAI8mB,EAAgBvmB;AAChB5B,KAAKs2B,gBAAgBC,QACrBpO,EAAgBnoB,KAAKk3B;AAEzB,IAAIC,EAAoBn3B,KAAKm2B,aAAagB;AAgB1C,MAfiC,mBAAtBA,IACPA,IAAsBA,EAAkBn3B,KAAKm2B,gBAEvB,IAAtBgB,GACAn3B,KAAKk2B,iBACL9zB,OAAOuD,KAAK3F,KAAKk2B,iBAAiBpuB,OAAS,IAC1C9H,KAAKk2B,gBAAgB5O,eAAiBtnB,KAAKm2B,aAAa7O,gBACpD,OAAMtnB,KAAKk2B,gBAAgB70B,UAAWrB,KAAKm2B,aAAa90B,YACzDrB,KAAKk2B,gBAAgBe,OAASj3B,KAAKm2B,aAAac,QACpDj3B,KAAKqiB,UACL8F,EAAgBnoB,KAAKk3B,oBAEzBl3B,KAAKg3B,WAAWh3B,KAAKm2B,cACrBn2B,KAAKo3B,oBACLp3B,KAAKk2B,gBAAkBl2B,KAAKm2B,cACrB,SAAS,QAAS,CAAC,EAAGhO,GAAgB,CAAE9mB,UAAWrB,KAAKm2B,aAAa90B,WAChF,EACAw1B,iBAAiB32B,UAAUm3B,aAAe,WACtCr3B,KAAKi2B,WAAY,CACrB,EACAY,iBAAiB32B,UAAUmiB,QAAU,WACjCriB,KAAKs3B,yBACEt3B,KAAK+2B,kBAAkB31B,KAClC,EACAy1B,iBAAiB32B,UAAU82B,WAAa,SAAUn2B,GAC1Cb,KAAK+2B,kBAAkB31B,QAAoC,IAA3BpB,KAAKm2B,aAAac,OAEtDj3B,KAAK+2B,kBAAkB31B,MAAQpB,KAAKs2B,gBAAgBtgB,OAAO+I,UAAU,CACjE3d,MAAOP,EAAQymB,aACfjmB,UAAWR,EAAQQ,UACnB0Z,YAAala,EAAQka,cAE7B,EACA8b,iBAAiB32B,UAAUk3B,kBAAoB,WACvCp3B,KAAK+2B,kBAAkBzP,eAE3BtnB,KAAK+2B,kBAAkBzP,aAAetnB,KAAK+2B,kBAAkB31B,MAAM2d,UAAU,CACzEC,KAAMhf,KAAKu3B,kBAAkB7S,KAAK1kB,MAClC4V,MAAO5V,KAAKw3B,YAAY9S,KAAK1kB,MAC7BwL,SAAUxL,KAAKy3B,qBAAqB/S,KAAK1kB,QAEjD,EACA62B,iBAAiB32B,UAAUg3B,iBAAmB,WAC1C,MAAO,CACHvhB,SAAS,EACTC,WAAO+J,EACP9d,UAAM8d,EAEd,EACAkX,iBAAiB32B,UAAUw3B,aAAe,SAAU91B,GAC5C5B,KAAKi2B,WACLj2B,KAAK82B,UAAUl1B,EAEvB,EACAi1B,iBAAiB32B,UAAUq3B,kBAAoB,SAAU31B,GACrD,IAAI+1B,EAAqB33B,KAAKm2B,aAAawB;AAC3C33B,KAAK03B,aAAa,CACd71B,KAAMD,EAAOC,KACb8T,SAAS,EACTC,WAAO+J,IAEPgY,GACAA,EAAmB,CACf3hB,OAAQhW,KAAKs2B,gBAAgBtgB,OAC7BwS,iBAAkB5mB,GAG9B,EACAi1B,iBAAiB32B,UAAUs3B,YAAc,SAAU5hB,GAC/C5V,KAAK03B,aAAa,CACd9hB,MAAOA,EACPD,SAAS,GAEjB,EACAkhB,iBAAiB32B,UAAUu3B,qBAAuB,WAC9C,IAAIG,EAAyB53B,KAAKm2B,aAAayB;AAC3CA,GACAA,IACJ53B,KAAKs3B,iBACT,EACAT,iBAAiB32B,UAAUo3B,gBAAkB,WACrCt3B,KAAK+2B,kBAAkBzP,eACvBtnB,KAAK+2B,kBAAkBzP,aAAa5F,qBAC7B1hB,KAAK+2B,kBAAkBzP,aAEtC,CAEJ,CAhHuB,CAgHrB0O,G,qBC7GE6B,EAAgB,SAAU9uB,GAE1B,SAAS8uB,aAAajxB,GAClB,IAAI/F,EAAU+F,EAAG/F,QAASiJ,EAAUlD,EAAGkD,QAASlI,EAASgF,EAAGhF,OAAQk1B,EAAYlwB,EAAGkwB,UAC/EhzB,EAAQiF,EAAO/D,KAAKhF,KAAMa,EAASiJ,IAAY9J;AAoBnD,OAnBA8D,EAAMg0B,YAAc,SAAUC,QACM,IAA5BA,IAAsCA,EAA0B,CAAC,GACrEj0B,EAAMk0B;AACN,IAAIxiB,EAAa1R,EAAMm0B;AACvB,OAAOn0B,EAAMsZ,OAAO2a,GACfnhB,MAAK,SAAUvD,GAEhB,OADAvP,EAAMo0B,oBAAoB7kB,EAAUmC,GAC7BnC,CACX,IACKiW,OAAM,SAAU1T,GAEjB,GADA9R,EAAMq0B,gBAAgBviB,EAAOJ,IACxB1R,EAAMqyB,aAAa1N,QACpB,MAAM7S,CACd,GACJ,EACA9R,EAAM0yB,mBAAmB31B,EAAQ6U,SAAUigB,EAAaG,UACxDhyB,EAAMlC,OAASA,EACfkC,EAAMgzB,UAAYA,EAClBhzB,EAAMs0B,qBAAuB,EACtBt0B,CACX,CA0EA,OAlGA,QAAU+zB,aAAc9uB,GAyBxB8uB,aAAa33B,UAAUsY,QAAU,SAAU5W,GAGvC,OAFA5B,KAAKi2B,WAAY,EACjBj2B,KAAKw2B,mBAAmBx2B,KAAKm2B,aAAazgB,SAAUigB,EAAaG,UAC1D,CACH91B,KAAK83B,aACL,SAAS,QAAS,CAAC,EAAGl2B,GAAS,CAAEoU,OAAQhW,KAAKs2B,gBAAgBtgB,SAEtE,EACA6hB,aAAa33B,UAAUm3B,aAAe,WAElC,OADAr3B,KAAKi2B,WAAY,EACVj2B,KAAKq2B,QAAQ3R,KAAK1kB,KAC7B,EACA63B,aAAa33B,UAAUmiB,QAAU,WACjC,EACAwV,aAAa33B,UAAUkd,OAAS,SAAU2a,GACtC,OAAO/3B,KAAKs2B,gBAAgBtgB,OAAOoH,QAAO,QAAQpd,KAAKm2B,aAAc4B,GACzE,EACAF,aAAa33B,UAAU83B,gBAAkB,WAChCh4B,KAAK4B,OAAO+T,SAAY3V,KAAKm2B,aAAakC,eAC3Cr4B,KAAK03B,aAAa,CACd/hB,SAAS,EACTC,WAAO+J,EACP9d,UAAM8d,EACN2Y,QAAQ,GAGpB,EACAT,aAAa33B,UAAUg4B,oBAAsB,SAAU7kB,EAAUmC,GAC7D,IAAI5O,EAAK5G,KAAKm2B,aAAcoC,EAAc3xB,EAAG2xB,YAAaF,EAAgBzxB,EAAGyxB,cACzEx2B,EAAOwR,EAASxR,KAAMyZ,EAASjI,EAASiI,OACxC1F,EAAQ0F,GAAUA,EAAOxT,OAAS,EAChC,IAAI,IAAY,CAAEiS,cAAeuB,SACjCqE;AAIF3f,KAAKw4B,qBAAqBhjB,KAAgB6iB,GAC1Cr4B,KAAK03B,aAAa,CACdY,QAAQ,EACR3iB,SAAS,EACT9T,KAAMA,EACN+T,MAAOA,IAPJ2iB,GAAcA,EAAY12B,EAWzC,EACAg2B,aAAa33B,UAAUi4B,gBAAkB,SAAUviB,EAAOJ,GACtD,IAAIiT,EAAUzoB,KAAKm2B,aAAa1N;AAC5BzoB,KAAKw4B,qBAAqBhjB,IAC1BxV,KAAK03B,aAAa,CACd/hB,SAAS,EACTC,MAAOA,EACP/T,UAAM8d,EACN2Y,QAAQ,IAGZ7P,GACAA,EAAQ7S,EAEhB,EACAiiB,aAAa33B,UAAU+3B,sBAAwB,WAC3C,QAASj4B,KAAKo4B,oBAClB,EACAP,aAAa33B,UAAUs4B,qBAAuB,SAAUhjB,GACpD,OAAOxV,KAAKo4B,uBAAyB5iB,CACzC,EACAqiB,aAAa33B,UAAUw3B,aAAe,SAAU91B,IACxC5B,KAAKi2B,WACHj2B,KAAK6oB,iBAAmB,OAAM7oB,KAAK6oB,eAAgBjnB,KACrD5B,KAAK82B,UAAUl1B,GACf5B,KAAK6oB,eAAiBjnB,EAE9B,EACOi2B,YACX,CApGmB,CAoGjB7B,G,WCpGEyC,EAAa,SAAU1vB,GAEvB,SAAS0vB,UAAU7xB,GACf,IAAI/F,EAAU+F,EAAG/F,QAASiJ,EAAUlD,EAAGkD,QAAS4uB,EAAY9xB,EAAG8xB,UAC3D50B,EAAQiF,EAAO/D,KAAKhF,KAAMa,EAASiJ,IAAY9J;AAyEnD,OAxEA8D,EAAM60B,aAAe,CAAC,EACtB70B,EAAM80B,SAAU,EAChB90B,EAAM+0B,aAAe,SAAUh4B,GAC3BiD,EAAMue,UACNve,EAAM80B,SAAU,EAChB90B,EAAMg1B,YAAcj4B,EACpBiD,EAAM40B,WACV,EACA50B,EAAMi1B,eAAiB,WACnB,IAAIn3B,EAASkC,EAAMk1B,wBACfn4B,EAAUiD,EAAMqyB;AACpB,GAAIt1B,EAAQo2B,KACRr1B,GAAS,SAAS,QAAS,CAAC,EAAGA,GAAS,CAAEC,UAAM8d,EAAW/J,WAAO+J,EAAWhK,SAAS,EAAO2iB,QAAQ;KAEpG,GAAIx0B,EAAMizB,kBAAmB,CAC9B,IAAI5O,EAAgBrkB,EAAMizB,kBAAkBxP,mBACxC1lB,EAAOsmB,EAActmB,KAAM8T,EAAUwS,EAAcxS,QAASuN,EAAUiF,EAAcjF,QAAStJ,EAAgBuO,EAAcvO,cAAe0B,EAAS6M,EAAc7M,OACjK1F,EAAQuS,EAAcvS;AAQ1B,GAPI0F,GAAUA,EAAOxT,OAAS,IAC1B8N,EAAQ,IAAI,IAAY,CAAEmE,cAAeuB,KAE7C1Z,GAAS,SAAS,QAAS,CAAC,EAAGA,GAAS,CAAEC,KAAMA,EAC5C8T,QAASA,EACTiE,cAAeA,EACfhE,MAAOA,EAAO0iB,QAAQ,IACtB3iB,QAEC,GAAIC,EACLxT,OAAOyX,OAAOjY,EAAQ,CAClBC,MAAOiC,EAAMizB,kBAAkBrP,iBAAmB,CAAC,GAC9C7lB;IAGR,CACD,IAAIkZ,EAAcjX,EAAMizB,kBAAkBl2B,QAAQka;AAElD,GADqBla,EAAQo4B,gBAEzB/V,KACErhB,GAAqC,IAA7BO,OAAOuD,KAAK9D,GAAMiG,SACZ,eAAhBiT,EAMA,OALA3Y,OAAOyX,OAAOjY,EAAQ,CAClB+T,SAAS,EACTiE,cAAe,eAEnBhY,EAAOwd,UACAxd,CAEf,CACJ,CAOA,OANAA,EAAOoU,OAASlS,EAAMkS,OACtBlS,EAAM4kB,WAAW7nB,GAAS,GAC1BiD,EAAM60B,aAAahjB,QACf7R,EAAM60B,aAAa/2B,QAAUkC,EAAM60B,aAAa/2B,OAAO+T,UAAW,EACtE7R,EAAM60B,aAAa/2B,OAASA,EAC5BkC,EAAMizB,mBAAqBjzB,EAAMizB,kBAAkBnP,wBAC5ChmB,CACX,EACAkC,EAAMo1B,WAAa,SAAU73B,GACzB,OAAOyC,EAAMizB,kBAAkB3X,QAAQ/d,EAC3C,EACAyC,EAAMq1B,aAAe,SAAUnR,GAAoB,OAAOlkB,EAAMizB,kBAAkBhP,UAAUC,EAAmB,EAC/GlkB,EAAMs1B,eAAiB,SAAUxQ,GAAS,OAAO9kB,EAAMizB,kBAAkB1O,YAAYO,EAAQ,EAC7F9kB,EAAMu1B,gBAAkB,SAAU9Y,GAC9B,IAAI3Z;AAC+B,QAAlCA,EAAK9C,EAAMizB,yBAAsC,IAAPnwB,GAAyBA,EAAGkiB,aAAavI,EACxF,EACAzc,EAAMw1B,eAAiB,WACnB,IAAI1yB;AAC+B,QAAlCA,EAAK9C,EAAMizB,yBAAsC,IAAPnwB,GAAyBA,EAAGsU,aAC3E,EACApX,EAAMy1B,mBAAqB,SAAU14B,GAAW,OAAOiD,EAAMizB,kBAAkBxO,gBAAgB1nB,EAAU,EACzGiD,EAAM40B,UAAYA,EACX50B,CACX,CA2MA,OAxRA,QAAU20B,UAAW1vB,GA8ErB0vB,UAAUv4B,UAAUsY,QAAU,WAC1BxY,KAAKs2B;AACL,IAAI1vB,EAAK5G,KAAKm2B,aAAcc,EAAOrwB,EAAGqwB,KAAM71B,EAAQwF,EAAGxF;AAQvD,OAPI61B,GAAQ71B,IAAUpB,KAAK24B,aAAav3B,SACpCpB,KAAKw5B,0BACLx5B,KAAK24B,aAAav3B,MAAQA,GAE9BpB,KAAKy5B,wBACDz5B,KAAKi2B,WACLj2B,KAAK05B,yBACF15B,KAAK25B,uBAAyB35B,KAAK45B,kBAC9C,EACAnB,UAAUv4B,UAAU25B,YAAc,WAC9B,OAAQ75B,KAAK44B,QAUP,CAAC54B,KAAK64B,aAAc74B,KAAKwY,WATzB,CACExY,KAAK64B,aACL,CACIljB,SAAS,EACTiE,cAAe,WACf0e,QAAQ,EACRz2B,UAAM8d,GAItB,EACA8Y,UAAUv4B,UAAU45B,UAAY,WAC5B,IAAIh2B,EAAQ9D,KACRa,EAAUb,KAAKm2B;AACnB,OAAIt1B,EAAQo2B,OAAwB,IAAhBp2B,EAAQk5B,KAErB,IAAIhlB,SAAQ,SAAUC,GAAW,OAAOlR,EAAM41B,uBAAuB1kB,EAAU,GAC1F,EACAyjB,UAAUv4B,UAAUm3B,aAAe,SAAUzwB,GACzC,IAAIoC,QAAa,IAAPpC,EAAgB,CAAC,EAAIA,GAAIozB,KAAMA,OAAc,IAAPhxB,GAAwBA;AAMxE,OALAhJ,KAAKi2B,WAAY,EACZ+D,IAAQh6B,KAAK44B,SACd54B,KAAKi6B,yBAETj6B,KAAKk2B,gBAAkBl2B,KAAKm2B,aACrBn2B,KAAKq2B,QAAQ3R,KAAK1kB,KAC7B,EACAy4B,UAAUv4B,UAAUmiB,QAAU,WAC1BriB,KAAKw5B,iCACEx5B,KAAK+2B,yBACL/2B,KAAK24B,aAAa/2B,MAC7B,EACA62B,UAAUv4B,UAAUi2B,WAAa,WAC7B,IAAIt1B,EAAUkI,EAAO7I,UAAUi2B,WAAWnxB,KAAKhF;AAQ/C,OAPIA,KAAK84B,cACLj4B,EAAQQ,WAAY,SAAS,QAAS,CAAC,EAAGR,EAAQQ,WAAYrB,KAAK84B,YAAYz3B,WAC/ER,EAAQiJ,SAAU,SAAS,QAAS,CAAC,EAAGjJ,EAAQiJ,SAAU9J,KAAK84B,YAAYhvB,UAE3E9J,KAAK44B,gBACE/3B,EAAQo2B,KAEZp2B,CACX,EACA43B,UAAUv4B,UAAUg6B,aAAe,WAC/B,OAAOl6B,KAAK8J,SAAW9J,KAAK8J,QAAQqwB,cACxC,EACA1B,UAAUv4B,UAAU05B,iBAAmB,WACnC,IAAIh4B,EAAS5B,KAAK+4B;AAElB,OADA/4B,KAAK05B,yBACE93B,CACX,EAEA62B,UAAUv4B,UAAUy5B,oBAAsB,WACtC,IAOI/3B,EAPAw4B,GAAwC,IAA1Bp6B,KAAKm2B,aAAa4D,IAChCM,EAAgBr6B,KAAKs2B,gBAAgBtgB,OAAOyO,sBAC5C6V,GAAa,QAAS,CAAE3kB,SAAS,EAAMiE,cAAe,aAAuB0e,QAAQ,EAAMz2B,UAAM8d,EAAW4a,OAAO,EAAOvkB,OAAQhW,KAAKgW,QAAUhW,KAAKg5B;AAC1J,OAAIoB,IAAgBp6B,KAAKk6B,gBAAkBG,IACvCr6B,KAAK24B,aAAa/2B,OAAS04B,EACpBA,IAGPt6B,KAAKk6B,iBACLt4B,EACI5B,KAAK8J,QAAQqwB,eAAeK,gBAAgBx6B,KAAMA,KAAK+4B,iBAAmBuB,GAE3E14B,EACX,EACA62B,UAAUv4B,UAAUu6B,8BAAgC,WAChD,IAAI55B,EAAUb,KAAKm2B;AACnBn2B,KAAKw2B,mBAAmB31B,EAAQO,MAAOu0B,EAAaE;AACpD,IAAI6E,EAAc75B,EAAQ65B,aAAe;AAMzC,OALI16B,KAAKk6B,gBACoB,iBAAxBr5B,EAAQka,aACmB,sBAAxBla,EAAQka,cACZla,EAAQka,YAAc,gBAEnB,SAAS,QAAS,CAAC,EAAGla,GAAU,CAAE65B,YAAaA,EAAa5wB,QAASjJ,EAAQiJ,SACxF,EACA2uB,UAAUv4B,UAAUy6B,0BAA4B,WAI5C,GAHI36B,KAAKk6B,iBACLl6B,KAAK+2B,kBAAoB/2B,KAAK8J,QAAQqwB,eAAeS,iBAAiB56B,KAAKm2B,gBAE1En2B,KAAK+2B,kBAAmB,CACzB,IAAI8D,EAAyB76B,KAAKy6B;AAClCz6B,KAAK24B,aAAakC,wBAAyB,SAAS,QAAS,CAAC,EAAGA,GAAyB,CAAEvF,SAAU,OACtGt1B,KAAK+2B,kBAAoB/2B,KAAKs2B,gBAAgBtgB,OAAOkK,YAAW,QAAS,CAAC,EAAG2a,IACzE76B,KAAKk6B,gBACLl6B,KAAK8J,QAAQqwB,eAAeW,sBAAsB96B,KAAK+2B,kBAAmB8D,EAElF,CACJ,EACApC,UAAUv4B,UAAUu5B,sBAAwB,WACxC,IAAIz5B,KAAKm2B,aAAac,KAEtB,GAAKj3B,KAAK+2B,kBAAV,CAIA,IAAIgE,GAA4B,SAAS,QAAS,CAAC,EAAG/6B,KAAKy6B,iCAAkC,CAAEnF,SAAU,QACpG,OAAMyF,EAA2B/6B,KAAK24B,aAAakC,0BACpD76B,KAAK24B,aAAakC,uBAAyBE,EAC3C/6B,KAAK+2B,kBACArO,WAAWqS,GACXzR,OAAM,WAAc,IAN7B,MAFItpB,KAAK26B,2BAUb,EACAlC,UAAUv4B,UAAUw5B,uBAAyB,SAAUhB,GACnD,IAAI50B,EAAQ9D;KACM,IAAd04B,IAAwBA,EAAY14B,KAAK04B,WACzC14B,KAAKowB,qBAAuBpwB,KAAKm2B,aAAac,OAElDj3B,KAAKowB,oBAAsBpwB,KAAK+2B,kBAAkBhY,UAAU,CACxDC,KAAM,SAAUpY,GACZ,IAAI+O,EAAU/O,EAAG+O,QAASiE,EAAgBhT,EAAGgT,cAAe/X,EAAO+E,EAAG/E,KAClEgnB,EAAiB/kB,EAAM60B,aAAa/2B;AACpCinB,GACAA,EAAelT,UAAYA,GAC3BkT,EAAejP,gBAAkBA,IACjC,OAAMiP,EAAehnB,KAAMA,IAG/B62B,GACJ,EACA9iB,MAAO,SAAUA,GAEb,GADA9R,EAAMk3B,sBACDplB,EAAMvT,eAAe,iBACtB,MAAMuT;AACV,IAAIiT,EAAiB/kB,EAAM60B,aAAa/2B,QACnCinB,GAAkBA,EAAelT,WACjC,OAAMC,EAAO9R,EAAM60B,aAAa/iB,UACjC9R,EAAM60B,aAAa/iB,MAAQA,EAC3B8iB,IAER,IAER,EACAD,UAAUv4B,UAAU86B,mBAAqB,WACrCh7B,KAAKw5B;AACL,IAAIzC,EAAoB/2B,KAAK+2B;AAC7B,GAAIA,EAAmB,CACnB,IAAIlQ,EAAYkQ,EAAkBpP,eAC9BX,EAAa+P,EAAkBrP;AACnCqP,EAAkB5V,mBAClBnhB,KAAK05B,yBACLt3B,OAAOyX,OAAOkd,EAAmB,CAC7BlQ,UAAWA,EACXG,WAAYA,GAEpB,CACJ,EACAyR,UAAUv4B,UAAU+5B,uBAAyB,WACzC,GAAKj6B,KAAK+2B,mBAAsB/2B,KAAK24B,aAAa/2B,OAAlD,CAEA,IAAIgF,EAAK5G,KAAK24B,aAAa/2B,OAAQC,EAAO+E,EAAG/E,KAAM8T,EAAU/O,EAAG+O,QAASC,EAAQhP,EAAGgP;AACpF,IAAKD,EAAS,CACV,IAAI3M,EAAKhJ,KAAKm2B,aAAc/0B,EAAQ4H,EAAG5H,MAAOC,EAAY2H,EAAG3H,UAAWk3B,EAAcvvB,EAAGuvB,YAAa9P,EAAUzf,EAAGyf,QAASwO,EAAOjuB,EAAGiuB;AACtI,GAAIj3B,KAAKk2B,kBACJl2B,KAAK24B,aAAahjB,UACnB,OAAM3V,KAAKk2B,gBAAgB90B,MAAOA,KAClC,OAAMpB,KAAKk2B,gBAAgB70B,UAAWA,GACtC;CAEAk3B,GAAgB3iB,GAAUqhB,EAGrBxO,GAAW7S,GAChB6S,EAAQ7S,GAHR2iB,EAAY12B,EAKpB,CAhBU,CAiBd,EACA42B,UAAUv4B,UAAUs5B,wBAA0B,WACtCx5B,KAAKowB,sBACLpwB,KAAKowB,oBAAoB1O,qBAClB1hB,KAAKowB,oBAEpB,EACAqI,UAAUv4B,UAAU84B,sBAAwB,WACxC,IAAIpyB;AACJ,MAAO,CACHvF,UAA6C,QAAjCuF,EAAK5G,KAAK+2B,yBAAsC,IAAPnwB,OAAgB,EAASA,EAAGvF,UACjF+d,QAASpf,KAAKk5B,WACdnR,UAAW/nB,KAAKm5B,aAChB9Q,YAAaroB,KAAKo5B,eAClBtQ,aAAc9oB,KAAKq5B,gBACnBne,YAAalb,KAAKs5B,eAClB/Q,gBAAiBvoB,KAAKu5B,mBAE9B,EACOd,SACX,CA1RgB,CA0RdzC;AC3RK,SAASiF,aAAa75B,EAAOP,EAASm5B,QAC5B,IAATA,IAAmBA,GAAO;AAC9B,IAAIlwB,GAAU,IAAAoxB,YAAW,kCACrBt0B,GAAK,IAAAu0B,aAAW,SAAUvZ,GAAK,OAAOA,EAAI,CAAG,GAAG,GAAIwZ,EAAOx0B,EAAG,GAAIy0B,EAAcz0B,EAAG,GACnF00B,EAAiBz6B,GAAU,SAAS,QAAS,CAAC,EAAGA,GAAU,CAAEO,MAAOA,IAAW,CAAEA,MAAOA,GACxFm6B,GAAe,IAAAC,UACfC,EAAYF,EAAaG,SACzB,IAAIjD,EAAU,CACV53B,QAASy6B,EACTxxB,QAASA,EACT4uB,UAAW,WACF+C,EAAUvB,eAIXmB,IAHAtmB,QAAQC,UAAU4B,KAAKykB,EAK/B;AAERI,EAAU/S,WAAW4S,GACrBG,EAAU3xB,QAAUA,EAChB2xB,EAAUvB,iBAAmBqB,EAAaG,UAC1CH,EAAaG,QAAUD;AAE3B,IAKI75B,EChCD,SAAS+5B,YAAYC,EAAQhN,GAChC,IAAIjqB,GAAM,IAAA62B;AAIV,OAHK72B,EAAI+2B,UAAY,OAAM9M,EAAKjqB,EAAI+2B,QAAQ9M,OACxCjqB,EAAI+2B,QAAU,CAAE9M,IAAKA,EAAKlsB,MAAOk5B,MAE9Bj3B,EAAI+2B,QAAQh5B,KACvB,CD0BiBi5B,EAAY,WAAc,OAAQ3B,EAAOyB,EAAU5B,cAAgB4B,EAAUjjB,SAAY,GAL3F,CACP3X,SAAS,SAAS,QAAS,CAAC,EAAGy6B,GAAiB,CAAE7S,aAAS9I,EAAW4Y,iBAAa5Y,IACnF7V,QAASA,EACTsxB,KAAMA,IAGNS,EAAc7B,EACZp4B,EAAO,GACPA;AAaN,OAZA,IAAAk6B,YAAU,WAIN,OAHKP,EAAaG,UACdH,EAAaG,QAAUD,GAEpB,WAAc,OAAOA,EAAUpZ,SAAW,CACrD,GAAG,KACH,IAAAyZ,YAAU,WAAc,OAAOL,EAAUpE,aAAa,CAAE2C,KAAMA,GAAS,GAAG,CACtE6B,EAAYlmB,QACZkmB,EAAYjiB,cACZiiB,EAAYjmB,MACZimB,EAAYh6B,OAETD,CACX,CElDO,SAASm6B,aAAa36B,EAAOP,GAChC,OAAOo6B,aAAa75B,EAAOP,GAAS,EACxC,CCCO,SAASm7B,YAAYtmB,EAAU7U,GAClC,IAAIiJ,GAAU,IAAAoxB,YAAW,kCACrBt0B,GAAK,IAAAq1B,UAAS,CAAE3D,QAAQ,EAAO3iB,SAAS,IAAU/T,EAASgF,EAAG,GAAIkwB,EAAYlwB,EAAG,GACjF00B,EAAiBz6B,GAAU,SAAS,QAAS,CAAC,EAAGA,GAAU,CAAE6U,SAAUA,IAAc,CAAEA,SAAUA,GACjGwmB,GAAkB,IAAAV;AAYtB,IAAIW,EAXJ,SAASC,qBASL,OARKF,EAAgBR,UACjBQ,EAAgBR,QAAU,IAAI7D,EAAa,CACvCh3B,QAASy6B,EACTxxB,QAASA,EACTlI,OAAQA,EACRk1B,UAAWA,KAGZoF,EAAgBR,OAC3B,CACmBU;AAInB,OAHAD,EAAazT,WAAW4S,GACxBa,EAAaryB,QAAUA,GACvB,IAAAgyB,YAAU,WAAc,OAAOK,EAAa9E,cAAgB,IACrD8E,EAAa3jB,QAAQ5W,EAChC,CCxBO,SAASy6B,SAASj7B,EAAOP,GAC5B,OAAOo6B,aAAa75B,EAAOP,GAAS,EACxC,C;;;ACDO,SAASy7B,cAAc11B,EAAIvF,GAC9B,IAAI8X,EAAavS,EAAGuS;AACpB,OAAKA,IAAeA,EAAWrR,QAqC5B,SAASy0B,uBAAuBpjB,GACnC,IAAIvX,EAAS;AACTuX,GAAcA,EAAWrR,QACzBqR,EAAWvT,SAAQ,SAAUwT,GACzB,GARZ,SAASojB,qBAAqB51B,GAC1B,IAAIlE,EAAQkE,EAAG2F,KAAK7J;AACpB,MAAiB,SAAVA,GAA8B,YAAVA,CAC/B,CAKiB85B,CAAqBpjB,GAA1B,CAEA,IAAIqjB,EAAqBrjB,EAAU5Q;AACf4Q,EAAU7M,KAAK7J,OACK,QAAU+5B,GAAoD,IAA9BA,EAAmB30B,OAAc;AACzG,IAAI40B,EAAaD,EAAmB,IACI,QAAUC,EAAWnwB,MAAkC,OAA1BmwB,EAAWnwB,KAAK7J,MAAgB;AACrG,IAAIi6B,EAAUD,EAAWh6B,OACe,QAAUi6B,IAC5B,aAAjBA,EAAQ9kB,MAAwC,iBAAjB8kB,EAAQ9kB,MAA0B,IAEtEjW,EAAOoK,KAAK,CAAEoN,UAAWA,EAAWsjB,WAAYA,GAVtC,CAWd;AAEJ,OAAO96B,CACX,CArDW26B,CAAuBpjB,GAAYsX,OAAM,SAAU7pB,GACtD,IAAIwS,EAAYxS,EAAGwS,UAAWsjB,EAAa91B,EAAG81B,WAC1CE,GAAc;AAQlB,MAP8B,aAA1BF,EAAWh6B,MAAMmV,MACjB+kB,EAAcv7B,GAAaA,EAAUq7B,EAAWh6B,MAAM6J,KAAK7J,QACnB,aAA0B,IAAhBk6B,EAAwB,KAG1EA,EAAcF,EAAWh6B,MAAMA,MAEH,SAAzB0W,EAAU7M,KAAK7J,OAAoBk6B,EAAcA,CAC5D,GACJ,CAUO,SAASC,cAAcC,EAAOC,GACjC,OAVG,SAASC,kBAAkBD,GAC9B,IAAID,EAAQ;AAMZ,OALA,QAAMC,EAAM,CACRvlB,UAAW,SAAUE,GACjBolB,EAAM9wB,KAAK0L,EAAKnL,KAAK7J,MACzB,IAEGo6B,CACX,CAEWE,CAAkBD,GAAMplB,MAAK,SAAUpL,GAAQ,OAAOuwB,EAAMlvB,QAAQrB,IAAS,CAAG,GAC3F,CACO,SAAS6R,iBAAiB5d,GAC7B,OAAQA,GACJq8B,cAAc,CAAC,UAAWr8B,IAC1Bq8B,cAAc,CAAC,UAAWr8B,EAClC,C;AClCO,SAASy8B,yBAAyBz8B,EAAUgB,GAC/C,IAAI07B,EAAqB17B,EACrBwW,EAAY;AAgChB,OA/BAxX,EAASguB,YAAY5oB,SAAQ,SAAU+wB,GACnC,GAAwB,wBAApBA,EAAW9e,KACX,MAA8C,IAAI,KAAe;AAG7C,uBAApB8e,EAAW9e,MACXG,EAAUhM,KAAK2qB,EAEvB,SACkC,IAAvBuG,KACiC,QAA+B,IAArBllB,EAAUlQ,OAAc,IAC1Eo1B,EAAqBllB,EAAU,GAAGzL,KAAK7J,QAE/B,SAAS,QAAS,CAAC,EAAGlC,GAAW,CAAEguB,aAAa,QAAe,CACnE,CACI3W,KAAM,sBACNO,UAAW,QACX/N,aAAc,CACVwN,KAAM,eACNxL,WAAY,CACR,CACIwL,KAAM,iBACNtL,KAAM,CACFsL,KAAM,OACNnV,MAAOw6B,QAM5B18B,EAASguB,cAEpB,CACO,SAAS2O,kBAAkBnlB,QACZ,IAAdA,IAAwBA,EAAY;AACxC,IAAIolB,EAAW,CAAC;AAIhB,OAHAplB,EAAUpS,SAAQ,SAAUrE,GACxB67B,EAAS77B,EAASgL,KAAK7J,OAASnB,CACpC,IACO67B,CACX,CACO,SAASC,yBAAyB/wB,EAAWjB,GAChD,OAAQiB,EAAUuL,MACd,IAAK,iBACD,OAAOvL;AACX,IAAK,iBACD,IAAI/K,EAAW8J,GAAeA,EAAYiB,EAAUC,KAAK7J;AAEzD,OADwC,QAAUnB,EAAU,IACrDA;AAEX,QACI,OAAO,KAEnB,C;ACvDO,SAAS+7B,cAAcn8B,GAC1B,MAAO,CAAEiD,MAAOgM,OAAOjP,GAC3B,CACO,SAASsF,YAAY0B,GACxB,OAAOo1B,QAAQp1B,GAAsB,iBAARA,GAAyC,iBAAdA,EAAI/D,MAChE,CA4BO,SAASo5B,4BAA4BC,EAAQlxB,EAAM7J,EAAOrB,GAC7D,GAtBJ,SAASq8B,WAAWh7B,GAChB,MAAsB,aAAfA,EAAMmV,IACjB,CAoBQ6lB,CAAWh7B,IAnBnB,SAASi7B,aAAaj7B,GAClB,MAAsB,eAAfA,EAAMmV,IACjB,CAiB6B8lB,CAAaj7B,GAClC+6B,EAAOlxB,EAAK7J,OAASk7B,OAAOl7B,EAAMA;KAEjC,GA5BT,SAASm7B,eAAen7B,GACpB,MAAsB,iBAAfA,EAAMmV,IACjB,CA0BagmB,CAAen7B,IA/B5B,SAASo7B,cAAcp7B,GACnB,MAAsB,gBAAfA,EAAMmV,IACjB,CA6BsCimB,CAAcp7B,GAC5C+6B,EAAOlxB,EAAK7J,OAASA,EAAMA;KAE1B,GAnBT,SAASq7B,cAAcr7B,GACnB,MAAsB,gBAAfA,EAAMmV,IACjB,CAiBakmB,CAAcr7B,GAAQ,CAC3B,IAAIs7B,EAAiB,CAAC;AACtBt7B,EAAMoD,OAAOgH,KAAI,SAAU3E,GACvB,OAAOq1B,4BAA4BQ,EAAgB71B,EAAIoE,KAAMpE,EAAIzF,MAAOrB,EAC5E,IACAo8B,EAAOlxB,EAAK7J,OAASs7B,CACzB,MACK,GA7BT,SAASC,WAAWv7B,GAChB,MAAsB,aAAfA,EAAMmV,IACjB,CA2BaomB,CAAWv7B,GAAQ,CACxB,IAAIw7B,GAAiB78B,GAAa,CAAC,GAAGqB,EAAM6J,KAAK7J;AACjD+6B,EAAOlxB,EAAK7J,OAASw7B,CACzB,MACK,GA3BT,SAASC,YAAYz7B,GACjB,MAAsB,cAAfA,EAAMmV,IACjB,CAyBasmB,CAAYz7B,GACjB+6B,EAAOlxB,EAAK7J,OAASA,EAAM0F,OAAO0E,KAAI,SAAUsxB,GAC5C,IAAIC,EAAoB,CAAC;AAEzB,OADAb,4BAA4Ba,EAAmB9xB,EAAM6xB,EAAW/8B,GACzDg9B,EAAkB9xB,EAAK7J,MAClC;KAEC,GA/BT,SAAS47B,YAAY57B,GACjB,MAAsB,cAAfA,EAAMmV,IACjB,CA6BaymB,CAAY57B,GACjB+6B,EAAOlxB,EAAK7J,OAASA,EAAMA;IAE1B,KA/BT,SAAS67B,YAAY77B,GACjB,MAAsB,cAAfA,EAAMmV,IACjB,CA6Ba0mB,CAAY77B,GAIjB,MAA8C,IAAI,KAAe;AAHjE+6B,EAAOlxB,EAAK7J,OAAS,IAMzB,CACJ,CACO,SAAS87B,sBAAsB17B,EAAOzB,GACzC,IAAIo9B,EAAgB;AAChB37B,EAAMqW,aACNslB,EAAgB,CAAC,EACjB37B,EAAMqW,WAAWvT,SAAQ,SAAUwT,GAC/BqlB,EAAcrlB,EAAU7M,KAAK7J,OAAS,CAAC,EACnC0W,EAAU5Q,WACV4Q,EAAU5Q,UAAU5C,SAAQ,SAAUgB,GAClC,IAAI2F,EAAO3F,EAAG2F,KAAM7J,EAAQkE,EAAGlE;AAC/B,OAAO86B,4BAA4BiB,EAAcrlB,EAAU7M,KAAK7J,OAAQ6J,EAAM7J,EAAOrB,EACzF,GAER;AAEJ,IAAIo8B,EAAS;AAQb,OAPI36B,EAAM0F,WAAa1F,EAAM0F,UAAUV,SACnC21B,EAAS,CAAC,EACV36B,EAAM0F,UAAU5C,SAAQ,SAAUgB,GAC9B,IAAI2F,EAAO3F,EAAG2F,KAAM7J,EAAQkE,EAAGlE;AAC/B,OAAO86B,4BAA4BC,EAAQlxB,EAAM7J,EAAOrB,EAC5D,KAEGq9B,gBAAgB57B,EAAMyJ,KAAK7J,MAAO+6B,EAAQgB,EACrD,CACA,IAAIE,EAAmB,CACnB,aACA,UACA,OACA,SACA,OACA;AAEG,SAASD,gBAAgB55B,EAAW6B,EAAMwS,GAC7C,GAAIxS,GACAwS,GACAA,EAAuB,YACvBA,EAAuB,WAAO,IAAG,CACjC,GAAIA,EAAuB,WAAU,QACjCA,EAAuB,WAAU,OAAErR,OAAS,EAAG,CAC/C,IAAI82B,EAAazlB,EAAuB,WAAU,OAC5CA,EAAuB,WAAU,OACjC;AACNylB,EAAWC;AACX,IAAIC,EAAiB,CAAC;AAItB,OAHAF,EAAWh5B,SAAQ,SAAUgpB,GACzBkQ,EAAelQ,GAAOjoB,EAAKioB,EAC/B,IACOzV,EAAuB,WAAO,IAAI,IAAMhO,KAAKC,UAAU0zB,GAAkB,GACpF,CAEI,OAAO3lB,EAAuB,WAAO,GAE7C,CACA,IAAI4lB,EAAoBj6B;AACxB,GAAI6B,EAAM,CACN,IAAIq4B,EAAkB,IAAUr4B;AAChCo4B,GAAqB,IAAMC,EAAkB,GACjD,CAaA,OAZI7lB,GACA/W,OAAOuD,KAAKwT,GAAYvT,SAAQ,SAAUgpB,IACC,IAAnC+P,EAAiB/wB,QAAQghB,KAEzBzV,EAAWyV,IAAQxsB,OAAOuD,KAAKwT,EAAWyV,IAAM9mB,OAChDi3B,GAAqB,IAAMnQ,EAAM,IAAMzjB,KAAKC,UAAU+N,EAAWyV,IAAQ,IAGzEmQ,GAAqB,IAAMnQ,EAEnC,IAEGmQ,CACX,CACO,SAASE,yBAAyBn8B,EAAOzB,GAC5C,GAAIyB,EAAM0F,WAAa1F,EAAM0F,UAAUV,OAAQ,CAC3C,IAAIo3B,EAAW,CAAC;AAKhB,OAJAp8B,EAAM0F,UAAU5C,SAAQ,SAAUgB,GAC9B,IAAI2F,EAAO3F,EAAG2F,KAAM7J,EAAQkE,EAAGlE;AAC/B,OAAO86B,4BAA4B0B,EAAU3yB,EAAM7J,EAAOrB,EAC9D,IACO69B,CACX,CACA,OAAO,IACX,CACO,SAASC,uBAAuBr8B,GACnC,OAAOA,EAAMkQ,MAAQlQ,EAAMkQ,MAAMtQ,MAAQI,EAAMyJ,KAAK7J,KACxD,CACO,SAAS08B,sBAAsBx9B,EAAQyI,EAAcgB,GACxD,GAAiC,iBAAtBzJ,EAAOuK,WACd,OAAOvK,EAAOuK;AAElB,IAAK,IAAI5D,EAAK,EAAG3B,EAAKyD,EAAagC,WAAY9D,EAAK3B,EAAGkB,OAAQS,IAAM,CACjE,IAAI+D,EAAY1F,EAAG2B;AACnB,GAAI,mBAAQ+D,IACR,GAA6B,eAAzBA,EAAUC,KAAK7J,MACf,OAAOd,EAAOu9B,uBAAuB7yB,QAGxC,CACD,IAAIzF,EAAWu4B,sBAAsBx9B,EAAQy7B,yBAAyB/wB,EAAWjB,GAAahB,aAAcgB;AAC5G,GAAwB,iBAAbxE,EACP,OAAOA,CAEf,CACJ,CACJ,CACO,SAAS,mBAAQyF,GACpB,MAA0B,UAAnBA,EAAUuL,IACrB,CACO,SAASwnB,iBAAiB/yB,GAC7B,MAA0B,mBAAnBA,EAAUuL,IACrB,CCrLO,SAASynB,cAAcrf,IACc,QAAUA,GAAoB,aAAbA,EAAIpI,KAAqB;AAClF,IAAI0X,EAAatP,EAAIuO,YAChBnmB,QAAO,SAAUO,GAAK,MAAkB,uBAAXA,EAAEiP,IAA+B,IAC9D/K,KAAI,SAAU6pB,GACf,GAAwB,wBAApBA,EAAW9e,KACX,MAA8C,IAAI,KAAe;AAErE,OAAO8e,CACX;AAEA,OADwC,QAAUpH,EAAWznB,QAAU,EAAG,IACnEmY,CACX,CACO,SAASsf,uBAAuBtf,GAEnC,OADAqf,cAAcrf,GACPA,EAAIuO,YAAYnmB,QAAO,SAAUsuB,GAAc,MAA2B,wBAApBA,EAAW9e,IAAgC,IAAG,EAC/G,CACO,SAAS2nB,iBAAiBvf,GAC7B,OAAQA,EAAIuO,YACPnmB,QAAO,SAAUsuB,GAClB,MAA2B,wBAApBA,EAAW9e,MAAkC8e,EAAWpqB,IACnE,IACKO,KAAI,SAAU8U,GAAK,OAAOA,EAAErV,KAAK7J,KAAO,IAAG,IAAM,IAC1D,CACO,SAAS+8B,uBAAuBxf,GACnC,OAAOA,EAAIuO,YAAYnmB,QAAO,SAAUsuB,GAAc,MAA2B,uBAApBA,EAAW9e,IAA+B,GAC3G,CACO,SAAS6nB,mBAAmBzf,GAC/B,IAAI0f,EAAWJ,uBAAuBtf;AAEtC,OADwC,QAAU0f,GAAmC,UAAvBA,EAASvnB,UAAuB,IACvFunB,CACX,CAQO,SAASC,kBAAkBC,GAE9B,IAAIC;AADJR,cAAcO;AAEd,IAAK,IAAIt3B,EAAK,EAAG3B,EAAKi5B,EAASrR,YAAajmB,EAAK3B,EAAGkB,OAAQS,IAAM,CAC9D,IAAIouB,EAAa/vB,EAAG2B;AACpB,GAAwB,wBAApBouB,EAAW9e,KAAgC,CAC3C,IAAIO,EAAYue,EAAWve;AAC3B,GAAkB,UAAdA,GACc,aAAdA,GACc,iBAAdA,EACA,OAAOue,CAEf,CACwB,uBAApBA,EAAW9e,MAAkCioB,IAC7CA,EAAqBnJ,EAE7B,CACA,GAAImJ,EACA,OAAOA;AAEX,MAA8C,IAAI,KAAe,GACrE,CACO,SAASC,iBAAiBpJ,GAC7B,IAAIqJ,EAAgB59B,OAAOqB,OAAO,MAC9Bw8B,EAAOtJ,GAAcA,EAAWC;AAQpC,OAPIqJ,GAAQA,EAAKn4B,QACbm4B,EAAKr6B,SAAQ,SAAUs6B,GACfA,EAAIC,cACJ3C,4BAA4BwC,EAAeE,EAAIE,SAAS7zB,KAAM2zB,EAAIC,aAE1E,IAEGH,CACX,CC1EO,SAASK,cAAc11B,EAAO4gB,EAAMzhB,GACvC,IAAIw2B,EAAS;AAOb,OANA31B,EAAM/E,SAAQ,SAAU26B,EAAM1zB,GACtB0e,EAAKvmB,KAAKhF,KAAMugC,EAAM1zB,EAAGlC,KACzBA,EAAM21B,KAAYC,EAE1B,GAAGz2B,GACHa,EAAM7C,OAASw4B,EACR31B,CACX,CCFA,IAAI61B,EAAiB,CACjB3oB,KAAM,QACNtL,KAAM,CACFsL,KAAM,OACNnV,MAAO;AAGf,SAAS+9B,QAAQ9V,EAAI3S,GACjB,OAAO2S,EAAGtgB,aAAagC,WAAWokB,OAAM,SAAUnkB,GAC9C,MAA0B,mBAAnBA,EAAUuL,MACb4oB,QAAQzoB,EAAU1L,EAAUC,KAAK7J,OAAQsV,EACjD,GACJ,CACA,SAAS0oB,iBAAiBzgB,GACtB,OAAOwgB,QAAQlB,uBAAuBtf,IFanC,SAAS0gB,sBAAsB1gB,IACM,QAAuB,aAAbA,EAAIpI,KAAqB,KACnC,QAAUoI,EAAIuO,YAAY1mB,QAAU,EAAG;AAC/E,IAAI84B,EAAc3gB,EAAIuO,YAAY;AAElC,OADwC,QAA+B,uBAArBoS,EAAY/oB,KAA+B,IACtF+oB,CACX,CEnBkDD,CAAsB1gB,GAAMkd,kBAAkBsC,uBAAuBxf,KAC7G,KACAA,CACV,CACA,SAAS4gB,oBAAoB1nB,GACzB,OAAO,SAAS2nB,iBAAiB1nB,GAC7B,OAAOD,EAAWxB,MAAK,SAAUopB,GAC7B,OAAQA,EAAIx0B,MAAQw0B,EAAIx0B,OAAS6M,EAAU7M,KAAK7J,OAC3Cq+B,EAAIxV,MAAQwV,EAAIxV,KAAKnS,EAC9B,GACJ,CACJ,CACO,SAAS4nB,6BAA6B7nB,EAAY8G,GACrD,IAAIghB,EAAiB7+B,OAAOqB,OAAO,MAC/By9B,EAAoB,GACpBC,EAAuB/+B,OAAOqB,OAAO,MACrC29B,EAA0B,GAC1BC,EAAcX,kBAAiB,QAAMzgB,EAAK,CAC1CqhB,SAAU,CACN7pB,MAAO,SAAUC,EAAM6pB,EAAMn8B,GACL,uBAAhBA,EAAOyS,OACPopB,EAAevpB,EAAKnL,KAAK7J,QAAS,EAE1C,GAEJ8+B,MAAO,CACH/pB,MAAO,SAAUC,GACb,GAAIyB,GAAczB,EAAKyB,aACKA,EAAWxB,MAAK,SAAUyB,GAAa,OAAOA,EAAUqoB,MAAQ,KAEpF/pB,EAAKyB,YACLzB,EAAKyB,WAAWxB,KAAKkpB,oBAAoB1nB,KAiBzC,OAhBIzB,EAAKlP,WACLkP,EAAKlP,UAAU5C,SAAQ,SAAUgS,GACN,aAAnBA,EAAIlV,MAAMmV,MACVqpB,EAAkBl1B,KAAK,CACnBO,KAAMqL,EAAIlV,MAAM6J,KAAK7J,OAGjC,IAEAgV,EAAKrN,cACLq3B,sCAAsChqB,EAAKrN,cAAczE,SAAQ,SAAU+7B,GACvEP,EAAwBp1B,KAAK,CACzBO,KAAMo1B,EAAKp1B,KAAK7J,OAExB,IAEG,IAGnB,GAEJk/B,eAAgB,CACZnqB,MAAO,SAAUC,GACbypB,EAAqBzpB,EAAKnL,KAAK7J,QAAS,CAC5C,GAEJ8U,UAAW,CACPC,MAAO,SAAUC,GACb,GAAImpB,oBAAoB1nB,EAApB0nB,CAAgCnpB,GAChC,OAAO,IAEf;AAYR,OATI2pB,GACAhB,cAAca,GAAmB,SAAU1M,GAAK,QAASA,EAAEjoB,OAAS00B,EAAezM,EAAEjoB,KAAO,IAAGzE,SAC/Fu5B,EA0FD,SAASQ,4BAA4B53B,EAAQgW,GAChD,IAAI6hB,EAZR,SAASC,mBAAmB93B,GACxB,OAAO,SAAS+3B,gBAAgBC,GAC5B,OAAOh4B,EAAO0N,MAAK,SAAUuqB,GACzB,OAAOD,EAASv/B,OACY,aAAxBu/B,EAASv/B,MAAMmV,MACfoqB,EAASv/B,MAAM6J,OACd21B,EAAQ31B,OAAS01B,EAASv/B,MAAM6J,KAAK7J,OACjCw/B,EAAQ3W,MAAQ2W,EAAQ3W,KAAK0W,GAC1C,GACJ,CACJ,CAEqBF,CAAmB93B;AACpC,OAAOy2B,kBAAiB,QAAMzgB,EAAK,CAC/BkiB,oBAAqB,CACjB1qB,MAAO,SAAUC,GACb,OAAO,SAAS,QAAS,CAAC,EAAGA,GAAO,CAAEkf,oBAAqBlf,EAAKkf,oBAAsBlf,EAAKkf,oBAAoBvuB,QAAO,SAAU+5B,GACxH,OAAQn4B,EAAO0N,MAAK,SAAUC,GAAO,OAAOA,EAAIrL,OAAS61B,EAAOhC,SAAS7zB,KAAK7J,KAAO,GACzF,IAAK,IACb,GAEJ8+B,MAAO,CACH/pB,MAAO,SAAUC,GAEb,GADwBzN,EAAO0N,MAAK,SAAU0qB,GAAa,OAAOA,EAAUZ,MAAQ,IAC7D,CACnB,IAAIa,EAAkB;AAQtB,GAPI5qB,EAAKlP,WACLkP,EAAKlP,UAAU5C,SAAQ,SAAUgS,GACzBkqB,EAAWlqB,KACX0qB,GAAmB,EAE3B,IAEoB,IAApBA,EACA,OAAO,IAEf,CACJ,GAEJC,SAAU,CACN9qB,MAAO,SAAUC,GACb,GAAIoqB,EAAWpqB,GACX,OAAO,IAEf,KAGZ,CA9HsBmqB,CAA4BX,EAAmBG,IAE7DA,GACAhB,cAAce,GAAyB,SAAUoB,GAAM,QAASA,EAAGj2B,OAAS40B,EAAqBqB,EAAGj2B,KAAO,IACtGzE,SACLu5B,EA0HD,SAASoB,iCAAiCx4B,EAAQgW,GACrD,SAASxI,MAAMC,GACX,GAAIzN,EAAO0N,MAAK,SAAUuoB,GAAO,OAAOA,EAAI3zB,OAASmL,EAAKnL,KAAK7J,KAAO,IAClE,OAAO,IAEf,CACA,OAAOg+B,kBAAiB,QAAMzgB,EAAK,CAC/B2hB,eAAgB,CAAEnqB,OAClBirB,mBAAoB,CAAEjrB,SAE9B,CApIsBgrB,CAAiCrB,EAAyBC,IAErEA,CACX,CACO,SAASsB,sBAAsB1iB,GAClC,OAAO,QAAMqf,cAAcrf,GAAM,CAC7B2iB,aAAc,CACVnrB,MAAO,SAAUC,EAAM6pB,EAAMn8B,GACzB,IAAIA,GACgB,wBAAhBA,EAAOyS,KADX,CAIA,IAAIxL,EAAaqL,EAAKrL;AACtB,GAAKA,EAQL,IALWA,EAAWsL,MAAK,SAAUrL,GACjC,OAAQ,mBAAQA,KACc,eAAzBA,EAAUC,KAAK7J,OACkC,IAA9C4J,EAAUC,KAAK7J,MAAMmgC,YAAY,KAAM,GACnD,IACA,CAGA,IAAI//B,EAAQsC;AACZ,KAAI,mBAAQtC,IACRA,EAAMqW,YACNrW,EAAMqW,WAAWxB,MAAK,SAAU/O,GAAK,MAAwB,WAAjBA,EAAE2D,KAAK7J,KAAoB,KAG3E,OAAO,SAAS,QAAS,CAAC,EAAGgV,GAAO,CAAErL,YAAY,QAAeA,EAAY,CAACm0B,KAP9E,CAZA,CAoBJ,IAGZ,CACAmC,sBAAsBG,MAAQ,SAAUhgC,GACpC,OAAOA,IAAU09B,CACrB;AACA,IAAIuC,EAAyB,CACzBxX,KAAM,SAAUnS,GACZ,IAAI4pB,EAAsC,eAAzB5pB,EAAU7M,KAAK7J;AAQhC,OAPIsgC,KACK5pB,EAAU5Q,WACV4Q,EAAU5Q,UAAUmP,MAAK,SAAUC,GAAO,MAA0B,QAAnBA,EAAIrL,KAAK7J,KAAiB,KAK7EsgC,CACX;AAEG,SAASC,sCAAsChjB,GAClD,OAAO+gB,6BAA6B,CAAC+B,GAAyBzD,cAAcrf,GAChF,CAgFA,SAASyhB,sCAAsCr3B,GAC3C,IAAI64B,EAAe;AAUnB,OATA74B,EAAagC,WAAWzG,SAAQ,SAAU0G,IACjC,mBAAQA,IAAc+yB,iBAAiB/yB,KACxCA,EAAUjC,aACVq3B,sCAAsCp1B,EAAUjC,cAAczE,SAAQ,SAAU+7B,GAAQ,OAAOuB,EAAal3B,KAAK21B,EAAO,IAEhG,mBAAnBr1B,EAAUuL,MACfqrB,EAAal3B,KAAKM,EAE1B,IACO42B,CACX,CACO,SAASC,2BAA2B3iC,GAGvC,MAA4B,UAFXo/B,kBAAkBp/B,GACE4X,UAE1B5X,GAEO,QAAMA,EAAU,CAC9B2hC,oBAAqB,CACjB1qB,MAAO,SAAUC,GACb,OAAO,SAAS,QAAS,CAAC,EAAGA,GAAO,CAAEU,UAAW,SACrD,IAIZ,CACO,SAASgrB,6BAA6B5iC,GACzC8+B,cAAc9+B;AACd,IAAI6gC,EAAcL,6BAA6B,CAC3C,CACIzV,KAAM,SAAUnS,GAAa,MAAgC,WAAzBA,EAAU7M,KAAK7J,KAAoB,EACvE++B,QAAQ,IAEbjhC;AAiBH,OAhBI6gC,IACAA,GAAc,QAAMA,EAAa,CAC7BqB,mBAAoB,CAChBjrB,MAAO,SAAUC,GACb,GAAIA,EAAKrN,cACgBqN,EAAKrN,aAAagC,WAAWokB,OAAM,SAAUnkB,GAC9D,OAAO,mBAAQA,IAAuC,eAAzBA,EAAUC,KAAK7J,KAChD,IAEI,OAAO,IAGnB,MAIL2+B,CACX,C;;ACtRA,8BAAuC,WAAc,OAAOrhC,IAAM;ACDlE,IAAI,EAAiBoC,OAAOlC,UAAUmC;AAC/B,SAASghC,YAEZ,IADA,IAAIC,EAAU,GACL/6B,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpC+6B,EAAQ/6B,GAAMC,UAAUD;AAE5B,OAAOg7B,eAAeD,EAC1B,CACO,SAASC,eAAeD,GAC3B,IAAIhD,EAASgD,EAAQ,IAAM,CAAC,EACxBh8B,EAAQg8B,EAAQx7B;AACpB,GAAIR,EAAQ,EAER,IADA,IAAI8F,EAAS,IAAIo2B,EACR32B,EAAI,EAAGA,EAAIvF,IAASuF,EACzByzB,EAASlzB,EAAO7J,MAAM+8B,EAAQgD,EAAQz2B;AAG9C,OAAOyzB,CACX,CACA,SAASmD,SAASt7B,GACd,OAAe,OAARA,GAA+B,iBAARA,CAClC,CACA,IAAIu7B,kBAAoB,SAAUpD,EAAQqD,EAAQxgC,GAC9C,OAAOnD,KAAKuD,MAAM+8B,EAAOn9B,GAAWwgC,EAAOxgC,GAC/C,EACIqgC,EAAc,WACd,SAASA,WAAWI,QACG,IAAfA,IAAyBA,EAAaF,mBAC1C1jC,KAAK4jC,WAAaA,EAClB5jC,KAAKyjC,SAAWA,SAChBzjC,KAAK6jC,WAAa,IAAIp8B,GAC1B,CAwCA,OAvCA+7B,WAAWtjC,UAAUqD,MAAQ,SAAU+8B,EAAQqD,GAG3C,IAFA,IAAI7/B,EAAQ9D,KACR8J,EAAU,GACLvB,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpCuB,EAAQvB,EAAK,GAAKC,UAAUD;AAEhC,OAAIk7B,SAASE,IAAWF,SAASnD,IAC7Bl+B,OAAOuD,KAAKg+B,GAAQ/9B,SAAQ,SAAUk+B,GAClC,GAAI,EAAe9+B,KAAKs7B,EAAQwD,GAAY,CACxC,IAAIC,EAAczD,EAAOwD;AACzB,GAAIH,EAAOG,KAAeC,EAAa,CACnC,IAAIniC,EAASkC,EAAM8/B,WAAW33B,MAAMnI,GAAO,QAAe,CAACw8B,EAAQqD,EAAQG,GAAYh6B;AACnFlI,IAAWmiC,KACXzD,EAASx8B,EAAMkgC,oBAAoB1D,IAC5BwD,GAAaliC,EAE5B,CACJ,MAEI0+B,EAASx8B,EAAMkgC,oBAAoB1D,IAC5BwD,GAAaH,EAAOG,EAEnC,IACOxD,GAEJqD,CACX,EACAH,WAAWtjC,UAAU8jC,oBAAsB,SAAUthC,GAUjD,OATI+gC,SAAS/gC,KAAW1C,KAAK6jC,WAAWt/B,IAAI7B,KAEpCA,EADAC,MAAMC,QAAQF,GACNA,EAAMqH,MAAM,IAGZ,QAAS,CAAEkgB,UAAW7nB,OAAO6hC,eAAevhC,IAAUA,GAElE1C,KAAK6jC,WAAWn8B,IAAIhF,IAEjBA,CACX,EACO8gC,UACX,CA/CiB,GC1Bb,EAAWphC,OAAOlC,UAAUgkC;AACzB,SAASC,UAAUzhC,GACtB,OAAO0hC,gBAAgB1hC,EAC3B,CACA,SAAS0hC,gBAAgBC,EAAKC,GAC1B,OAAQ,EAASt/B,KAAKq/B,IAClB,IAAK,iBAED,IADAC,EAAOA,GAAQ,IAAIvwB,KACVxP,IAAI8/B,GACT,OAAOC,EAAKngC,IAAIkgC;AACpB,IAAIE,EAASF,EAAIt6B,MAAM;AAKvB,OAJAu6B,EAAK33B,IAAI03B,EAAKE,GACdA,EAAO3+B,SAAQ,SAAU4+B,EAAO33B,GAC5B03B,EAAO13B,GAAKu3B,gBAAgBI,EAAOF,EACvC,IACOC;AAEX,IAAK,kBAED,IADAD,EAAOA,GAAQ,IAAIvwB,KACVxP,IAAI8/B,GACT,OAAOC,EAAKngC,IAAIkgC;AACpB,IAAII,EAASriC,OAAOqB,OAAOrB,OAAO6hC,eAAeI;AAKjD,OAJAC,EAAK33B,IAAI03B,EAAKI,GACdriC,OAAOuD,KAAK0+B,GAAKz+B,SAAQ,SAAUgpB,GAC/B6V,EAAO7V,GAAOwV,gBAAgBC,EAAIzV,GAAM0V,EAC5C,IACOG;AAEX,QACI,OAAOJ,EAEnB,CCbO,SAASK,gBAAgBv8B,GAI5B,OAAOA,CACX,CCvBO,SAASw8B,uBAAuB/d,EAAWiG,EAAQoV,GACtD,IAAI2C,EAAsB;AAC1Bhe,EAAUhhB,SAAQ,SAAUi/B,GAAO,OAAOA,EAAIhY,IAAW+X,EAAoB54B,KAAK64B,EAAM,IACxFD,EAAoBh/B,SAAQ,SAAUi/B,GAAO,OAAOA,EAAIhY,GAAQoV,EAAW,GAC/E,CCHO,SAAS6C,SAAS1kB,EAAYwI,EAAOmc,GACxC,OAAO,IAAI,IAAJ,EAAe,SAAUvjB,GAC5B,IAAIxC,EAAOwC,EAASxC,KAAMpJ,EAAQ4L,EAAS5L,MAAOpK,EAAWgW,EAAShW,SAClEw5B,EAAsB,EACtBC,GAAY;AAChB,SAASC,aAAaC,EAAUC,GAC5B,OAAID,EACO,SAAUvtB,KACXotB,EACF,IAAIjwB,SAAQ,SAAUC,GAAW,OAAOA,EAAQmwB,EAASvtB,GAAO,IAAGhB,MAAK,SAAUhV,KAC5EojC,EACFhmB,GAAQA,EAAKha,KAAKwc,EAAU5f,GACxBqjC,GACApa,EAAQrf,UAEhB,IAAG,SAAUyT,KACP+lB,EACFpvB,GAASA,EAAM5Q,KAAKwc,EAAUvC,EAClC,GACJ,EAGO,SAAUrH,GAAO,OAAOwtB,GAAYA,EAASpgC,KAAKwc,EAAU5J,EAAM,CAEjF,CACA,IAAIiT,EAAU,CACV7L,KAAMkmB,aAAatc,EAAO5J,GAC1BpJ,MAAOsvB,aAAaH,EAASnvB,GAC7BpK,SAAU,WACNy5B,GAAY,EACPD,GACDx5B,GAAYA,EAASxG,KAAKwc,EAElC,GAEAC,EAAMrB,EAAWrB,UAAU8L;AAC/B,OAAO,WAAc,OAAOpJ,EAAIC,aAAe,CACnD,GACJ,CCpCA,SAAS2jB,cAAc3iC,GACnB,OAAOA,GAA+B,mBAAfA,EAAMkU,IACjC,CACA,IAAI0uB,EAAW,SAAUv8B,GAErB,SAASu8B,QAAQhC,GACb,IAAIx/B,EAAQiF,EAAO/D,KAAKhF,MAAM,SAAUwhB,GAEpC,OADA1d,EAAMuiB,YAAY7E,GACX,WAAc,OAAO1d,EAAMsiB,eAAe5E,EAAW,CAChE,KAAMxhB;AA0DN,OAzDA8D,EAAM8iB,UAAY,IAAInf,IACtB3D,EAAM0b,QAAU,IAAIzK,SAAQ,SAAUC,EAAS4J,GAC3C9a,EAAMkR,QAAUA,EAChBlR,EAAM8a,OAASA,CACnB,IACA9a,EAAMyhC,SAAW,CACbvmB,KAAM,SAAUpd,GACM,OAAdkC,EAAM2d,MACN3d,EAAM4H,OAAS,CAAC,OAAQ9J,GACxB+iC,uBAAuB7gC,EAAM8iB,UAAW,OAAQhlB,GAExD,EACAgU,MAAO,SAAUA,GACK,OAAd9R,EAAM2d,MACF3d,EAAM2d,KACN3d,EAAM2d,IAAIC,cACd5d,EAAM2d,IAAM,KACZ3d,EAAM4H,OAAS,CAAC,QAASkK,GACzB9R,EAAM8a,OAAOhJ,GACb+uB,uBAAuB7gC,EAAM8iB,UAAW,QAAShR,GAEzD,EACApK,SAAU,WACN,GAAkB,OAAd1H,EAAM2d,IAAc,CACpB,IAAI/e,EAAQoB,EAAMw/B,QAAQkC;AACrB9iC,EAWI2iC,cAAc3iC,GACnBA,EAAMkU,MAAK,SAAUiuB,GAAO,OAAO/gC,EAAM2d,IAAMojB,EAAI9lB,UAAUjb,EAAMyhC,SAAW,IAG9EzhC,EAAM2d,IAAM/e,EAAMqc,UAAUjb,EAAMyhC,WAdlCzhC,EAAM2d,IAAM,KACR3d,EAAM4H,QACc,SAApB5H,EAAM4H,OAAO,GACb5H,EAAMkR,QAAQlR,EAAM4H,OAAO,IAG3B5H,EAAMkR,UAEV2vB,uBAAuB7gC,EAAM8iB,UAAW,YAQhD,CACJ,GAEJ9iB,EAAMmX,OAAS,SAAU4H,GACrB/e,EAAM8a,OAAOiE,GACb/e,EAAMw/B,QAAU,GAChBx/B,EAAMyhC,SAAS/5B,UACnB,EACA1H,EAAM0b,QAAQ8J,OAAM,SAAUja,GAAK,IAC/Bg2B,cAAc/B,GACdA,EAAQ1sB,MAAK,SAAU6uB,GAAY,OAAO3hC,EAAM6sB,MAAM8U,EAAW,GAAG3hC,EAAMyhC,SAAS3vB,OAGnF9R,EAAM6sB,MAAM2S,GAETx/B,CACX,CAqDA,OArHA,QAAUwhC,QAASv8B,GAiEnBu8B,QAAQplC,UAAUywB,MAAQ,SAAU2S,QACf,IAAbtjC,KAAKyhB,MAETzhB,KAAKsjC,QAAU3gC,MAAMyD,KAAKk9B,GAC1BtjC,KAAKulC,SAAS/5B,WAClB,EACA85B,QAAQplC,UAAUmmB,YAAc,SAAU7E,GACtC,IAAKxhB,KAAK4mB,UAAUriB,IAAIid,GAAW,CAC/B,GAAIxhB,KAAK0L,OAAQ,CACb,IAAIg6B,EAAc1lC,KAAK0L,OAAO,GAC1BmhB,EAASrL,EAASkkB;AAClB7Y,GACAA,EAAO7nB,KAAKwc,EAAUxhB,KAAK0L,OAAO,IAErB,OAAb1L,KAAKyhB,KACW,SAAhBikB,GACAlkB,EAAShW,UACTgW,EAAShW,UAEjB,CACAxL,KAAK4mB,UAAUlf,IAAI8Z,EACvB,CACJ,EACA8jB,QAAQplC,UAAUkmB,eAAiB,SAAU5E,EAAUmkB,GACnD,GAAI3lC,KAAK4mB,UAAUlgB,OAAO8a,IACtBxhB,KAAK4mB,UAAU9L,KAAO,EAAG,CACzB,GAAI6qB,EACA;AACA3lC,KAAKyhB,MACLzhB,KAAKyhB,IAAIC,cACT1hB,KAAK4e,OAAO,IAAIsL,MAAM,sCAE1BlqB,KAAKyhB,IAAM,IACf,CACJ,EACA6jB,QAAQplC,UAAUmiB,QAAU,SAAUhO,GAClC,IAAIvQ,EAAQ9D,KACRs4B,GAAS,EACTsN,KAAO,WACFtN,IACDA,GAAS,EACTx0B,EAAM8iB,UAAUlgB,OAAO8a,GACvBnN,IAER,EACImN,EAAW,CACXxC,KAAM4mB,KACNhwB,MAAOgwB,KACPp6B,SAAUo6B;AAEd5lC,KAAKqmB,YAAY7E,EACrB,EACO8jB,OACX,CAvHc,CAuHZ;AC7HK,SAASO,gBAAgBnjC,GAC5B,OAAOC,MAAMC,QAAQF,IAAUA,EAAMoF,OAAS,CAClD,CCFO,SAASg+B,sBAAsBlkC,GAClC,OAAQA,EAAO0Z,QAAU1Z,EAAO0Z,OAAOxT,OAAS,IAAM,CAC1D,CF6HsB,mBAAXwsB,QAAyBA,OAAOyR,SACvC3jC,OAAO+kB,eAAeme,EAAShR,OAAOyR,QAAS,CAC3CrjC,MAAO;AGjIR,IAAIsjC,EAAmC,mBAAZx7B,WAAiD,iBAAdy7B,WAC3C,gBAAtBA,UAAUC;ACDP,SAASC,UAEZ,IADA,IAAIC,EAAU,GACL79B,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpC69B,EAAQ79B,GAAMC,UAAUD;AAE5B,IAAI3G,EAASQ,OAAOqB,OAAO;AAW3B,OAVA2iC,EAAQxgC,SAAQ,SAAUuC,GACjBA,GAEL/F,OAAOuD,KAAKwC,GAAKvC,SAAQ,SAAUgpB,GAC/B,IAAIlsB,EAAQyF,EAAIymB;KACF,IAAVlsB,IACAd,EAAOgtB,GAAOlsB,EAEtB,GACJ,IACOd,CACX,C;;ACqCA,QAtDW,WACP,SAASykC,IAAIxlC,GACT,IAAI+F,EAAK/F,EAAQylC,MAAOA,OAAe,IAAP1/B,GAAwBA;AACxD5G,KAAKsmC,MAAQA,EACbtmC,KAAKumC,MAAQ,EACjB,CA+CA,OA9CAF,IAAInmC,UAAUsmC,KAAO,SAAUC,EAAOxkC,GAClC,GAAIwkC,KAASC,QACIL,IAAIM,MAGzB,EACAN,IAAInmC,UAAU0mC,SAAW,WACrB,IAAI9iC,EAAQ9D;AACZA,KAAKumC,MAAM3gC,SAAQ,SAAUgB,GACzB,IAAI6/B,EAAQ7/B,EAAG,GAAI3E,EAAU2E,EAAG;AAChC,OAAO9C,EAAM0iC,KAAKC,EAAOxkC,EAC7B,GACJ,EACAokC,IAAInmC,UAAU2mC,QAAU,WACpB,OAAO7mC,KAAKumC,KAChB,EACAF,IAAInmC,UAAUwB,MAAQ,SAAU+kC,EAAOxkC,GACnC,IAAI6kC,EAAST,IAAIS;AACjB9mC,KAAKumC,MAAQvmC,KAAKumC,MAAMx8B,MAAM,EAAI+8B,GAAQzb,OAAO,CAAC,CAACob,EAAOxkC,MACtDjC,KAAKsmC,OAAmB,QAAVG,IACdzmC,KAAKwmC,KAAKC,EAAOxkC,EAEzB,EACAokC,IAAInmC,UAAU2S,KAAO,WAEjB,IADA,IAAI5Q,EAAU,GACLsG,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpCtG,EAAQsG,GAAMC,UAAUD;AAE5BvI,KAAK0B,MAAM,MAAOO,EACtB,EACAokC,IAAInmC,UAAU6mC,KAAO,WAEjB,IADA,IAAI9kC,EAAU,GACLsG,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpCtG,EAAQsG,GAAMC,UAAUD;AAE5BvI,KAAK0B,MAAM,OAAQO,EACvB,EACAokC,IAAInmC,UAAU0V,MAAQ,WAElB,IADA,IAAI3T,EAAU,GACLsG,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpCtG,EAAQsG,GAAMC,UAAUD;AAE5BvI,KAAK0B,MAAM,QAASO,EACxB,EACAokC,IAAIS,OAAS,GACbT,IAAIM,OAAS,yBACNN,GACX,CArDU;ACuBV,QAvBa,WACT,SAASvmC,MAAMe,GACX,IAAIoK,EAAQpK,EAAQoK,MAAOrE,EAAK/F,EAAQmmC,UAAWA,OAAmB,IAAPpgC,GAAuBA;AACtF5G,KAAKiL,MAAQA,EACbjL,KAAKgnC,UAAYA,CACrB,CAgBA,OAfAlnC,MAAMI,UAAUwU,QAAU,WACtB,IAAI7S,EAAO7B,KAAKiL,MAAMyJ;AAItB,OAHI1U,KAAKgnC,YACLnlC,EAAOsJ,KAAKC,UAAUvJ,IAEnBA,CACX,EACA/B,MAAMI,UAAUuU,QAAU,SAAU5S,GAC5B7B,KAAKgnC,WAA6B,iBAATnlC,IACzBA,EAAOsJ,KAAKukB,MAAM7tB,IAEV,MAARA,GACA7B,KAAKiL,MAAMwJ,QAAQ5S,EAE3B,EACO/B,KACX,CAtBY;ACAZ,IAAIwzB,UAAwC,SAAUC,EAASC,EAAYC,EAAGC,GAC1E,OAAO,IAAKD,IAAMA,EAAI1e,WAAU,SAAUC,EAAS4J,GAC/C,SAAS+U,UAAUjxB,GAAS,IAAMkxB,KAAKF,EAAU1U,KAAKtc,GAAS,CAAE,MAAOuc,GAAKL,EAAOK,EAAI,CAAE,CAC1F,SAAS4U,SAASnxB,GAAS,IAAMkxB,KAAKF,EAAiB,MAAEhxB,GAAS,CAAE,MAAOuc,GAAKL,EAAOK,EAAI,CAAE,CAC7F,SAAS2U,KAAKhyB,GAAUA,EAAOkyB,KAAO9e,EAAQpT,EAAOc,OAAS,IAAI+wB,GAAE,SAAUze,GAAWA,EAAQpT,EAAOc,MAAQ,IAAGkU,KAAK+c,UAAWE,SAAW,CAC9ID,MAAMF,EAAYA,EAAUznB,MAAMsnB,EAASC,GAAc,KAAKxU,OAClE,GACJ,EACIgV,YAA4C,SAAUT,EAASrF,GAC/D,IAAsG+F,EAAG7I,EAAG6H,EAAGiB,EAA3G7kB,EAAI,CAAE2O,MAAO,EAAGK,KAAM,WAAa,GAAW,EAAP4U,EAAE,GAAQ,MAAMA,EAAE;AAAI,OAAOA,EAAE,EAAI,EAAGkB,KAAM,GAAIC,IAAK;AAChG,OAAOF,EAAI,CAAElV,KAAMqV,KAAK,GAAI,MAASA,KAAK,GAAI,OAAUA,KAAK,IAAwB,mBAAXC,SAA0BJ,EAAEI,OAAOC,UAAY,WAAa,OAAOv0B,IAAM,GAAIk0B;AACvJ,SAASG,KAAKnB,GAAK,OAAO,SAAUsB,GAAK,OACzC,SAASZ,KAAKjJ,GACV,GAAIsJ,EAAG,MAAM,IAAIQ,UAAU;AAC3B,KAAOplB,OACH,GAAI4kB,EAAI,EAAG7I,IAAM6H,EAAI7H,EAAU,EAART,EAAG,GAAS,SAAWA,EAAG,GAAK,QAAU,YAAcsI,EAAIA,EAAEjuB,KAAKomB,EAAGT,EAAG,KAAKmJ,KAAM,OAAOb;AAEjH,OADI7H,EAAI,EAAG6H,IAAGtI,EAAK,CAAC,EAAGsI,EAAEvwB,QACjBioB,EAAG,IACP,KAAK,EAAG,KAAK,EAAGsI,EAAItI;AAAI;AACxB,KAAK,EAAc,OAAXtb,EAAE2O,QAAgB,CAAEtb,MAAOioB,EAAG,GAAImJ,MAAM;AAChD,KAAK,EAAGzkB,EAAE2O,QAASoN,EAAIT,EAAG,GAAIA,EAAK,CAAC;AAAI;AACxC,KAAK,EAAGA,EAAKtb,EAAE+kB,IAAI3nB,MAAO4C,EAAE8kB,KAAK1nB;AAAO;AACxC,QACI,KAAMwmB,EAAI5jB,EAAE8kB,MAAMlB,EAAIA,EAAEnrB,OAAS,GAAKmrB,EAAEA,EAAEnrB,OAAS,KAAkB,IAAV6iB,EAAG,IAAsB,IAAVA,EAAG,IAAW,CAAEtb,EAAI;AAAG,QAAU,CAC3G,GAAc,IAAVsb,EAAG,MAAcsI,GAAMtI,EAAG,GAAKsI,EAAE,IAAMtI,EAAG,GAAKsI,EAAE,IAAM,CAAE5jB,EAAE2O,MAAQ2M,EAAG;AAAI,KAAO,CACrF,GAAc,IAAVA,EAAG,IAAYtb,EAAE2O,MAAQiV,EAAE,GAAI,CAAE5jB,EAAE2O,MAAQiV,EAAE,GAAIA,EAAItI;AAAI,KAAO,CACpE,GAAIsI,GAAK5jB,EAAE2O,MAAQiV,EAAE,GAAI,CAAE5jB,EAAE2O,MAAQiV,EAAE,GAAI5jB,EAAE+kB,IAAIpoB,KAAK2e;AAAK,KAAO,CAC9DsI,EAAE,IAAI5jB,EAAE+kB,IAAI3nB,MAChB4C,EAAE8kB,KAAK1nB;AAAO,SAEtBke,EAAKuD,EAAKlpB,KAAKuuB,EAASlkB,EAC5B,CAAE,MAAO4P,GAAK0L,EAAK,CAAC,EAAG1L,GAAImM,EAAI,CAAG,CAAE,QAAU6I,EAAIhB,EAAI,CAAG,CACzD,GAAY,EAARtI,EAAG,GAAQ,MAAMA,EAAG;AAAI,MAAO,CAAEjoB,MAAOioB,EAAG,GAAKA,EAAG,QAAK,EAAQmJ,MAAM,EAC9E,CAtBgDF,CAAK,CAACV,EAAGsB,GAAK,CAAG,CAuBrE;AA2DA,QA1De,WACX,SAASyS,QAAQpmC,GACb,IAAIkR,EAAUlR,EAAQkR,QAASnL,EAAK/F,EAAQ+tB,IAAKA,OAAa,IAAPhoB,EAAgB,uBAAyBA;AAChG5G,KAAK+R,QAAUA,EACf/R,KAAK4uB,IAAMA,CACf,CAmDA,OAlDAqY,QAAQ/mC,UAAUe,KAAO,WACrB,OAAOqyB,UAAUtzB,UAAM,OAAQ,GAAQ,WACnC,OAAOg0B,YAAYh0B,MAAM,SAAU4G,GAC/B,MAAO,CAAC,EAAG5G,KAAK+R,QAAQm1B,QAAQlnC,KAAK4uB,KACzC,GACJ,GACJ,EACAqY,QAAQ/mC,UAAUwB,MAAQ,SAAUG,GAChC,OAAOyxB,UAAUtzB,UAAM,OAAQ,GAAQ,WACnC,OAAOg0B,YAAYh0B,MAAM,SAAU4G,GAC/B,OAAQA,EAAGoX,OACP,KAAK,EAAG,MAAO,CAAC,EAAGhe,KAAK+R,QAAQo1B,QAAQnnC,KAAK4uB,IAAK/sB;AAClD,KAAK,EAED,OADA+E,EAAGyX,OACI,CAAC,GAEpB,GACJ,GACJ,EACA4oB,QAAQ/mC,UAAUknC,MAAQ,WACtB,OAAO9T,UAAUtzB,UAAM,OAAQ,GAAQ,WACnC,OAAOg0B,YAAYh0B,MAAM,SAAU4G,GAC/B,OAAQA,EAAGoX,OACP,KAAK,EAAG,MAAO,CAAC,EAAGhe,KAAK+R,QAAQs1B,WAAWrnC,KAAK4uB;AAChD,KAAK,EAED,OADAhoB,EAAGyX,OACI,CAAC,GAEpB,GACJ,GACJ,EACA4oB,QAAQ/mC,UAAUonC,QAAU,WACxB,OAAOhU,UAAUtzB,UAAM,OAAQ,GAAQ,WACnC,IAAI6B;AACJ,OAAOmyB,YAAYh0B,MAAM,SAAU4G,GAC/B,OAAQA,EAAGoX,OACP,KAAK,EAAG,MAAO,CAAC,EAAGhe,KAAK+R,QAAQm1B,QAAQlnC,KAAK4uB;AAC7C,KAAK,EAED,OAAY,OADZ/sB,EAAO+E,EAAGyX,QAEC,CAAC,EAAG,GAGJ,CAAC,EAAmB,iBAATxc,EAAoBA,EAAKiG,OAAS,MAIpE,GACJ,GACJ,EACOm/B,OACX,CAzDc;ACnCd,IAAI,kBAAwC,SAAU1T,EAASC,EAAYC,EAAGC,GAC1E,OAAO,IAAKD,IAAMA,EAAI1e,WAAU,SAAUC,EAAS4J,GAC/C,SAAS+U,UAAUjxB,GAAS,IAAMkxB,KAAKF,EAAU1U,KAAKtc,GAAS,CAAE,MAAOuc,GAAKL,EAAOK,EAAI,CAAE,CAC1F,SAAS4U,SAASnxB,GAAS,IAAMkxB,KAAKF,EAAiB,MAAEhxB,GAAS,CAAE,MAAOuc,GAAKL,EAAOK,EAAI,CAAE,CAC7F,SAAS2U,KAAKhyB,GAAUA,EAAOkyB,KAAO9e,EAAQpT,EAAOc,OAAS,IAAI+wB,GAAE,SAAUze,GAAWA,EAAQpT,EAAOc,MAAQ,IAAGkU,KAAK+c,UAAWE,SAAW,CAC9ID,MAAMF,EAAYA,EAAUznB,MAAMsnB,EAASC,GAAc,KAAKxU,OAClE,GACJ,EACI,oBAA4C,SAAUuU,EAASrF,GAC/D,IAAsG+F,EAAG7I,EAAG6H,EAAGiB,EAA3G7kB,EAAI,CAAE2O,MAAO,EAAGK,KAAM,WAAa,GAAW,EAAP4U,EAAE,GAAQ,MAAMA,EAAE;AAAI,OAAOA,EAAE,EAAI,EAAGkB,KAAM,GAAIC,IAAK;AAChG,OAAOF,EAAI,CAAElV,KAAMqV,KAAK,GAAI,MAASA,KAAK,GAAI,OAAUA,KAAK,IAAwB,mBAAXC,SAA0BJ,EAAEI,OAAOC,UAAY,WAAa,OAAOv0B,IAAM,GAAIk0B;AACvJ,SAASG,KAAKnB,GAAK,OAAO,SAAUsB,GAAK,OACzC,SAASZ,KAAKjJ,GACV,GAAIsJ,EAAG,MAAM,IAAIQ,UAAU;AAC3B,KAAOplB,OACH,GAAI4kB,EAAI,EAAG7I,IAAM6H,EAAI7H,EAAU,EAART,EAAG,GAAS,SAAWA,EAAG,GAAK,QAAU,YAAcsI,EAAIA,EAAEjuB,KAAKomB,EAAGT,EAAG,KAAKmJ,KAAM,OAAOb;AAEjH,OADI7H,EAAI,EAAG6H,IAAGtI,EAAK,CAAC,EAAGsI,EAAEvwB,QACjBioB,EAAG,IACP,KAAK,EAAG,KAAK,EAAGsI,EAAItI;AAAI;AACxB,KAAK,EAAc,OAAXtb,EAAE2O,QAAgB,CAAEtb,MAAOioB,EAAG,GAAImJ,MAAM;AAChD,KAAK,EAAGzkB,EAAE2O,QAASoN,EAAIT,EAAG,GAAIA,EAAK,CAAC;AAAI;AACxC,KAAK,EAAGA,EAAKtb,EAAE+kB,IAAI3nB,MAAO4C,EAAE8kB,KAAK1nB;AAAO;AACxC,QACI,KAAMwmB,EAAI5jB,EAAE8kB,MAAMlB,EAAIA,EAAEnrB,OAAS,GAAKmrB,EAAEA,EAAEnrB,OAAS,KAAkB,IAAV6iB,EAAG,IAAsB,IAAVA,EAAG,IAAW,CAAEtb,EAAI;AAAG,QAAU,CAC3G,GAAc,IAAVsb,EAAG,MAAcsI,GAAMtI,EAAG,GAAKsI,EAAE,IAAMtI,EAAG,GAAKsI,EAAE,IAAM,CAAE5jB,EAAE2O,MAAQ2M,EAAG;AAAI,KAAO,CACrF,GAAc,IAAVA,EAAG,IAAYtb,EAAE2O,MAAQiV,EAAE,GAAI,CAAE5jB,EAAE2O,MAAQiV,EAAE,GAAIA,EAAItI;AAAI,KAAO,CACpE,GAAIsI,GAAK5jB,EAAE2O,MAAQiV,EAAE,GAAI,CAAE5jB,EAAE2O,MAAQiV,EAAE,GAAI5jB,EAAE+kB,IAAIpoB,KAAK2e;AAAK,KAAO,CAC9DsI,EAAE,IAAI5jB,EAAE+kB,IAAI3nB,MAChB4C,EAAE8kB,KAAK1nB;AAAO,SAEtBke,EAAKuD,EAAKlpB,KAAKuuB,EAASlkB,EAC5B,CAAE,MAAO4P,GAAK0L,EAAK,CAAC,EAAG1L,GAAImM,EAAI,CAAG,CAAE,QAAU6I,EAAIhB,EAAI,CAAG,CACzD,GAAY,EAARtI,EAAG,GAAQ,MAAMA,EAAG;AAAI,MAAO,CAAEjoB,MAAOioB,EAAG,GAAKA,EAAG,QAAK,EAAQmJ,MAAM,EAC9E,CAtBgDF,CAAK,CAACV,EAAGsB,GAAK,CAAG,CAuBrE;AAwGA,QAvGiB,WACb,SAAS+S,UAAU3gC,EAAI/F,GACnB,IAAI2mC,EAAM5gC,EAAG4gC,IAAKv8B,EAAQrE,EAAGqE,MAAO8G,EAAUnL,EAAGmL,QAC7C/I,EAAKnI,EAAQ4mC,QAASA,OAAiB,IAAPz+B,EAAgB,QAAcA;AAClEhJ,KAAKwnC,IAAMA,EACXxnC,KAAKiL,MAAQA,EACbjL,KAAK+R,QAAUA,EACf/R,KAAK0nC,QAAS,EACVD,IACAznC,KAAKynC,QAAUA,EAEvB,CA0FA,OAzFAF,UAAUrnC,UAAUynC,QAAU,WAC1B,OAAO,kBAAU3nC,UAAM,OAAQ,GAAQ,WACnC,IAAI6B,EAAM+lC;AACV,OAAO,oBAAY5nC,MAAM,SAAU4G,GAC/B,OAAQA,EAAGoX,OACP,KAAK,EAGD,OAFApX,EAAGutB,KAAKnoB,KAAK,CAAC,EAAG,EAAG,CAAE,IACtBnK,EAAO7B,KAAKiL,MAAMyJ,UACI,MAAhB1U,KAAKynC,SACS,iBAAT5lC,GACPA,EAAKiG,OAAS9H,KAAKynC,UAClBznC,KAAK0nC,OACH,CAAC,EAAG1nC,KAAKonC,SADU,CAAC,EAAG;AAElC,KAAK,EAGD,OAFAxgC,EAAGyX,OACHre,KAAK0nC,QAAS,EACP,CAAC;AACZ,KAAK,EAID,OAHI1nC,KAAK0nC,SACL1nC,KAAK0nC,QAAS,GAEX,CAAC,EAAG1nC,KAAK+R,QAAQrQ,MAAMG;AAClC,KAAK,EAKD,OAJA+E,EAAGyX,OACHre,KAAKwnC,IAAI30B,KAAqB,iBAAThR,EACf,2BAA6BA,EAAKiG,OAClC,mBACC,CAAC,EAAG;AACf,KAAK,EAGD,MAFA8/B,EAAUhhC,EAAGyX,OACbre,KAAKwnC,IAAI5xB,MAAM,yBAA0BgyB,GACnCA;AACV,KAAK,EAAG,MAAO,CAAC,GAExB,GACJ,GACJ,EACAL,UAAUrnC,UAAUuU,QAAU,WAC1B,OAAO,kBAAUzU,UAAM,OAAQ,GAAQ,WACnC,IAAI6B,EAAMgmC;AACV,OAAO,oBAAY7nC,MAAM,SAAU4G,GAC/B,OAAQA,EAAGoX,OACP,KAAK,EAED,OADApX,EAAGutB,KAAKnoB,KAAK,CAAC,EAAG,EAAG,CAAE,IACf,CAAC,EAAGhM,KAAK+R,QAAQ9Q;AAC5B,KAAK,EAED,OAAc,OADdY,EAAO+E,EAAGyX,QACkB,CAAC,EAAG,GACzB,CAAC,EAAGre,KAAKiL,MAAMwJ,QAAQ5S;AAClC,KAAK,EAKD,OAJA+E,EAAGyX,OACHre,KAAKwnC,IAAI30B,KAAqB,iBAAThR,EACf,0BAA4BA,EAAKiG,OACjC,kBACC,CAAC,EAAG;AACf,KAAK,EACD9H,KAAKwnC,IAAI30B,KAAK,8BACdjM,EAAGoX,MAAQ;AACf,KAAK,EAAG,MAAO,CAAC,EAAG;AACnB,KAAK,EAGD,MAFA6pB,EAAUjhC,EAAGyX,OACbre,KAAKwnC,IAAI5xB,MAAM,wBAAyBiyB,GAClCA;AACV,KAAK,EAAG,MAAO,CAAC,GAExB,GACJ,GACJ,EACAN,UAAUrnC,UAAUknC,MAAQ,WACxB,OAAO,kBAAUpnC,UAAM,OAAQ,GAAQ,WACnC,IAAI8nC;AACJ,OAAO,oBAAY9nC,MAAM,SAAU4G,GAC/B,OAAQA,EAAGoX,OACP,KAAK,EAED,OADApX,EAAGutB,KAAKnoB,KAAK,CAAC,EAAG,EAAG,CAAE,IACf,CAAC,EAAGhM,KAAK+R,QAAQq1B;AAC5B,KAAK,EAGD,OAFAxgC,EAAGyX,OACHre,KAAKwnC,IAAI30B,KAAK,wBACP,CAAC,EAAG;AACf,KAAK,EAGD,MAFAi1B,EAAUlhC,EAAGyX,OACbre,KAAKwnC,IAAI5xB,MAAM,8BAA+BkyB,GACxCA;AACV,KAAK,EAAG,MAAO,CAAC,GAExB,GACJ,GACJ,EACOP,SACX,CAtGgB;ACnCD,SAAS,aAAC3gC,GACrB,IAAIqE,EAAQrE,EAAGqE;AACf,OAAO,SAAU08B,GACb,IAAIjmC,EAAQuJ,EAAMvJ;AASlB,OARAuJ,EAAMvJ,MAAQ,WAEV,IADA,IAAIiF,EAAO,GACF4B,EAAK,EAAGA,EAAKC,UAAUV,OAAQS,IACpC5B,EAAK4B,GAAMC,UAAUD;AAEzB7G,EAAMuK,MAAMhB,EAAOtE,GACnBghC,GACJ,EACO,WACH18B,EAAMvJ,MAAQA,CAClB,CACJ,CACJ,CCkDA,QAhEe,WACX,SAASqmC,QAAQnhC,EAAI/F,GACjB,IAAI2mC,EAAM5gC,EAAG4gC,IAAKQ,EAAYphC,EAAGohC,UAC7BlkC,EAAQ9D;AACZA,KAAKioC,KAAO,WACHnkC,EAAMokC,UAIU,MAAjBpkC,EAAMyiB,SACN5L,aAAa7W,EAAMyiB,SAEvBziB,EAAMyiB,QAAUjM,WAAWxW,EAAM6jC,QAAS7jC,EAAMokC,WAN5CpkC,EAAM6jC,SAOd,EACA3nC,KAAK2nC,QAAU,WACP7jC,EAAM4jC,QAGV5jC,EAAMkkC,UAAUL,SACpB;AACA,IAAIQ,EAAkBJ,QAAQI,gBAC1Bl9B,EAAQpK,EAAQoK,MAAOi9B,EAAWrnC,EAAQqnC,SAAUl/B,EAAKnI,EAAQunC,QAASA,OAAiB,IAAPp/B,EAAgB,QAAUA;AAClH,GAAKo/B,EAML,OAHApoC,KAAKkoC,SAAuB,MAAZA,EAAmBA,EAAWC,EAC9CnoC,KAAKgoC,UAAYA,EACjBhoC,KAAK0nC,QAAS,EACNU,GACJ,IAAK,QACDpoC,KAAKqoC,UAAYC,aAAa,CAAEr9B,MAAOA,GAAtBq9B,CAA+BtoC,KAAKioC;AACrD;AACJ,IAAK,aACGC,GACAV,EAAIT,KAAK,yDAEb/mC,KAAKkoC,SAAWA,EAChBloC,KAAKqoC,UCtCN,SAAS,gBAACzhC,GACrB,IAAI4gC,EAAM5gC,EAAG4gC,IAAKv8B,EAAQrE,EAAGqE;AAC7B,OAAO,SAAU08B,GAEb,OADAH,EAAIT,KAAK,2EACFuB,aAAa,CAAEr9B,MAAOA,GAAtBq9B,CAA+BX,EAC1C,CACJ,CDgCiCY,CAAgB,CAAEt9B,MAAOA,EAAOu8B,IAAKA,GAArCe,CAA4CvoC,KAAKioC;AAClE;AACJ,QACI,GAAuB,mBAAZG,EAIP,MAAMle,MAAM,gCAAkCke;AAH9CpoC,KAAKqoC,UAAYD,EAAQpoC,KAAKioC,MAM9C,CAeA,OAdAF,QAAQ7nC,UAAUsoC,MAAQ,WACtBxoC,KAAK0nC,QAAS,CAClB,EACAK,QAAQ7nC,UAAUuoC,OAAS,WACvBzoC,KAAK0nC,QAAS,CAClB,EACAK,QAAQ7nC,UAAUuhC,OAAS,WACnBzhC,KAAKqoC,YACLroC,KAAKqoC,YACLroC,KAAKqoC,UAAY,KACjBroC,KAAK0nC,QAAS,EAEtB,EACAK,QAAQI,gBAAkB,IACnBJ,OACX,CA/Dc;AEwDd,QArDsB,WAClB,SAASW,eAAe7nC,GACpB,IAAKA,EAAQoK,MACT,MAAM,IAAIif,MAAM;AAGpB,IAAKrpB,EAAQkR,QACT,MAAM,IAAImY,MAAM;AAGpB,IAAIsd,EAAM,IAAI,EAAI3mC,GACdoK,EAAQ,IAAI,EAAMpK,GAClBkR,EAAU,IAAI,EAAQlR,GACtBmnC,EAAY,IAAI,EAAU,CAAER,IAAKA,EAAKv8B,MAAOA,EAAO8G,QAASA,GAAWlR,GACxEunC,EAAU,IAAI,EAAQ,CAAEZ,IAAKA,EAAKQ,UAAWA,GAAannC;AAC9Db,KAAKwnC,IAAMA,EACXxnC,KAAKiL,MAAQA,EACbjL,KAAK+R,QAAUA,EACf/R,KAAKgoC,UAAYA,EACjBhoC,KAAKooC,QAAUA,CACnB,CA+BA,OA9BAM,eAAexoC,UAAUynC,QAAU,WAC/B,OAAO3nC,KAAKgoC,UAAUL,SAC1B,EACAe,eAAexoC,UAAUuU,QAAU,WAC/B,OAAOzU,KAAKgoC,UAAUvzB,SAC1B,EACAi0B,eAAexoC,UAAUknC,MAAQ,WAC7B,OAAOpnC,KAAKgoC,UAAUZ,OAC1B,EACAsB,eAAexoC,UAAUsoC,MAAQ,WAC7BxoC,KAAKooC,QAAQI,OACjB,EACAE,eAAexoC,UAAUuoC,OAAS,WAC9BzoC,KAAKooC,QAAQK,QACjB,EACAC,eAAexoC,UAAUuhC,OAAS,WAC9BzhC,KAAKooC,QAAQ3G,QACjB,EACAiH,eAAexoC,UAAU2mC,QAAU,SAAU8B,GAEzC,QADc,IAAVA,IAAoBA,GAAQ,IAC5BA,EAIA,OAAO3oC,KAAKwnC,IAAIX;AAHhB7mC,KAAKwnC,IAAIZ,UAKjB,EACA8B,eAAexoC,UAAUonC,QAAU,WAC/B,OAAOtnC,KAAK+R,QAAQu1B,SACxB,EACOoB,cACX,CApDqB,E;;;ACFrB,SAASE,gBAAgBC,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAIrU,UAAU,oCAExB,CAEA,SAASsU,kBAAkBzI,EAAQ0I,GACjC,IAAK,IAAIn8B,EAAI,EAAGA,EAAIm8B,EAAMlhC,OAAQ+E,IAAK,CACrC,IAAIo8B,EAAaD,EAAMn8B;AACvBo8B,EAAW7hB,WAAa6hB,EAAW7hB,aAAc,EACjD6hB,EAAW5hB,cAAe,EACtB,UAAW4hB,IAAYA,EAAW7T,UAAW,GACjDhzB,OAAO+kB,eAAemZ,EAAQ2I,EAAWra,IAAKqa,EAChD,CACF,CAEA,SAASC,aAAaJ,EAAaK,EAAYC,GAG7C,OAFID,GAAYJ,kBAAkBD,EAAY5oC,UAAWipC,GACrDC,GAAaL,kBAAkBD,EAAaM,GACzCN,CACT,CAEA,SAASO,gBAAgBlhC,EAAKymB,EAAKlsB,GAYjC,OAXIksB,KAAOzmB,EACT/F,OAAO+kB,eAAehf,EAAKymB,EAAK,CAC9BlsB,MAAOA,EACP0kB,YAAY,EACZC,cAAc,EACd+N,UAAU,IAGZjtB,EAAIymB,GAAOlsB,EAGNyF,CACT,CAEA,SAASmhC,WAeP,OAdAA,SAAWlnC,OAAOyX,QAAU,SAAUymB,GACpC,IAAK,IAAIzzB,EAAI,EAAGA,EAAIrE,UAAUV,OAAQ+E,IAAK,CACzC,IAAI82B,EAASn7B,UAAUqE;AAEvB,IAAK,IAAI+hB,KAAO+U,EACVvhC,OAAOlC,UAAUmC,eAAe2C,KAAK2+B,EAAQ/U,KAC/C0R,EAAO1R,GAAO+U,EAAO/U,GAG3B,CAEA,OAAO0R,CACT,EAEOgJ,SAASr9B,MAAMjM,KAAMwI,UAC9B,CAEA,SAAS+gC,QAAQ7oC,EAAQ8oC,GACvB,IAAI7jC,EAAOvD,OAAOuD,KAAKjF;AAEvB,GAAI0B,OAAOgxB,sBAAuB,CAChC,IAAIqW,EAAUrnC,OAAOgxB,sBAAsB1yB;AACvC8oC,IAAgBC,EAAUA,EAAQphC,QAAO,SAAUqhC,GACrD,OAAOtnC,OAAOunC,yBAAyBjpC,EAAQgpC,GAAKtiB,UACtD,KACAzhB,EAAKqG,KAAKC,MAAMtG,EAAM8jC,EACxB,CAEA,OAAO9jC,CACT,CAEA,SAASikC,eAAetJ,GACtB,IAAK,IAAIzzB,EAAI,EAAGA,EAAIrE,UAAUV,OAAQ+E,IAAK,CACzC,IAAI82B,EAAyB,MAAhBn7B,UAAUqE,GAAarE,UAAUqE,GAAK,CAAC;AAEhDA,EAAI,EACN08B,QAAQnnC,OAAOuhC,IAAS,GAAM/9B,SAAQ,SAAUgpB,GAC9Cya,gBAAgB/I,EAAQ1R,EAAK+U,EAAO/U,GACtC,IACSxsB,OAAOynC,0BAChBznC,OAAO0nC,iBAAiBxJ,EAAQl+B,OAAOynC,0BAA0BlG,IAEjE4F,QAAQnnC,OAAOuhC,IAAS/9B,SAAQ,SAAUgpB,GACxCxsB,OAAO+kB,eAAemZ,EAAQ1R,EAAKxsB,OAAOunC,yBAAyBhG,EAAQ/U,GAC7E,GAEJ,CAEA,OAAO0R,CACT,CAEA,SAASyJ,UAAUC,EAAUC,GAC3B,GAA0B,mBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAIxV,UAAU;AAGtBuV,EAAS9pC,UAAYkC,OAAOqB,OAAOwmC,GAAcA,EAAW/pC,UAAW,CACrE6yB,YAAa,CACXrwB,MAAOsnC,EACP5U,UAAU,EACV/N,cAAc,KAGd4iB,GAAYC,gBAAgBF,EAAUC,EAC5C,CAEA,SAASE,gBAAgBzZ,GAIvB,OAHAyZ,gBAAkB/nC,OAAOwwB,eAAiBxwB,OAAO6hC,eAAiB,SAASkG,gBAAgBzZ,GACzF,OAAOA,EAAEzG,WAAa7nB,OAAO6hC,eAAevT,EAC9C,EACOyZ,gBAAgBzZ,EACzB,CAEA,SAASwZ,gBAAgBxZ,EAAGrE,GAM1B,OALA6d,gBAAkB9nC,OAAOwwB,gBAAkB,SAASsX,gBAAgBxZ,EAAGrE,GAErE,OADAqE,EAAEzG,UAAYoC,EACPqE,CACT,EAEOwZ,gBAAgBxZ,EAAGrE,EAC5B,CA8BA,SAAS+d,yBAAyBzG,EAAQ0G,GACxC,GAAc,MAAV1G,EAAgB,MAAO,CAAC;AAE5B,IAEI/U,EAAK/hB,EAFLyzB,EAlBN,SAASgK,8BAA8B3G,EAAQ0G,GAC7C,GAAc,MAAV1G,EAAgB,MAAO,CAAC;AAC5B,IAEI/U,EAAK/hB,EAFLyzB,EAAS,CAAC,EACViK,EAAanoC,OAAOuD,KAAKg+B;AAG7B,IAAK92B,EAAI,EAAGA,EAAI09B,EAAWziC,OAAQ+E,IACjC+hB,EAAM2b,EAAW19B,GACbw9B,EAASz8B,QAAQghB,IAAQ,IAC7B0R,EAAO1R,GAAO+U,EAAO/U;AAGvB,OAAO0R,CACT,CAKegK,CAA8B3G,EAAQ0G;AAInD,GAAIjoC,OAAOgxB,sBAAuB,CAChC,IAAIoX,EAAmBpoC,OAAOgxB,sBAAsBuQ;AAEpD,IAAK92B,EAAI,EAAGA,EAAI29B,EAAiB1iC,OAAQ+E,IACvC+hB,EAAM4b,EAAiB39B,GACnBw9B,EAASz8B,QAAQghB,IAAQ,GACxBxsB,OAAOlC,UAAUmzB,qBAAqBruB,KAAK2+B,EAAQ/U,KACxD0R,EAAO1R,GAAO+U,EAAO/U,GAEzB,CAEA,OAAO0R,CACT,CAEA,SAASmK,uBAAuB3sB,GAC9B,QAAa,IAATA,EACF,MAAM,IAAI4sB,eAAe;AAG3B,OAAO5sB,CACT,CAUA,SAAS6sB,aAAaC,GACpB,IAAIC,EAlEN,SAASC,4BACP,GAAuB,oBAAZC,UAA4BA,QAAQC,UAAW,OAAO;AACjE,GAAID,QAAQC,UAAUC,KAAM,OAAO;AACnC,GAAqB,mBAAVC,MAAsB,OAAO;AAExC,IAEE,OADAC,KAAKjrC,UAAUgkC,SAASl/B,KAAK+lC,QAAQC,UAAUG,KAAM,IAAI,WAAa,MAC/D,CACT,CAAE,MAAOlsB,GACP,OAAO,CACT,CACF,CAuDkC6rB;AAEhC,OAAO,SAASM,uBACd,IACIxpC,EADAypC,EAAQlB,gBAAgBS;AAG5B,GAAIC,EAA2B,CAC7B,IAAIS,EAAYnB,gBAAgBnqC,MAAM+yB;AAEtCnxB,EAASmpC,QAAQC,UAAUK,EAAO7iC,UAAW8iC,EAC/C,MACE1pC,EAASypC,EAAMp/B,MAAMjM,KAAMwI;AAG7B,OAvBJ,SAAS+iC,2BAA2BztB,EAAM9Y,GACxC,OAAIA,GAAyB,iBAATA,GAAqC,mBAATA,EAIzCylC,uBAAuB3sB,GAHrB9Y,CAIX,CAiBWumC,CAA2BvrC,KAAM4B,EAC1C,CACF,CAEA,SAAS4pC,eAAeC,EAAK5+B,GAC3B,OAWF,SAAS6+B,gBAAgBD,GACvB,GAAI9oC,MAAMC,QAAQ6oC,GAAM,OAAOA,CACjC,CAbSC,CAAgBD,IAmBzB,SAASE,sBAAsBF,EAAK5+B,GAClC,GAAsB,oBAAXynB,UAA4BA,OAAOC,YAAYnyB,OAAOqpC,IAAO;AACxE,IAAIG,EAAO,GACPC,GAAK,EACL3vB,GAAK,EACLE,OAAKuD;AAET,IACE,IAAK,IAAiCmsB,EAA7BvjC,EAAKkjC,EAAInX,OAAOC,cAAmBsX,GAAMC,EAAKvjC,EAAGyW,QAAQ8U,QAChE8X,EAAK5/B,KAAK8/B,EAAGppC,QAETmK,GAAK++B,EAAK9jC,SAAW+E,GAH8Cg/B,GAAK,GAKhF,CAAE,MAAOhiC,GACPqS,GAAK,EACLE,EAAKvS,CACP,CAAE,QACA,IACOgiC,GAAsB,MAAhBtjC,EAAW,QAAWA,EAAW,QAC9C,CAAE,QACA,GAAI2T,EAAI,MAAME,CAChB,CACF,CAEA,OAAOwvB,CACT,CA5CiCD,CAAsBF,EAAK5+B,IAAMk/B,4BAA4BN,EAAK5+B,IAmEnG,SAASm/B,mBACP,MAAM,IAAIvX,UAAU,4IACtB,CArEyGuX,EACzG,CAEA,SAASC,mBAAmBR,GAC1B,OAGF,SAASS,mBAAmBT,GAC1B,GAAI9oC,MAAMC,QAAQ6oC,GAAM,OAAOU,kBAAkBV,EACnD,CALSS,CAAmBT,IAW5B,SAASW,iBAAiBC,GACxB,GAAsB,oBAAX/X,QAA0BA,OAAOC,YAAYnyB,OAAOiqC,GAAO,OAAO1pC,MAAMyD,KAAKimC,EAC1F,CAboCD,CAAiBX,IAAQM,4BAA4BN,IA2DzF,SAASa,qBACP,MAAM,IAAI7X,UAAU,uIACtB,CA7DiG6X,EACjG,CAyCA,SAASP,4BAA4Brb,EAAG6b,GACtC,GAAK7b,EAAL,CACA,GAAiB,iBAANA,EAAgB,OAAOyb,kBAAkBzb,EAAG6b;AACvD,IAAIrZ,EAAI9wB,OAAOlC,UAAUgkC,SAASl/B,KAAK0rB,GAAG3mB,MAAM,GAAI;AAEpD,MADU,WAANmpB,GAAkBxC,EAAEqC,cAAaG,EAAIxC,EAAEqC,YAAYxmB,MAC7C,QAAN2mB,GAAqB,QAANA,EAAoBvwB,MAAMyD,KAAKsqB,GACxC,cAANwC,GAAqB,2CAA2C3H,KAAK2H,GAAWiZ,kBAAkBzb,EAAG6b,QAAzG,CALc,CAMhB,CAEA,SAASJ,kBAAkBV,EAAKe,IACnB,MAAPA,GAAeA,EAAMf,EAAI3jC,UAAQ0kC,EAAMf,EAAI3jC;AAE/C,IAAK,IAAI+E,EAAI,EAAG4/B,EAAO,IAAI9pC,MAAM6pC,GAAM3/B,EAAI2/B,EAAK3/B,IAAK4/B,EAAK5/B,GAAK4+B,EAAI5+B;AAEnE,OAAO4/B,CACT,CAuEA,IAAInG,EAJJ,SAASoG,qBAAqBpnB,EAAIqnB,GACjC,OAAiCrnB,EAA1BqnB,EAAS,CAAEC,QAAS,CAAC,GAAgBD,EAAOC,SAAUD,EAAOC,OACrE,CAEYF,EAAqB,SAAUC,GAiC3C,SAASE,eAAelmC,EAAMsD,GAC5B,IAAIsC,EAAOtC,EAAO6iC;AAElB,GAAI7iC,EAAO8iC,UAAW,CACpB,IAAI74B,EAAIjK,EAAO+iC,MAEXrG,EAAS,KAAKtb,OADF,OAAYnX,EAAI,EAAIA,EAAI,OAASA,GACb,OAAOmX,OAAO9e,EAAM;AACxD5F,EAAK,GAAKggC,EAAShgC,EAAK,GAAG2kB,MAAM,MAAM+D,KAAK,KAAOsX,EACrD,MACEhgC,EAAK,GAAK4F,EAAO,IAAM5F,EAAK,EAEhC,CAOA,SAASsmC,kBAAkBtmC,EAAMsD,GAG/B,GAFAtD,EAAK,IAAMsD,EAAO8iC,UAAY,KAAO,IAAM9iC,EAAO6iC,UAE7C7iC,EAAO8iC,UAAZ,CAIA,IAAI74B,EAAI,UAAYjK,EAAO+iC,MAIvBxc,EAAQ,EACR0c,EAAQ;AACZvmC,EAAK,GAAGO,QAAQ,eAAe,SAAU1E,GACzB,OAAVA,IAIJguB,IAEc,OAAVhuB,IAGF0qC,EAAQ1c,GAEZ,IACA7pB,EAAKwmC,OAAOD,EAAO,EAAGh5B,EArBtB,CAsBF,CAEA,IAAIk5B,EAAgB,CAAC,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW;AA8C90B,SAASC,eACP,IAAI1G,EAASn+B,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,KAC7EyB,EAASzB,UAAUV,OAAS,EAAIU,UAAU,QAAKmX;AACnD,OAAO,WACL,IAAK,IAAI2tB,EAAO9kC,UAAUV,OAAQnB,EAAO,IAAIhE,MAAM2qC,GAAO/L,EAAO,EAAGA,EAAO+L,EAAM/L,IAC/E56B,EAAK46B,GAAQ/4B,UAAU+4B;AAGrBoF,GACFhgC,EAAK4mC,QAAQ5G;AAID18B,EAAOujC,WAAWliB,MAAM,KAAKxe,KAAI,SAAUggC,GAEvD,MAAwC,MAApCA,EAAUA,EAAUhlC,OAAS,GACxB,IAAI2lC,OAAO,IAAMX,EAAU/iC,MAAM,EAAG+iC,EAAUhlC,OAAS,GAA5C,OAGb,IAAI2lC,OAAO,IAAMX,EAAY,IACtC,IAEoBn1B,MAAK,SAAU+1B,GACjC,OAAOA,EAAMniB,KAAKob,EACpB,IAtIJ,SAASgH,YAAYb,EAAWc,GAG9B,IAFA,IAAIC,EAAO,EAEFhhC,EAAI,EAAGA,EAAIigC,EAAUhlC,OAAQ+E,IACpCghC,GAAQA,GAAQ,GAAKA,EAAOf,EAAUgB,WAAWjhC,GACjDghC,GAAQ;AAGV,OAAOD,EAAOnc,KAAKsc,IAAIF,GAAQD,EAAO9lC,OACxC,CA+Ha6lC,CAAYhH,EAAQ18B,EAAO2jC,QAEvB3jC,EAAO8iC,SAUtB,CACF,CAeuB,oBAAZiB,SAA4C,aAAjBA,QAAQpY,OAA2C,IAApBoY,QAAQC,SAAoBD,QAAQE,OACvGvB,EAAOC,QAVT,SAASuB,cAAcxH,GACrB,OAAO0G,aAAa1G,EApFtB,SAASyH,cACP,IAAIZ;AAEJ,IACEA,EAAaa,aAAanH,QAAQ,QACpC,CAAE,MAAOtxB,GAET,CAOA,OAJK43B,GAAiC,oBAAZQ,SAA2B,QAASA,UAC5DR,EAAaQ,QAAQM,IAAIC,OAGpB,CACLf,WAAYA,GAAc,GAC1BI,OAAQR,EACRL,WAAW,EACXyB,WAAYvB,kBAEhB,CAgE8BmB,GAC9B,EAUEzB,EAAOC,QAhBT,SAAS6B,WAAW9H,GAClB,OAAO0G,aAAa1G,EAnDtB,SAAS+H,WACP,MAAO,CACLlB,WAAYQ,QAAQM,IAAIC,OAAS,GACjCX,OAAQ,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GACxBb,WAAW,EACXyB,WAAY3B,eAEhB,CA4C8B6B,GAC9B,CAgBA,IAEIC,EAAUrI,EAAM,qBAGhBsI,EAAW,SAASA,WACtB,IAAI1sC,EAAOsG,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK;AAC/E,OAAO4H,OAAOlQ,UAAUgH,QAAQlC,KAAK9C,EAAM,eAAgB,OAAOopB,MAAM,aAAajjB,OAAOk1B,QAC9F,EAIIsR,EAAQ,SAASA,MAAM1mC,GACzB,IAAIjG,EAAOsG,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,GAC3E23B,EAAe33B,UAAUV,OAAS,EAAIU,UAAU,QAAKmX,EACrD/d,EAASwO,OAAOlQ,UAAUgH,QAAQlC,KAAK9C,EAAM,eAAgB,OAAOopB,MAAM,aAAajjB,OAAOk1B,SAASpS,QAAO,SAAU2jB,EAAKlgB,GAC/H,OAAOkgB,QAAoCA,EAAIlgB,GAAOkgB,CACxD,GAAG3mC;AACH,YAAkBwX,IAAX/d,GAAwBA,IAAWuG,EAAMg4B,EAAev+B,CACjE,EAQImtC,EAAa,SAASA,WAAW7sC,GACnC,MAAO,IAAImpB,OAAOnpB,GAAMgF,QAAQ,aAAc,MAAMA,QAAQ,KAAM,GACpE,EAUI8nC,EAAQ,SAASA,MAAM7mC,EAAKjG,GAC9B,IAAI+sC,EAAQF,EAAW7sC,GACnB0sB,EANQ,SAASsgB,QAAQhtC,GAC7B,OAAOA,EAAKgF,QAAQ6nC,EAAW7sC,GAAO,IAAIgF,QAAQ,KAAM,GAC1D,CAIYgoC,CAAQhtC,GAGditC,EAAYF,EAAQ9qC,IAAIgE,EAAK8mC,GAAS9mC;AAE1C,SAAUgnC,IAAa/sC,OAAOC,eAAe2C,KAAKmqC,EAAWvgB,EAAI1nB,QAAQ,WAAY,OACvF,EAIIkoC,EAAQ,SAASA,MAAMjnC,GACzB,IAAIjG,EAAOsG,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,GAC3E67B,EAAM77B,UAAUV,OAAS,EAAIU,UAAU,QAAKmX;AAChDvP,OAAOlQ,UAAUgH,QAAQlC,KAAK9C,EAAM,eAAgB,OAAOopB,MAAM,aAAajjB,OAAOk1B,SAASpS,QAAO,SAAU2jB,EAAKlgB,EAAK/hB,EAAG4+B,GAG1H,OAAI5+B,IAAM4+B,EAAI3jC,OAAS,GACrBgnC,EAAIlgB,GAAOyV,EACJyK,EAAIlgB,SAIIjP,IAAbmvB,EAAIlgB,IACFgP,OAAOyR,WAAW5D,EAAI5+B,EAAI,IAC5BiiC,EAAIlgB,GAAO,GAEXkgB,EAAIlgB,GAAO,CAAC,EAGPkgB,EAAIlgB,KAITgP,OAAOyR,WAAW5D,EAAI5+B,EAAI,MAAQlK,MAAMC,QAAQksC,EAAIlgB,MACtDkgB,EAAIlgB,GAAO,IAKNkgB,EAAIlgB,GACb,GAAGzmB,EACL,EAIImnC,EAAU,SAASA,QAAQnnC,GAC7B,IAAIjG,EAAOsG,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,GAC3E+mC,GAAQ;AAiBZ,OAhBAn/B,OAAOlQ,UAAUgH,QAAQlC,KAAK9C,EAAM,eAAgB,OAAOopB,MAAM,aAAajjB,OAAOk1B,SAASpS,QAAO,SAAU2jB,EAAKlgB,EAAK/hB,EAAG4+B,GAE1H,YAAY9rB,IAARmvB,EACKA,EAILjiC,IAAM4+B,EAAI3jC,OAAS,UACdgnC,EAAIlgB,GACX2gB,GAAQ,EACDT,EAAIlgB,IAINkgB,EAAIlgB,EACb,GAAGzmB,GACIonC,CACT,EAoCIC,EAAkB,SAASA,gBAAgBttC,GAC7C,IAAIutC,EAAYb,EAAS1sC;AACzB,OAAO07B,OAAOyR,WAAWI,EAAUA,EAAU3nC,OAAS,GACxD,EAEI4nC,EAAyB,WAC3B,SAASA,YACP9G,gBAAgB5oC,KAAM0vC,UACxB,CAyFA,OAvFAxG,aAAawG,UAAW,KAAM,CAAC,CAC7B9gB,IAAK,QACLlsB,MAAO,SAASuoB,MAAMvqB,GACpB,OAAmC,IArB1B,SAASivC,WACtB,IAAIxnC,EAAMK,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,CAAC;AAE/E,OADYpG,OAAOuD,KAAKwC,GACX2E,KAAI,SAAU8hB,GACzB,OAAOzmB,EAAIymB,EACb,GACF,CAea+gB,CAASjvC,GAAQoH,MAC1B,GACC,CACD8mB,IAAK,MACLlsB,MAAO,SAASyB,IAAIzD,EAAQwB,GAG1B,OAFU2sC,EAAMnuC,EAAQwB,EAG1B,GACC,CACD0sB,IAAK,MACLlsB,MAAO,SAAS6B,IAAI7D,EAAQwB,GAC1B,OAAO8sC,EAAMtuC,EAAQwB,EACvB,GACC,CACD0sB,IAAK,MACLlsB,MAAO,SAASiK,IAAIjM,EAAQwB,EAAMQ,GAChC,QAAcid,IAAVjd,EACFisC,EAAQ,UAAWzsC,EAAMQ,GACzB0sC,EAAM1uC,EAAQwB,EAAMQ;KASpB,GAAI8sC,EAAgBttC,SAAyCyd,IAAhC+vB,UAAUvrC,IAAIzD,EAAQwB,GAAqB,CACtEysC,EAAQ,uBAAwBzsC,EAAM,gBACtCktC,EAAM1uC,EAAQwB,OAAMyd;AACpB,IAAI8vB,EAAYb,EAAS1sC;AAEzBmgB,QAAQ3hB,EADR+uC,EAAYA,EAAU1lC,MAAM,EAAG0lC,EAAU3nC,OAAS,GAEpD,MAKU0nC,EAAgBttC,SAAyCyd,IAAhC+vB,UAAUvrC,IAAIzD,EAAQwB,KACrDysC,EAAQ,wBAAyBzsC,EAAM,0BACvCwtC,UAAkB,OAAEhvC,EAAQwB,GAGpC,GACC,CACD0sB,IAAK,SACLlsB,MAAO,SAASktC,QAAQlvC,EAAQwB,GAC9BysC,EAAQ,SAAUzsC,GAEdstC,EAAgBttC,IAClBysC,EAAQ,QAASzsC,GAEjBlC,KAAK6vC,QAAQnvC,EAAQwB,IAErBotC,EAAQ5uC,EAAQwB;AAGlB,IAAIutC,EAAYb,EAAS1sC;AAEzBmgB,QAAQ3hB,EADR+uC,EAAYA,EAAU1lC,MAAM,EAAG0lC,EAAU3nC,OAAS,GAEpD,GAEC,CACD8mB,IAAK,UACLlsB,MAAO,SAASmtC,QAAQnvC,EAAQwB,GAE9B,IAAIutC,EAAYb,EAAS1sC,GAErBsuB,EAAQif,EAAUA,EAAU3nC,OAAS;AACzC2nC,EAAYA,EAAU1lC,MAAM,EAAG0lC,EAAU3nC,OAAS,GAClD6mC,EAAQ,eAAgBc,EAAW,QAASjf;AAE5C,IAAIib,EAAMoD,EAAMnuC,EAAQ+uC;AACxBd,EAAQ,QAASlD,GAEb9oC,MAAMC,QAAQ6oC,IAzHT,SAASqE,SAAS3nC,GAC/B,IACI4nC,EADA7tC,EAAOsG,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK;AAE/E4H,OAAOlQ,UAAUgH,QAAQlC,KAAK9C,EAAM,eAAgB,OAAOopB,MAAM,aAAajjB,OAAOk1B,SAASpS,QAAO,SAAU2jB,EAAKlgB,EAAK/hB,EAAG4+B,GAE1H,YAAY9rB,IAARmvB,EACKA,EAILjiC,IAAM4+B,EAAI3jC,OAAS,GAAKnF,MAAMC,QAAQksC,IAExCiB,EAASjB,EAAI3B,OAAOve,EAAK,GAClBkgB,EAAIlgB,IAINkgB,EAAIlgB,EACb,GAAGzmB,EAEL,CAsGQ2nC,CAASrE,EAAKjb,GAGhBnO,QAAQ3hB,EAAQ+uC,EAClB,KAGKC,SACT,CA7F6B;AA+F7B,SAASrtB,QAAQla,EAAKjG,GAGpB,GAAoB,IAAhBA,EAAK4F,OAAT,CAIA,IAAIpH,EAASmuC,EAAM1mC,EAAKjG,IAMpBS,MAAMC,QAAQlC,GAAUA,EAAO+vB,OAAM,SAAUxR,GACjD,OAAY,MAALA,CACT,IAAgC,OAA3B9T,KAAKC,UAAU1K,KAClB4uC,EAAQnnC,EAAKjG,GAIfmgB,QAAQla,EAAKjG,EAAK6H,MAAM,EAAG7H,EAAK4F,OAAS,GAfzC,CAgBF,CAEA,IAAIkoC,EAAmC,gBAAoB,CACzDC,SAAU,SAASA,WAAY,EAC/BC,WAAY,SAASA,aAAc,EACnCC,SAAU,SAASA,WAAY,EAC/BC,WAAY,SAASA,aAAc,EACnCC,SAAU,SAASA,WAAY,EAC/B1yB,OAAQ,SAASA,SAAU,EAC3B2yB,SAAU,SAASA,WAAY,EAC/BC,cAAe,SAASA,gBAAiB,EACzCC,gBAAiB,SAASA,kBAAmB,IAE3CC,EAAgC,gBAAoB,CAAC,GACrDC,EAA8B,gBAAoB,CACpDC,aAAc,SAASA,eAAgB,EACvCC,UAAW,SAASA,YAAa,EACjCza,WAAY,SAASA,aACnB,MAAO,CAAC,CACV,EACA0a,gBAAiB,SAASA,kBAAmB,EAC7CL,gBAAiB,SAASA,kBAAmB,EAC7CM,iBAAkB,SAASA,mBAAoB,EAC/CC,cAAe,SAASA,gBAAiB,EACzCC,iBAAkB,SAASA,mBAAoB,IAE7CC,EAA4B,kBAC5BC,EAAsC,kBACtCC,EAAoC,kBACpCC,EAAwC,kBACxCC,EAA0C,kBAG1CC,EAAoC;AAExC,SAASC,aAEP,OADc,IAAArW,YAAWwV,EAE3B,CAIA,SAASc,mBAAmBrgB,GAC1B,IAAIxsB,GAAM,IAAA62B,UACNiW,GAAU,IAAAjW,SAAO,GAGjBkW,EAAalG,gBADD,IAAAvP,UAAS9K,GACkB,GACvCpM,EAAQ2sB,EAAW,GACnBC,EAAWD,EAAW;AAE1B/sC,EAAI+2B,QAAU3W;AAgBd,OALA,IAAA+W,YAAU,WACR,OAAO,WACL2V,EAAQ/V,SAAU,CACpB,CACF,GAAG,IACI,CAAC3W,EAdE,SAASpY,IAAIjK,GACrBiC,EAAI+2B,QAAUh5B,EACV+uC,EAAQ/V,SAASiW,EAASjvC,EAChC,EAEU,SAASyB,MACjB,OAAOQ,EAAI+2B,OACb,EAQF,CAEA,IAQIkW,EAAkB,SAASA,gBAAgBC,GAC7C,IAAIv2B,EAAS,CAAC;AAEd,GAAIu2B,EAASC,MAAO,CAClB,GAA8B,IAA1BD,EAASC,MAAMhqC,OAGjB,YADA4nC,EAAU/iC,IAAI2O,EAAQu2B,EAAS3vC,KAAM2vC,EAAS5vC;AAIhD,IACI8vC,EADAC,EArlBR,SAASC,2BAA2BvhB,EAAGwhB,GACrC,IAAIC;AAEJ,GAAsB,oBAAX7d,QAAgD,MAAtB5D,EAAE4D,OAAOC,UAAmB,CAC/D,GAAI5xB,MAAMC,QAAQ8tB,KAAOyhB,EAAKpG,4BAA4Brb,KAAOwhB,GAAkBxhB,GAAyB,iBAAbA,EAAE5oB,OAAqB,CAChHqqC,IAAIzhB,EAAIyhB;AACZ,IAAItlC,EAAI,EAEJulC,EAAI,WAAa;AAErB,MAAO,CACL5+B,EAAG4+B,EACHlf,EAAG,WACD,OAAIrmB,GAAK6jB,EAAE5oB,OAAe,CACxBgsB,MAAM,GAED,CACLA,MAAM,EACNpxB,MAAOguB,EAAE7jB,KAEb,EACAoS,EAAG,SAAUA,GACX,MAAMA,CACR,EACAgV,EAAGme,EAEP,CAEA,MAAM,IAAI3d,UAAU,wIACtB,CAEA,IAEI5qB,EAFAwoC,GAAmB,EACnBC,GAAS;AAEb,MAAO,CACL9+B,EAAG,WACD2+B,EAAKzhB,EAAE4D,OAAOC,WAChB,EACArB,EAAG,WACD,IAAIU,EAAOue,EAAGnzB;AAEd,OADAqzB,EAAmBze,EAAKE,KACjBF,CACT,EACA3U,EAAG,SAAUA,GACXqzB,GAAS,EACTzoC,EAAMoV,CACR,EACAgV,EAAG,WACD,IACOoe,GAAiC,MAAbF,EAAGI,QAAgBJ,EAAGI,QACjD,CAAE,QACA,GAAID,EAAQ,MAAMzoC,CACpB,CACF,EAEJ,CA8hBoBooC,CAA2BJ,EAASC;AAGpD,IACE,IAAKE,EAAUx+B,MAAOu+B,EAAQC,EAAU9e,KAAKY,MAAO,CAClD,IAAIjqB,EAAMkoC,EAAMrvC;AAEXgtC,EAAUvrC,IAAImX,EAAQzR,EAAI3H,OAE7BwtC,EAAU/iC,IAAI2O,EAAQzR,EAAI3H,KAAM2H,EAAI5H,QAExC,CACF,CAAE,MAAO4H,GACPmoC,EAAU/yB,EAAEpV,EACd,CAAE,QACAmoC,EAAU/d,GACZ,CACF,CAEA,OAAO3Y,CACT,EAyDIk3B,EAAS,SAASA,SACpB,MAAO,uCAAuCtrC,QAAQ,SAAS,SAAUgN,GACvE,IAAI0gB,EAAoB,GAAhBnD,KAAKG,SAAgB;AAE7B,OADa,KAAL1d,EAAW0gB,EAAQ,EAAJA,EAAU,GACxBsP,SAAS,GACpB,GACF,EACIuO,EAA2B,SAASA,yBAAyBC,EAAcvvC,EAAUwjC,GACvF,IAAIgM,EAAYxvC,EAAS,cACrByvC,EAAgBzvC,EAAS,kBACzB0vC,EAAa1vC,EAAS,eACtB2vC,EAAW3vC,EAAS,aACpB4vC,EAAU5vC,EAAS,YACnB6vC,EAAQ7vC,EAAS6vC,MACjBC,EAAQ9vC,EAAS8vC,MACjBC,EAAa/vC,EAAe,KAC5B6a,EAAQ7a,EAASgwC,MACjBzhB,EAAMvuB,EAASiwC,QACf/hB,EAAMluB,EAASkwC,QACfC,EAAYnwC,EAASmwC,UACrBC,EAAYpwC,EAASowC,UACrBC,EAAUrwC,EAASqwC,QACnB5d,EAAOzyB,EAASyyB,KAChB6d,EAAgBtwC,EAASuwC,WAEzBvyC,EAAKqxC;AAELK,GAAcA,EAAW1xC,KAC3BA,EAAK0xC,EAAW1xC;AAGlB,IAAI2B,EAAQ,CACV6wC,cAAehB,EACf7vC,MAAO6jC,EAAS,GAAGtb,OAAOsb,EAAQ,KAAKtb,OAAOqnB,GAAgBA,EAC9D9c,KAAMA,EACNkd,SAAUA,EACVC,QAASA,EACTW,WAAqB,WAAT9d,EAAoB6d,OAAgB9zB,EAChDszB,MAAgB,UAATrd,EAAmBqd,OAAQtzB,EAClCqpB,MAAOY,eAAeA,eAAe,CACnC5rB,MAAOA,EACP7c,GAAIA,EACJuwB,IAAKA,EACLL,IAAKA,EACLiiB,UAAWA,EACXC,UAAWA,EACXC,QAASA,GACRZ,GAAgBC;AAGrB,GAAIG,EAAO,CACT,IAAInyC,EAAUsC,EAAS6vC,MAAMlmC,KAAI,SAAU8mC,GACzC,IAAIC,EAAqBD,EAAO,eAC5Bf,OAAoC,IAAvBgB,EAAgC,CAAC,EAAIA;AACtD,OAAOjK,eAAe,CACpBlnC,MAAOkxC,EAAc,MACrB51B,MAAO41B,EAAOT,OACbN,EACL;AACA/vC,EAAMkmC,MAAMnoC,QAAUA,CACxB,CAEA,GAAIqyC,EAAY,CACd,IAAIY,EAAW3wC,EAAe,KAAE2J,KAAI,SAAUu3B,GAC5C,MAAO,CACL3hC,MAAO2hC,EACPrmB,MAAOqmB,EAEX;AAEAvhC,EAAMkmC,MAAMnoC,QAAUizC,CACxB,CAEA,GAAIb,GAASA,EAAMD,MAAO,CACxB,IAAIe,EAAYd,EAAMD,MAAMlmC,KAAI,SAAU8mC,GACxC,IAAII,EAAsBJ,EAAO,eAC7Bf,OAAqC,IAAxBmB,EAAiC,CAAC,EAAIA;AACvD,OAAOpK,eAAe,CACpBlnC,MAAOkxC,EAAc,MACrB51B,MAAO41B,EAAOT,OACbN,EACL;AAEA/vC,EAAMkmC,MAAMnoC,QAAUkzC,CACxB,CAEA,OAAOjxC,CACT,EAmGImxC,EAAiB,SAASA,eAAevxC,EAAOwxC,GAGlD,IAAKxxC,EACH,MAAO,CACLA,MAAOA,EACPyxC,OAAQ;AAKZ,IAAIC,EA3Da,SAASC,aAAaD,EAAW1xC,GAElD,GAAyB,iBAAd0xC,EACT,OAAOA,EAAU9oB,MAAM,IAAIxe,KAAI,SAAUwnC,GACvC,MAAc,MAAVA,EACK,KAGK,MAAVA,EACK,OAGFA,CACT;AAIF,GAAyB,mBAAdF,EACT,OAAOA,EAAU1xC;AAGnB,GAAIC,MAAMC,QAAQwxC,GAChB,OAAOA;AAIT,MAAM,IAAIlqB,MAAM,+CAClB,CAgCkBmqB,CAAaH,EAAOxxC,GAahC6xC,EAAeH,EAAUI,WAAU,SAAUhgB,GAC/C,MAAmB,iBAALA,CAChB,IAEIigB,EAAcL,EAAUtsC,OAASmkC,mBAAmBmI,GAAWM,UAAUF,WAAU,SAAUhgB,GAC/F,MAAmB,iBAALA,CAChB,IAGImgB,EAAY,GAEZC,EAAQlyC,EAAM4oB,MAAM,IAEpBupB,EAAS,EACTlkB,EAAQ,EAGRmkB,EA5Dc,SAASC,cAAcjgB,EAAGnC,GAM5C,IALA,IAAI9lB,EAAI,EACJmoC,GAAM,EACNC,GAAW,EAGRA,GAAYpoC,EAAIioB,EAAEhtB,QACnBgtB,EAAEjoB,IAAM8lB,EAAE9lB,GACZmoC,EAAKnoC,EAELooC,GAAW,EAGbpoC,GAAQ;AAGV,OAAOmoC,CACT,CA2CmBD,CAAcX,EAAUrqC,MAAM,EAAGwqC,GAAeK,EAAM7qC,MAAM,EAAGwqC;AAE5EO,GAAc,IAEhBD,EAASC,EAAa,EACtBH,EAAYA,EAAUtpB,OAAO+oB,EAAUrqC,MAAM,EAAG+qC,EAAa,IAC7DnkB,EAAQmkB,EAAa,GAInBA,EAAa,IAEfH,EAAYA,EAAUtpB,OAAO+oB,EAAUrqC,MAAM,EAAGwqC,IAChD5jB,EAAQ4jB;AAGV,IAAK,IAAI1nC,EAAI8jB,EAAO9jB,EAAIunC,EAAUtsC,OAAQ+E,IAAK,CAE7C,IAAIqoC,EAAUd,EAAUvnC;AAGxB,GAAIgoC,GAAUD,EAAM9sC,OAAQ,CAE1B,IAAIqtC,EAAUP,EAAMC,GAEhBryC,EAA2B,iBAAZ0yC,EAAuBA,IAAYC,EAAUD,EAAQ3pB,KAAK4pB;AAGzE3yC,GAA4B,iBAAZ0yC,GAClBP,EAAU3oC,KAAKkpC,GAEfL,GAAkB,GAGVryC,GAA4B,iBAAZ0yC,EAMf1yC,GAA2B,iBAAX0yC,GACrBP,EAAU3oC,KAAKmpC,GACfN,GAAkB,GAGVryC,GAA2B,iBAAX0yC,IAEtBL,GAAkB,EAClBhoC,GAAQ,GAXRgoC,GAAUD,EAAM9sC,QAAQ6sC,EAAU3oC,KAAKkpC,EAajD,KAAO,CAEL,KAAuB,iBAAZA,GAAwBroC,GAAK4nC,GAItC;AAHAE,EAAU3oC,KAAKkpC,EAKnB,CACF,CAEA,MAAO,CACLxyC,MAAOiyC,EAAUtlB,KAAK,IACtB8kB,OAAQzxC,EAAQiyC,EAAU7sC,OAASpF,EAAMoF,OAAS,EAEtD,EAMIstC,EAA8C,oBAAXzwB,aAAqD,IAApBA,OAAOnkB,eAAqE,IAAlCmkB,OAAOnkB,SAAS60C,cAAgC,EAAAC,gBAAkB,EAAAxZ,UAEhLyZ,EAASjP,EAAM,uBAEfkP,EAAkB,SAASA,gBAAgB9yC,EAAO+yC,EAAMrB,EAAW3d,GACrE,GAAa,MAAT/zB,EAEF,OAAI+yC,EACKA,EAAK/yC,GAGV0xC,IAAc3d,EACNwd,EAAevxC,EAAO0xC,GACrB1xC,MAGNA,CAKX,EA4IIgzC,EAAmB,SAASA,iBAAiBhzC,EAAOizC,GACtD,GAAIA,IAAsB,MAATjzC,GAA2B,KAAVA,GAChC,MAA2B,iBAAbizC,EAAwBA,EAAW,wBAErD;AAEA,SAASC,WACP,IAAIC,EAAartC,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAClFstC,EAAUttC,UAAUV,OAAS,EAAIU,UAAU,QAAKmX,EAGhD7c,EAAQ+yC,EAAW/yC,MACnBizC,EAAiBF,EAAWG,SAC5BC,EAAgBJ,EAAWI,cAC3BC,EAAmBL,EAAWK,iBAC9BT,EAAOI,EAAWJ,KAClBU,EAAuBN,EAAWM,qBAClCC,EAASP,EAAWO,OACpB1mB,EAAQmmB,EAAWnmB,MACnB0kB,EAAYyB,EAAWzB,UACvB3d,EAASof,EAAWpf,OACpB4f,EAAeR,EAAWQ,aAC1BC,EAAmBT,EAAWS,iBAC9BC,EAAiBV,EAAWU,eAC5BC,EAAkBX,EAAWW,gBAC7BC,EAAsBZ,EAAWY,oBACjCC,EAAab,EAAWa,WACxBC,EAAmBd,EAAWc,iBAC9BC,EAAgBf,EAAWe,cAC3Br8B,EAASs7B,EAAWt7B,OACpBs8B,EAAYhB,EAAWgB,UACvBC,EAAiBjB,EAAWiB,eAC5BxQ,EAAQuP,EAAWvP,MACnByQ,EAASlB,EAAWkB,OACpBnjB,EAAOiiB,EAAWjiB,KAClBojB,EAAYnB,EAAWmB,UACvBC,EAAWpB,EAAWoB,SACtBC,EAAWrB,EAAWqB,SACtBC,EAAStB,EAAWsB,OACpBC,EAAiBvB,EAAWuB,eAC5BC,EAAexB,EAAWyB,SAC1B3B,EAAWE,EAAWF,SACtB4B,EAAsB1B,EAAW0B,oBACjCC,EAAYpN,yBAAyByL,EAAY,CAAC,QAAS,WAAY,gBAAiB,mBAAoB,OAAQ,uBAAwB,SAAU,QAAS,YAAa,SAAU,eAAgB,mBAAoB,iBAAkB,kBAAmB,sBAAuB,aAAc,mBAAoB,gBAAiB,SAAU,YAAa,iBAAkB,QAAS,SAAU,OAAQ,YAAa,WAAY,WAAY,SAAU,iBAAkB,WAAY,WAAY,wBAKte4B,EADajM,gBADD,IAAAvP,UAASuW,KACkB,GAClB,GAGrBh0B,GAAU,IAAA0c,YAAW8U,GAErB0H,GAAmB,IAAAxc,YAAWoW,GAC9BqG,EAAcD,GAAoBH,EAElCK,EAAUrG,aAEVsG,GAAc,IAAArc,UAEdsc,GAAkB,IAAAtc,SAAO,GAEzBuc,GAAiB,IAAAvc;AAEjB4b,IACF54B,EAAU44B,EAAe54B,QACzBo5B,EAAUR,EAAeY;AAI3B,IAaIC,GACAC,GAdAlC,GAjM2B,SAASmC,2BAA2BpC,EAAgBG,EAAkBkC,GACrG,IAAIzC,EAAWyC,EAAKzC;AAGpB,OAAII,GAAkBG,EACb,SAAU7R,EAAKj8B,GACpB,OAAI8tC,EA1Xa,SAASmC,iBAAiBC,EAAQ51C,GACvD,IACE41C,EAAOC,aAAa71C,EAAO,CACzB81C,YAAY,GAEhB,CAAE,MAAOv5B,GACP,OAhBiB,SAASw5B,eAAe5G,GAC3C,GAAIA,EAASC,MAAO,CAClB,GAA8B,IAA1BD,EAASC,MAAMhqC,OACjB;AAIF,OADU+pC,EAASC,MAAM,GACd7vC,OACb,CACF,CAOWw2C,CAAex5B,EACxB,CACF,CAmXeo5B,CAAiBnC,EAAkB7R,GAGxC0R,EACKA,EAAe1R,EAAKj8B,QAD7B,CAGF,EAGEutC,EACK,SAAUtR,GACf,OAAOqR,EAAiBrR,EAAKsR,EAC/B,OAHF,CAKF,CA4KiBwC,CAA2BpC,EAAgBG,EAAkB,CAC1EP,SAAUA,IAOR+C,GADalN,gBAHA,IAAAvP,WAAS,WACxB,OAAOzd,EAAQgyB,gBAAgB1tC,EACjC,IAC4C,GACV,GAG9B61C,GAAaf,EAAQ7G,cAAcjuC,IAKlC+zC,GAAac,IAAgBgB,IAChCpD,EAAO,iBAAiBlqB,OAAO9e,GAAM,iBAAkBosC,IACvDV,GAAUU,GAAWj2C,MACrBw1C,GAAcS,GAAWC,QAEzBhB,EAAQ5G,iBAAiBzkC,KAEzB0rC,GADyBt4B,MAAhB02B,EACCA,EAEAqC;AAIZ,IACIG,GAAuBrN,eADDgG,mBAAmBgE,EAAgByC,GAASxC,EAAMrB,EAAW3d,IACxB,GAC3D/zB,GAAQm2C,GAAqB,GAC7BC,GAASD,GAAqB,GAC9BE,GAAYF,GAAqB,GAGjCG,GAAuBxN,eADAgG,mBAAmBgF,EAAkBR,GAAStzC,SAASid,GAClB,GAC5D/J,GAAQojC,GAAqB,GAC7BC,GAASD,GAAqB,GAC9BE,GAASF,GAAqB,GAG9BG,GAAuB3N,eADAgG,mBAAmB0G,IACkB,GAC5DU,GAAUO,GAAqB,GAC/BC,GAAWD,GAAqB,GAChCE,GAAWF,GAAqB,GAKhCG,GAAuB9N,eADAgG,mBAAmB,GACkB,GAE5D+H,IADSD,GAAqB,GAClBA,GAAqB,IACjCE,GAAYF,GAAqB,GAGjCG,GAAwBjO,eADDgG,mBAAmB,GACmB,GAE7DkI,IADeD,GAAsB,GACnBA,GAAsB,IACxCE,GAAkBF,GAAsB,GAExCG,IAAa,IAAA3d,WAAS,WACxB,OA9QiB,SAAS4d,eAAen3C,EAAO0zC,EAAQ1mB,EAAO0kB,GAEjE,OAAIgC,GAAU1mB,EACL0mB,EAAO1zC,GAIZ0xC,EACQH,EAAevxC,EAAO0xC,GACrB1xC,MAGNA,CACT,CAiQWm3C,CAAen3C,GAAO0zC,EAAQ1mB,EAAO0kB,EAC9C,IACI0F,GAAatO,eAAeoO,GAAY,GACxCG,GAAcD,GAAW,GACzBE,GAAiBF,GAAW,GAG5BG,IAAkB,IAAAze,QAAO6a,GACzB6D,IAAW,IAAA1e,QAAO14B,GAClBq3C,IAAe,IAAA3e;AACnBye,GAAgBve,QAAU2a,EAC1B6D,GAASxe,QAAU54B;AAEnB,IAAIs3C,GAAe,SAASA,eAC1B,OAAO,CACT,EAEI9C,GAAW,SAASA,SAAS+C,GAC/B,IAAIC,EAAMjD,GAAgB+C,GACtBG,EAAK3C,EAAQjH,aAAauJ,GAASxe,UAAYwe,GAASxe,QACxD/0B,EAAO,CACTzE,KAAMq4C,EACNxL,WAAYwL,EAAGrzC,QAAQ,aAAc,MACrC/C,IAAK,SAASA,IAAIiE,EAAQlG,GACxB,OAAOwtC,EAAUvrC,IAAIiE,EAAQlG,EAC/B;AAGF,OAAIw1C,GAAoBA,EAAiBJ,SAChCgD,EAAID,EAAQ1zC,IAAS+wC,EAAiBJ,SAAS+C,EAAQ1zC,GAGzD2zC,EAAID,EAAQ1zC,EACrB,EAGI6zC,GAAwBhP,eADAgG,mBAAmB8F,GAASM,EAAQhH,cACE,GAC9D6J,GAAaD,GAAsB,GACnCE,GAAgBF,GAAsB,GACtCG,GAAgBH,GAAsB,IAqB1C,IAAA1e,YAAU,WAEH2e,IAAe5D,GAClBgB,EAAYnc,QAAQ5mB,OAExB,GAAG,CAAC2lC;AAEJ,IAAIG,GAAS,SAASA,SACpB,OAAO7D,EAASa,EAAQ9G,iBAAiBhuC,GAASi2C,IACpD,EAKI1I,GAAW,SAASA,SAAShM,GAC/B,IACIwW,GADQryC,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,CAAC,GACvDqyC;AAGtBjnB,GAAQgkB,EAAQkD,UAAYlnB,GAC9B2hB,EAAO,WAAWlqB,OAAOvoB,EAAO,qDAChCm2C,QAAOt5B,GACPnB,EAAQ6xB,SAASoH,OAAS93B,GAAYk7B,KAEtCtF,EAAO,WAAWlqB,OAAOvoB,EAAO,gBAAgBuoB,OAAOgZ,IACvD4U,GAAO5U,GACP7lB,EAAQ6xB,SAASoH,EAASpT,GAAMwW,GAEpC,EAGI1K,GAAW,SAASA,SAAS9L,EAAKplB,GACpC,IAAIpe,EAAU2H,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,CAAC;AACnF+sC,EAAO,WAAWlqB,OAAOvoB,EAAO,QAAQuoB,OAAOgZ;AAE/C,IAAI0W,EAAcnD,EAAQzhB,aAEtB6kB,EAAY3W;AAuBhB,GArBY,KAARA,GAAesS,GAAqB91C,EAAQ81C,kBAAqBoE,EAAYE,oBAC/E5W,OAAM1kB,GAIiB,WAApBk2B,EAAWjgB,MAAmC,WAAdohB,QAAmCr3B,IAAR0kB,IAC9DA,GAAOA,GAILplB,GAAKA,EAAEqhB,QAAUrhB,EAAEqhB,OAAO4a,gBAC5B3B,GAAUt6B,EAAEqhB,OAAO4a,gBAIjBzF,IAASiB,IACXsE,EAAYvF,EAAKpR,EAAKmV,MACtBnV,EAAMoR,EAAKpR,EAAKmV,OAIdrD,IAAyBO,EAAY,CACvC,IAAI5H,EAAMqH,EAAqB9R,EAAKmV;AACpCwB,EAAYlM,EAAIpsC,MAChB2hC,EAAMyK,EAAIpsC,MACVg3C,GAAgB5K,EAAIqF,OACtB,CAUA,GAPIiC,GAAU1mB,IAEZ2U,EAAM3U,EAAM2U,GACZ2W,EAAY5E,EAAO/R,IAIjB+P,EAAW,CACb,IAAI+G,EAAOlH,EAAe5P,EAAK+P;AAE/BsF,GAAgByB,EAAKhH,QAErB9P,EADA2W,EAAYG,EAAKz4C,KAEnB,CAGI+zB,IACF4N,EAAa,MAAPA,EAAc5N,EAAO4N,GAAOA,GAKhC2R,IAAYM,IAAqBz1C,EAAQswB,UAC3CokB,EAAO,2BAA2BlqB,OAAOvoB,EAAO,KAAKuoB,OAAOgZ,IAC5DgM,GAAS2F,GAAS3R,EAAKuT,EAAQhH,eAIjCkI,GAAOzU,GACP2V,GAAegB,GAEXpE,GACFA,EAAcvS,GAIhB7lB,EAAQ2xB,SAASsH,EAASpT,GAAMxjC,EAAQg6C,cAC1C,EAGIzK,GAAa,SAASA,WAAW/L,EAAKvvB,GACxC,IACI+lC,GADQryC,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,CAAC,GACvDqyC;AAiB1B,GAfAtF,EAAO,SAASlqB,OAAOvoB,EAAO,sBAG1BkzC,IAAYO,IAAmBzhC,GAASuvB,IAC1CkR,EAAO,yBAAyBlqB,OAAOvoB,EAAO,KAAKuoB,OAAOuvB,OAC1DvK,GAAS2F,GAAS4E,KAAUhD,EAAQhH,eAIlCqF,GAAiBQ,IAAwB3hC,GAASuvB,IACpDkR,EAAO,+BAA+BlqB,OAAOvoB,EAAO,KAAKuoB,OAAOuvB,OAChE3E,EAAc2E,KAAUhD,EAAQhH,cAI9B6E,GAAQiB,EAAY,CAEtB,IAAIsE,EAAYvF,EAAKmF;AAErB9B,GAAOkC,GACPhB,GAAegB,GAEXpE,GACFA,EAAcoE,GAIhBx8B,EAAQ2xB,SAASsH,EAASuD,GAAYH,EACxC,CAGA,GAAI1E,GAAwBO,EAAY,CAEtC,IAAI5H,EAAMqH,EAAqByE;AAE/BlB,GAAgB5K,EAAIqF,QAEpB2E,GAAOhK,EAAIpsC,OACXs3C,GAAelL,EAAIpsC,OAEfk0C,GACFA,EAAc9H,EAAIpsC,OAIpB8b,EAAQ2xB,SAASsH,EAAS3I,EAAIpsC,OAAQm4C,EACxC,CAGAzB,GAAS/U,GACT7lB,EAAQ4xB,WAAWqH,EAASpT,GAAMwW,EACpC,EA2CIO,GAAW,CACbjL,SAAUA,GACVC,WAAYA,GACZC,SAAUA,GACVv7B,MA5CU,SAASA,QACnB,IACI+lC,GADQryC,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,CAAC,GACvDqyC,cAEtB5C,EAAUzC,EAAgByE,GAAgBve,SAAWld,EAAQgyB,gBAAgB0J,GAASxe,SAAU+Z,EAAMrB,EAAW3d;AAErH0Z,GAAS8H,EAAS,KAAM,CACtB9mB,SAAS,EACT0pB,cAAeA,IAGjBxK,GAASmG,EAAkBR,GAASiC,QAAWt4B,EAAW,CACxDk7B,cAAeA,IAEjBzK,QAAWzwB,GAAW,EAAM,CAC1Bk7B,cAAeA,GAEnB,EA4BE7E,SAtBkB,SAASqF,cAAcjzC,GACrC4tC,KACFT,EAAO,oBAAoBlqB,OAAOvoB,EAAO,KAAKuoB,OAAOuvB,OACrDvK,GAAS2F,GAAS4E,KAAUxyC,GAAUwvC,EAAQhH,cAElD,EAkBEqF,cAhBuB,SAASqF,mBAAmBlzC,GAC/C6tC,IACFV,EAAO,0BAA0BlqB,OAAOvoB,EAAO,KAAKuoB,OAAOuvB,OAC3D3E,EAAc2E,KAAUxyC,GAAUwvC,EAAQhH,aAE9C,EAYEniC,SAAUmsC,GACVW,WAAYlC,GACZmC,SAAUtC,GACVyB,cAAeA,GACfc,cAAe,SAASA,gBACtB,MAAO,CACL/4C,MAAOk4C,KACPhC,QAASS,KAEb,EACA/B,SAAUA,GACVoE,kBAnPsB,SAASA,kBAAkBrB,GACjD,OAAI3C,IAAoBA,EAAiBJ,UAChCI,EAAiBJ,SAAS+C,EAIrC,EA8OEsB,cA5OkB,SAASA,gBAC3B,IAAIC,EAAStE,GAASM,EAAQhH;AAO9B,OAJIgL,GAFSjB,MAGXD,GAAckB,GAGTA,CACT;AAqOA/D,EAAYnc,QAAU0f;AAEtB,IAAIS,GAAa,CACfn5C,MAAOA,GACPkT,MAAOA,GACPgjC,QAASA,GACTmB,YAAaA,GACbU,WAAYA;AAGV1D,IACF8E,GAAa,CACXjmC,MAAOA,GACPgjC,QAASA,KAIbrD,EAAO,SAAUqC,EAAQjH,aAAa7tC,GAAQ+4C;AAC9C,IAAIC,IAAc,IAAAtgB,QAAO,MACrB72B,GAAM,WAAc,WACtB,OAAOmxC,GAAWgG,EACpB,GAAG;AAEH1G,GAA0B,WACxB,IAAI2G,EAAYnE,EAAQjH,aAAauJ,GAASxe;AAa9C,OAZA6Z,EAAO,WAAYkC,EAASyC,GAASxe,SACrCqc,EAAerc,QAAU,CACvB54B,MAAOi5C,EACPtE,QAASA,EACT2D,SAAUA,GACVS,WAAYA,GACZthC,OAAQA,EACRs8B,UAAWA,EACXc,YAAaA,EACbZ,OAAQA,GAEVv4B,EAAQyxB,SAASwH,EAASM,EAAerc,SAClC,WACL,IAAIqgB,EAAYnE,EAAQjH,aAAauJ,GAASxe;AAC9C6Z,EAAO,aAAckC,EAASsE,GAC9Bv9B,EAAQ0xB,WAAWuH,EACrB,CACF,GAAG,KAEH,IAAA3b,YAAU,WACR,IAAIigB,EAAYnE,EAAQjH,aAAa7tC;AAUrC,OARIg1C,EAAgBpc,QAClBoc,EAAgBpc,SAAU,GAE1B6Z,EAAO,SAAUzyC,EAAO60C,GACxBI,EAAerc,QAAQ54B,MAAQi5C,EAC/Bv9B,EAAQb,OAAO85B,EAASM,EAAerc,QAASye,GAAaze,UAGxD,WACLye,GAAaze,QAAUqgB,CACzB,CACF,GAAG,CAACj5C,IAEJsyC,GAA0B,WACpB0B,GAAiC,MAAfnyC,GAAI+2B,SAAmB8d,OAAa70C,GAAI+2B,QAAQsgB,aAAexC,KAAcG,KACrG,GAAG,CAACj3C,KAEJ0yC,GAA0B,WACpB9O,GAAS3hC,KACXA,GAAI+2B,QAAQugB,MAAMC,OAAS,mBAC3B5hC,YAAW,WACT3V,GAAI+2B,QAAQugB,MAAME,YAAc,MAChCx3C,GAAI+2B,QAAQugB,MAAMG,YAAc,QAChCz3C,GAAI+2B,QAAQugB,MAAMI,YAAc,UAChC13C,GAAI+2B,QAAQugB,MAAMK,YAAc,SAClC,GAAG,KAEP;AAEA,IAAIC,GAAe,GAAGlxB,OAAO4gB,mBAAmB7pC,OAAOgG,OAAOyzC,KAAc5P,mBAAmB7pC,OAAOgG,OAAOytC,IAAc5J,mBAAmB7pC,OAAOgG,OAAOovC,KASxJjrC,GAAOzJ,EACP05C,GA7lBiB,SAASC,iBAAiBC,GAC/C,IAAI1F,EAAY0F,EAAM1F,UAClB7G,EAAWuM,EAAMvM,SACjB+G,EAAWwF,EAAMxF,SACjBD,EAAWyF,EAAMzF,SACjBtyC,EAAM+3C,EAAM/3C,IAEZylB,EAAS,SAASA,OAAOia,GAC3B,OAAO8L,EAAS9L,EAClB;AA6BA,MA3BkB,SAAd2S,GAAsC,aAAdA,GAA0C,WAAdA,IACtD5sB,EAAS,SAASA,OAAOnL,GACvB,OAAOkxB,EAASlxB,EAAEqhB,OAAO59B,MAAOuc,EAClC,GAGgB,WAAd+3B,IACF5sB,EAAS,SAASA,SAChB,IAAIuyB,EAAWh6C,MAAMyD,KAAKzB,EAAI+2B,SAASrzB,QAAO,SAAUurC,GACtD,OAAOA,EAAO+I,QAChB,IAAG7vC,KAAI,SAAU8mC,GACf,OAAOA,EAAOlxC,KAChB;AACAytC,EAAS8G,EAAW0F,EAAWA,EAAS,IAAM,GAChD,GAGgB,aAAd3F,IACF5sB,EAAS,SAASA,OAAOnL,GACvBkxB,EAASlxB,EAAEqhB,OAAOsc,SAEd1F,GACFA,EAASj4B,EAEb,GAGK,SAAUolB,GACfja,EAAOia,GAEH6S,GACFA,EAAS7S,EAEb,CACF,CAgjBsBoY,CAAiB,CACnCzF,UAAWA,EACX7G,SAAUA,GACV+G,SAAUA,EACVD,SAAUA,EACVtyC,IAAKA,KAEHk4C,GArjBe,SAASC,eAAeC,GAC3C,IAAI3M,EAAa2M,EAAM3M,WACnB+G,EAAS4F,EAAM5F;AACnB,OAAO,SAAUl4B,GACfmxB,GAAW,GAEP+G,GACFA,EAAOl4B,EAEX,CACF,CA2iBoB69B,CAAe,CAC/B1M,WAAYA,GACZ+G,OAAQA,IAEN6F,GA7iBc,SAASC,cAAcC,GACzC,IAAIlG,EAAYkG,EAAMlG,UAClB+C,EAAcmD,EAAMnD,YACpB9C,EAAWiG,EAAMjG,SACjBv0C,EAAQw6C,EAAMx6C;AAElB,OAAQs0C,GACN,IAAK,OACL,IAAK,SACH,OAAQ+C,GAA+B,IAAhBA,EAAyBA,EAAL;AAE7C,IAAK,WACH,OAAQA,GAAc;AAExB,IAAK,SACH,OAAOr3C,IAAUu0C,EAAW,GAAK;AAEnC,IAAK,WACH,QAASv0C;AAEX,QACE,OAAOA,EAEb,CAshBoBu6C,CAAc,CAC9BjG,UAAWA,EACX+C,YAAaA,GACb9C,SAAUA,EACVv0C,MAAOA,KAELkzB,GA1hBkB,SAASunB,kBAAkBnG,GACjD,OAAQA,GACN,IAAK,OAGL,IAAK,SAGL,IAAK,WACH,OAAOA;AAET,QACE,OAEN,CA4gBamG,CAAkBnG;AAC7B,MAAO,CACL6E,WAAYA,GACZT,SAAUA,GACVgC,OA7BW,SAASA,OAAO9nB,GAC3B,OAAO,IAAA+nB,UAAQ,WACb,OAAO5C,GAAanlB,EAAW,IACjC,GAAG2W,mBAAmBsQ,IACxB,EA0BE53C,IAAKA,GACL6yC,UAAW5N,eAAeA,eAAe,CAAC,EAAG4N,GAAY,CAAC,EAAG,CAC3DP,SAAUA,EAEVC,SAAUA,EAEVC,OAAQA,EAGRh2C,GAAIq2C,EAAUr2C,IAAMs2C,IAGtB6F,SAAU1T,eAAe,CACvBr9B,KAAMA,GACN0qC,SAAUA,EACVC,SAAUsF,GACVrF,OAAQ0F,GACRn6C,MAAOs6C,GACPr4C,IAAKA,GACLixB,KAAMA,GACNz0B,GAAIq2C,EAAUr2C,IAAMs2C,GACnBD,GAEP,CAEA,IAAI+F,EAAU,SAASA,QAAQC,GAC7B,IAAIC,EAA0B,cAAiB,SAAUzU,EAAO8M,GAC9D,IAAI4H,EAAY9H,SAAS5M,EAAO8M,GAC5B+F,EAAa6B,EAAU7B,WACvBT,EAAWsC,EAAUtC,SACrBgC,EAASM,EAAUN,OACnBz4C,EAAM+4C,EAAU/4C,IAChB6yC,EAAYkG,EAAUlG;AAE1B,OAAO4F,EAAqB,gBAAoBI,EAAWlU,SAAS,CAClE8R,SAAUA,EACVS,WAAYA,EACZ/4C,MAAOkmC,EAAMlmC,MACb66C,aAAch5C,EACd2hC,MAAO0C,EAAM1C,MACb1Q,KAAMoT,EAAMpT,MACX4hB,IACL;AAEA,OADAiG,EAAW/iB,YAAc,WAAWrP,OApmCZ,SAASuyB,oBAAoBC,GAErD,OAAIA,EAAiBjoB,MAAQioB,EAAiBjoB,KAAKrpB,KAC1CsxC,EAAiBjoB,KAAKrpB,KAGxBsxC,EAAiBnjB,aAAemjB,EAAiBtxC,MAAQ,WAClE,CA6lC6CqxC,CAAoBJ,GAAY,KACpEC,CACT,EAEIK,EAAWxX,EAAM,mBAEjByX,EAAO,SAASA,KAAK3F,GACvB,IAAIgD,EAAWhD,EAAKgD,SAChBS,EAAazD,EAAKyD,WAClB7S,EAAQoB,yBAAyBgO,EAAM,CAAC,WAAY,eAEpD2B,EAAc8B,EAAW9B,YACzB5J,EAAWiL,EAASjL,SACpBC,EAAagL,EAAShL,WAEtB4N,EAAYhV,EAAMkO,SAClB+G,EAAUjV,EAAMmO,OAChBr0C,EAAQkmC,EAAMlmC,MAEd66C,GADe3U,EAAMqN,aACNrN,EAAM2U,cACrBrX,EAAQ0C,EAAM1C,MACdtoB,EAAQgrB,EAAMhrB,MAEd7c,GADQ6nC,EAAMmK,MACTnK,EAAM7nC,IACX+8C,EAAO9T,yBAAyBpB,EAAO,CAAC,WAAY,SAAU,QAAS,eAAgB,eAAgB,QAAS,QAAS,QAAS;AAYtI,OAVA8U,EAAS,SAAUh7C,GAEnBsyC,GAA0B,WACpB9O,GAASqX,IACXA,EAAajiB,QAAQugB,MAAMkC,WAAa,MACxC7jC,YAAW,WACTqjC,EAAajiB,QAAQugB,MAAMkC,WAAa,OAC1C,GAAG,KAEP,IACoB,gBAAoB,WAAgB,KAAMngC,EAAqB,gBAAoB,QAAS,CAC9GogC,QAASj9C,GACR,IAAK6c,EAAO,KAAO,KAAmB,gBAAoB,QAASsrB,SAAS,CAAC,EAAG4U,EAAM,CACvF/8C,GAAIA,EACJoL,KAAMzJ,EACN6B,IAAKg5C,EACLj7C,MAAQq3C,GAA+B,IAAhBA,EAAyBA,EAAL,GAC3C7C,SAAU,SAASA,SAASj4B,GAC1BkxB,EAASlxB,EAAEqhB,OAAO59B,MAAOuc,GAErB++B,GACFA,EAAU/+B,EAEd,EACAk4B,OAAQ,SAASA,OAAOl4B,GACtBmxB,GAAW,GAEP6N,GACFA,EAAQh/B,EAEZ,KAEJ,EACIo/B,EAASd,EAAQQ,GAEjBO,EAAW,SAASA,SAASlG,GAC/B,IAAIgD,EAAWhD,EAAKgD,SAChBS,EAAazD,EAAKyD,WAClB7S,EAAQoB,yBAAyBgO,EAAM,CAAC,WAAY,eAEpD2B,EAAc8B,EAAW9B,YACzB5J,EAAWiL,EAASjL,SACpBC,EAAagL,EAAShL,WAEtB4N,EAAYhV,EAAMkO,SAClB+G,EAAUjV,EAAMmO,OAChBr0C,EAAQkmC,EAAMlmC,MAEd66C,GADe3U,EAAMqN,aACNrN,EAAM2U,cACrBrX,EAAQ0C,EAAM1C,MACdtoB,EAAQgrB,EAAMhrB,MACd7c,EAAK6nC,EAAM7nC,GACX+8C,EAAO9T,yBAAyBpB,EAAO,CAAC,WAAY,SAAU,QAAS,eAAgB,eAAgB,QAAS,QAAS;AAW7H,OARAoM,GAA0B,WACpB9O,GAASqX,IACXA,EAAajiB,QAAQugB,MAAMkC,WAAa,MACxC7jC,YAAW,WACTqjC,EAAajiB,QAAQugB,MAAMkC,WAAa,OAC1C,GAAG,KAEP,IACoB,gBAAoB,WAAgB,KAAMngC,EAAqB,gBAAoB,QAAS,CAC9GogC,QAASj9C,GACR,IAAK6c,EAAO,KAAO,KAAmB,gBAAoB,WAAYsrB,SAAS,CAAC,EAAG4U,EAAM,CAC1F/8C,GAAIA,EACJoL,KAAMzJ,EACN6B,IAAKg5C,EACLj7C,MAAQq3C,GAAc,GACtB7C,SAAU,SAASA,SAASj4B,GAC1BkxB,EAASlxB,EAAEqhB,OAAO59B,MAAOuc,GAErB++B,GACFA,EAAU/+B,EAEd,EACAk4B,OAAQ,SAASA,OAAOl4B,GACtBmxB,GAAW,GAEP6N,GACFA,EAAQh/B,EAEZ,KAEJ,EACIs/B,EAAahB,EAAQe,GAErBE,EAAWlY,EAAM,qBAEjBmY,EAAS,SAASA,OAAOrG,GAC3B,IAAIgD,EAAWhD,EAAKgD,SAChBS,EAAazD,EAAKyD,WAClB7S,EAAQoB,yBAAyBgO,EAAM,CAAC,WAAY,eAEpD11C,EAAQm5C,EAAWn5C,MACnB0tC,EAAagL,EAAShL,WAEtB8G,EAAWlO,EAAMkO,SACjB+G,EAAUjV,EAAMmO,OAChBr0C,EAAQkmC,EAAMlmC,MAEdjC,GADemoC,EAAMqN,aACXrN,EAAMnoC,SAChBy0B,EAAW0T,EAAM1T,SACjBqoB,EAAe3U,EAAM2U,aACrBrX,EAAQ0C,EAAM1C,MACd2Q,EAAWjO,EAAMiO,SACjBj5B,EAAQgrB,EAAMhrB,MACd7c,EAAK6nC,EAAM7nC,GACX+8C,EAAO9T,yBAAyBpB,EAAO,CAAC,WAAY,SAAU,QAAS,eAAgB,UAAW,WAAY,eAAgB,QAAS,WAAY,QAAS,OAE5J0V,GAAY,IAAAljB;AAyBhB,OATA4Z,GAA0B,WACpB9O,GAASqX,IACXA,EAAajiB,QAAQugB,MAAMkC,WAAa,MACxC7jC,YAAW,WACTqjC,EAAajiB,QAAQugB,MAAMkC,WAAa,OAC1C,GAAG,KAEP,IACAK,EAAS,SAAU17C,EAAOJ,GACN,gBAAoB,WAAgB,KAAMsb,EAAqB,gBAAoB,QAAS,CAC9GogC,QAASj9C,GACR,IAAK6c,EAAO,KAAO,KAAmB,gBAAoB,SAAUsrB,SAAS,CAAC,EAAG4U,EAAM,CACxF/8C,GAAIA,EACJ81C,SAAUA,EACV1qC,KAAMzJ,EACN6B,IAAKg5C,GAAgBe,EACrBh8C,MAAOA,IAAUu0C,EAAW,GAAK,IACjCC,SA/BiB,SAASyH,aAAa1/B,GACvC,IAAI09B,EAAWh6C,MAAMyD,MAAMu3C,GAAgBe,GAAWhjB,SAASrzB,QAAO,SAAUurC,GAC9E,OAAOA,EAAO+I,QAChB,IAAG7vC,KAAI,SAAU8mC,GACf,OAAOA,EAAOlxC,KAChB;AACA04C,EAASjL,SAAS8G,EAAW0F,EAAWA,EAAS,IAAM,IAEnDzF,GAAYj4B,GACdi4B,EAASj4B,EAEb,EAqBEk4B,OAAQ,SAASA,OAAOl4B,GACtBmxB,GAAW,GAEP6N,GACFA,EAAQh/B,EAEZ,IACEpe,EAAUA,EAAQiM,KAAI,SAAU8mC,GAClC,OAAoB,gBAAoB,SAAU,CAChDhlB,IAAKglB,EAAOlxC,MACZA,MAAOkxC,EAAOlxC,MACdk8C,SAAUhL,EAAOgL,UAChBhL,EAAO51B,MACZ,IAAKsX,GACP,EACIupB,EAAWtB,EAAQkB,GAEnBK,EAAW,SAASA,SAAS1G,GAC/B,IAAIgD,EAAWhD,EAAKgD,SAChBS,EAAazD,EAAKyD,WAClB7S,EAAQoB,yBAAyBgO,EAAM,CAAC,WAAY,eAEpD11C,EAAQm5C,EAAWn5C,MACnBytC,EAAWiL,EAASjL,SACpBC,EAAagL,EAAShL,WAEtB4N,EAAYhV,EAAMkO,SAClB+G,EAAUjV,EAAMmO,OAChBr0C,EAAQkmC,EAAMlmC,MAGd66C,GAFe3U,EAAMqN,aACbrN,EAAM1C,MACC0C,EAAM2U,cACrBx8C,EAAK6nC,EAAM7nC,GACX6c,EAAQgrB,EAAMhrB,MACdkgC,EAAO9T,yBAAyBpB,EAAO,CAAC,WAAY,SAAU,QAAS,eAAgB,QAAS,eAAgB,KAAM;AAE1H,OAAoB,gBAAoB,WAAgB,KAAMhrB,EAAqB,gBAAoB,QAAS,CAC9GogC,QAASj9C,GACR,IAAK6c,EAAO,KAAO,KAAmB,gBAAoB,QAASsrB,SAAS,CAAC,EAAG4U,EAAM,CACvF/8C,GAAIA,EACJoL,KAAMzJ,EACN6B,IAAKg5C,EACLf,UAAWl6C,EACXw0C,SAAU,SAASA,SAASj4B,GAC1BkxB,EAASlxB,EAAEqhB,OAAOsc,SAEdoB,GACFA,EAAU/+B,EAEd,EACAk4B,OAAQ,SAASA,OAAOl4B,GACtBmxB,GAAW,GAEP6N,GACFA,EAAQh/B,EAEZ,EACA2W,KAAM,cAEV,EACImpB,EAAaxB,EAAQuB,GAqErBE,EAnEiB,SAASC,eAAezB,GAC3C,OAAoB,cAAiB,SAAUxU,EAAOrkC,GACpD,OAAoB,gBAAoBssC,EAAazb,SAAU,MAAM,SAAU4iB,GAC7E,IAAI8G,EAAgB9G,EAAK8G,cACrBC,EAAkB/G,EAAK+G;AAC3B,OAAoB,gBAAoB3B,EAAWlU,SAAS,CAC1D4V,cAAeA,EACfC,gBAAiBA,EACjBx6C,IAAKA,GACJqkC,GACL,GACF,GACF,CAuDciW,EArDF,SAASG,MAAMhH,GACzB,IAAI8G,EAAgB9G,EAAK8G,cACrBC,EAAkB/G,EAAK+G,gBACvBnW,EAAQoB,yBAAyBgO,EAAM,CAAC,gBAAiB,oBAEzDiH,EAAaF,EAAgBz8C,MAC7BytC,EAAW+O,EAAc/O,SACzBC,EAAa8O,EAAc9O,WAC3BkP,EAAgBJ,EAAchI,SAC9BqI,EAAcL,EAAc/H,OAE5Bz0C,EAAQsmC,EAAMtmC,MACds7C,EAAYhV,EAAMkO,SAClB+G,EAAUjV,EAAMmO,OAChBr0C,EAAQkmC,EAAMlmC,MAEd66C,GADe3U,EAAMqN,aACNrN,EAAM2U,cACrBO,EAAO9T,yBAAyBpB,EAAO,CAAC,QAAS,WAAY,SAAU,QAAS,eAAgB;AAEpG,OAAoB,gBAAoB,QAASM,SAAS,CAAC,EAAG4U,EAAM,CAClE3xC,KAAMzJ,EACN6B,IAAKg5C,EACLj7C,MAAOA,EACPk6C,QAASyC,IAAe38C,EACxBw0C,SAAU,SAASA,SAASj4B,GACrBA,EAAEqhB,OAAOsc,UAIdzM,EAASztC,GAELs7C,GACFA,EAAU/+B,GAGRqgC,GACFA,EAAcrgC,GAElB,EACAk4B,OAAQ,SAASA,OAAOl4B,GACtBmxB,GAAW,GAEP6N,GACFA,EAAQh/B,GAGNsgC,GACFA,EAAYtgC,EAEhB,EACA2W,KAAM,UAEV,IAGI4pB,EAA0B,SAAUC,GACtC1V,UAAUyV,WAAYC;AAEtB,IAAI12C,EAAS4hC,aAAa6U;AAE1B,SAASA,aAGP,OAFA5W,gBAAgB5oC,KAAMw/C,YAEfz2C,EAAOkD,MAAMjM,KAAMwI,UAC5B,CA+BA,OA7BA0gC,aAAasW,WAAY,CAAC,CACxB5wB,IAAK,SACLlsB,MAAO,SAAS06C,SACd,IAAIsC,EAAc1/C,KAAKgpC,MACnBnoC,EAAU6+C,EAAY7+C,QACtBy0B,EAAWoqB,EAAYpqB;AAC3B,OAAoB,gBAAoB2b,EAAaxb,SAAU,CAC7D/yB,MAAO1C,KAAK2/C,cACX9+C,EAAUA,EAAQiM,KAAI,SAAU8mC,GACjC,OAAoB,gBAAoB,QAAS,CAC/ChlB,IAAKglB,EAAOlxC,OACXkxC,EAAO51B,MAAO,IAAkB,gBAAoBghC,EAAS,CAC9Dt8C,MAAOkxC,EAAOlxC,QAElB,IAAK4yB,EACP,GACC,CACD1G,IAAK,eACLzqB,IAAK,SAASA,MACZ,MAAO,CACL+6C,cAAetV,eAAeA,eAAe,CAAC,EAAG5pC,KAAKgpC,MAAMoS,UAAW,CAAC,EAAG,CACzElE,SAAUl3C,KAAKgpC,MAAMkO,SACrBC,OAAQn3C,KAAKgpC,MAAMmO,SAErBgI,gBAAiBn/C,KAAKgpC,MAAM6S,WAEhC,KAGK2D,UACT,CAzC8B,CAyC5B,EAAAhC,WACEoC,EAAerC,EAAQiC;AAsB3B,IAYIK,EAAWvZ,EAAM,4BAEjBwZ,EAAgB,SAASA,cAAc1H,GACzC,IAAIt1C,EAAQs1C,EAAKt1C,MACbuzC,EAAe+B,EAAK/B,aACpBL,EAAWoC,EAAKpC,SAChB+J,EAAmB3H,EAAK2H,iBACxB/W,EAAQoB,yBAAyBgO,EAAM,CAAC,QAAS,eAAgB,WAAY,qBAG7ER,EAAUrG,aAIVyO,EADaxU,gBADD,IAAAvP,UAAS,IAAIloB,KACc,GACf,GAGxByK,GAAU,IAAA0c,YAAW8U,GAErB+L,EAAYnE,EAAQjH,aAAa7tC,GACjCm9C,EAAczhC,EAAQgyB,gBAAgB1tC,IAAUuzC,GAAgB,GAOhEwC,EAAuBrN,eADDgG,mBAFToG,EAAQ7G,cAAcgL,IAAcnE,EAAQ7G,cAAcgL,GAAWr5C,OAE3Bu9C,GACI,GAC3DC,EAAgBrH,EAAqB,GACrCsH,EAAmBtH,EAAqB,GACxCuH,EAAmBvH,EAAqB,GAOxCG,EAAuBxN,eADAgG,mBAJT0O,EAAgBA,EAAcpzC,KAAI,WAClD,OAAO0lC,GACT,IAAK,IAG2D,GAC5D7sC,EAAOqzC,EAAqB,GAC5BqH,EAAUrH,EAAqB,GAC/BsH,EAAUtH,EAAqB,GAE/BuH,GAAqB,IAAAlD,UAAQ,WAC/B,OAAO,SAAU36C,EAAO0F,GACtB,IAAIN,EAAsB,MAAbw4C,IAAoB,EAAIA,IAAUx4C;AAC/C,OAAOkuC,EAAWA,EAAStzC,EAAOoF,EAAQM,QAAUuX,CACtD,CACF,IAOIy7B,EALYxF,SAAShM,eAAe,CACtC9mC,MAAOA,EACPkzC,SAAUA,EAAWuK,OAAqB5gC,EAC1Co3B,QAAQ,GACP/N,IACsBoS;AAGzBhG,GAA0B,WAExB,IAAIoL,EAAkB,SAASA,gBAAgB17C,GAEzCA,IAAci3C,IAIlB8D,EAAS,GAAGx0B,OAAO0wB,EAAW,aAE1BtO,OAAO,GAAGpiB,OAAO0wB,EAAW,iBAAiBxwB,KAAKzmB,IAEpDs2C,EAASpF,WAEb;AAKA,OAFA4B,EAAQ6I,QAAQC,GAAG,QAASF,GAErB,WACL5I,EAAQ6I,QAAQE,eAAe,QAASH,EAC1C,CACF,GAAG,CAAC19C;AAEJ,IAcI89C,EAAO,SAASA,KAAK9rB,EAAGnC,GAC1BktB,EAAS,WAAY,GAAGx0B,OAAOvoB,EAAO,KAAKuoB,OAAOyJ,EAAG,UAAUzJ,OAAOvoB,EAAO,KAAKuoB,OAAOsH,EAAG;AAE5F,IAAIkuB,EAAU5U,mBAAmBtmC;AAE7BA,EAAKmvB,IAAMnvB,EAAKgtB,KAClBkuB,EAAQ/rB,GAAKnvB,EAAKgtB,GAClBkuB,EAAQluB,GAAKhtB,EAAKmvB,IAMpBurB,EAAQQ,EACV,EAEIn5C,EAAM,SAASA,MACjB/B,EAAKqG,KAAKwmC,KACV6N,EAAQpU,mBAAmBtmC,GAC7B,EAEIm7C,EAAsB,SAASA,oBAAoBzK,GACrD1wC,EAAKqG,KAAKwmC,KACV6N,EAAQpU,mBAAmBtmC;AAE3B,IAAIo7C,EAAmB9U,mBAAmBmU;AAE1CW,EAAiBp7C,EAAKmC,OAAS,GAAKuuC,EACpC8J,EAAiBY,EACnB,EAeIj7C,EAASH,EAAKmH,KAAI,SAAU8hB,EAAK/hB,GACnC,IAAIm0C,EAAoB,CACtBvf,OAAQ,SAASA,SACf,OA7DQ,SAASA,OAAO50B,GAE5BgzC,EAAS,uBAAwB,GAAGx0B,OAAOvoB,EAAO,KAAKuoB,OAAOxe,EAAG,UAAUwe,OAAOvoB,EAAO,KAAKuoB,OAAO1lB,EAAKmC,OAAS,EAAG,MACtH0W,EAAQ+xB,cAAc,GAAGllB,OAAOvoB,EAAO,KAAKuoB,OAAOxe,EAAG,MACtD2R,EAAQ+xB,cAAc,GAAGllB,OAAOvoB,EAAO,KAAKuoB,OAAO1lB,EAAKmC,OAAS,EAAG;AAEpE,IAAI+4C,EAAUl7C,EAAKoE,MAAM,EAAG8C,GAAGwe,OAAO1lB,EAAKoE,MAAM8C,EAAI,EAAGlH,EAAKmC;AAC7Du4C,EAAQQ;AAER,IAAII,EAAWb,IACXW,EAAmBE,EAASl3C,MAAM,EAAG8C,GAAGwe,OAAO41B,EAASl3C,MAAM8C,EAAI,EAAGo0C,EAASn5C;AAClFq4C,EAAiBY,EACnB,CAiDaG,CAAQr0C,EACjB,GAEEs0C,EAAsB,CACxB9K,aAAc6J,GAAiBA,EAAcrzC,GAC7C+hB,IAAKA,EACL9rB,MAAO,GAAGuoB,OAAOvoB,EAAO,KAAKuoB,OAAOxe,EAAG,KACvC2jB,MAAO3jB;AAET,OAAO+8B,eAAeA,eAAe,CACnCoX,kBAAmBA,EACnBG,oBAAqBA,GACpBH,GAAoBG,EACzB,IACIC,EAAgB,CAClB15C,IAAKA,EACLk5C,KAAMA,EACNE,oBAAqBA,EACrBhsC,MAlCU,SAASA,QAEnB,IAAImsC,EAAWziC,EAAQgyB,gBAAgB1tC,IAAUuzC,GAAgB;AAEjE8J,EAAiBc;AAEjB,IAAII,EAAYJ,EAAWA,EAASn0C,KAAI,WACtC,OAAO0lC,GACT,IAAK;AAEL6N,EAAQgB,EACV;AA0BItB,IACFA,EAAiBrkB,QAAU0lB;AAG7B,IAAIE,EAAkB,CACpBx7C,OAAQA,EACRhD,MAAOA,GAGLy+C,EAAiB3X,eAAeA,eAAe,CAAC,EAAGprB,GAAU,CAAC,EAAG,CACnEyxB,SAAU,SAASA,SAAS9uC,EAAIqgD,GAC9BxB,EAAWrzC,IAAIxL,EAAIqgD;AAEnB,IAAK,IAAIlU,EAAO9kC,UAAUV,OAAQnB,EAAO,IAAIhE,MAAM2qC,EAAO,EAAIA,EAAO,EAAI,GAAI/L,EAAO,EAAGA,EAAO+L,EAAM/L,IAClG56B,EAAK46B,EAAO,GAAK/4B,UAAU+4B;AAG7B/iB,EAAQyxB,SAAShkC,MAAMuS,EAAS,CAACrd,EAAIqgD,GAAKn2B,OAAO1kB,GACnD,EACAupC,WAAY,SAASA,WAAW/uC,GAC9B6+C,EAAmB,OAAE7+C;AAErB,IAAK,IAAIsgD,EAAQj5C,UAAUV,OAAQnB,EAAO,IAAIhE,MAAM8+C,EAAQ,EAAIA,EAAQ,EAAI,GAAIC,EAAQ,EAAGA,EAAQD,EAAOC,IACxG/6C,EAAK+6C,EAAQ,GAAKl5C,UAAUk5C;AAG9BljC,EAAQ0xB,WAAWjkC,MAAMuS,EAAS,CAACrd,GAAIkqB,OAAO1kB,GAChD,EACA6pC,gBAAiB,SAASA,gBAAgB1rC,GAExC,GAAI2oC,OAAO,GAAGpiB,OAAO0wB,EAAW,iBAAiBxwB,KAAKzmB,GAAY,CAChE,IAAI5C,EAAO4C,EAAUoC,QAAQpE,EAAO,IAChC0xB,EAAIkb,EAAUvrC,IAAIi8C,IAAoBl+C;AAE1C,OADA29C,EAAS,aAAax0B,OAAOnpB,EAAM,QAAQmpB,OAAOmJ,IAC3CA,CACT,CAEA,OAAOhW,EAAQgyB,gBAAgB1rC,EACjC;AAaF,MAAO,CACLs4C,OAXW,SAASA,OAAO9nB,GAC3B,OAAoB,gBAAoB0a,EAAoBva,SAAU,CACpE/yB,MAAO6+C,GACO,gBAAoBpQ,EAAqB1b,SAAU,CACjE/yB,MAAO0+C,GACO,gBAAoBlQ,EAAuBzb,SAAU,CACnE/yB,MAAO4+C,GACNhsB,IACL,EAIE5tB,IAAKA,EACLk5C,KAAMA,EACNE,oBAAqBA,EACrBh7C,OAAQA,EACRw7C,gBAAiBA,EACjBF,cAAeA,EACft+C,MAAOA,EAEX;AA+BA,SAAS6+C,aAAaC,GACpB,IAAIhK,EAAUrG,aAEVsQ,GAAgB,IAAAxE,UAAQ,WAC1B,OAjCqB,SAASyE,mBAAmBF,EAAOhK,GAC1D,OAAOhO,eAAeA,eAAe,CAAC,EAAGgO,GAAU,CAAC,EAAG,CACrDnpC,SAAU,SAASA,SAAS3L,GAC1B,OAAO80C,EAAQnpC,SAAS,GAAG4c,OAAOu2B,EAAO,KAAKv2B,OAAOvoB,GACvD,EACAy4C,WAAY,SAASA,WAAWz4C,GAC9B,OAAO80C,EAAQ2D,WAAW,GAAGlwB,OAAOu2B,EAAO,KAAKv2B,OAAOvoB,GACzD,EACA04C,SAAU,SAASA,SAAS14C,GAC1B,OAAO80C,EAAQ4D,SAAS,GAAGnwB,OAAOu2B,EAAO,KAAKv2B,OAAOvoB,GACvD,EACAqtC,SAAU,SAASA,SAASrtC,EAAOJ,GACjC,OAAOk1C,EAAQzH,SAAS,GAAG9kB,OAAOu2B,EAAO,KAAKv2B,OAAOvoB,GAAQJ,EAC/D,EACA0tC,WAAY,SAASA,WAAWttC,EAAOJ,GACrC,OAAOk1C,EAAQxH,WAAW,GAAG/kB,OAAOu2B,EAAO,KAAKv2B,OAAOvoB,GAAQJ,EACjE,EACA2tC,SAAU,SAASA,SAASvtC,EAAOJ,GACjC,OAAOk1C,EAAQvH,SAAS,GAAGhlB,OAAOu2B,EAAO,KAAKv2B,OAAOvoB,GAAQJ,EAC/D,EACA8tC,gBAAiB,SAASA,gBAAgB1tC,GACxC,OAAO80C,EAAQpH,gBAAgB,GAAGnlB,OAAOu2B,EAAO,KAAKv2B,OAAOvoB,GAC9D,EACA6tC,aAAc,SAASA,aAAa7tC,GAClC,MAAO,GAAGuoB,OAAOusB,EAAQjH,aAAaiR,GAAQ,KAAKv2B,OAAOvoB,EAC5D,GAEJ,CAMWg/C,CAAmBF,EAAOhK,EACnC,GAAG,CAACgK;AACJ,OAAOC,CACT,CAEA,SAASE,eAEP,OADgB,IAAA7mB,YAAWuV,EAE7B,CAEA,IAAIuR,EAAW,SAASA,SAAS5J,GAC/B,IAAI6J,EAAO7J,EAAK6J,KACZ3sB,EAAW8iB,EAAK9iB;AAIpB,OAFiB2sB,EADDF,gBAIPzsB,EAGF,IACT,EAEI4sB,EAAa,SAASA,WAAW9J,GACnC,IAAId,EAAWc,EAAKd,SAChBx0C,EAAQs1C,EAAKt1C,MACbkmC,EAAQoB,yBAAyBgO,EAAM,CAAC,WAAY,UAGpDR,EAAUrG;AAEd,GAAI+F,EAAU,CACZ,IAAIiD,EAAK3C,EAAQjH,aAAa7tC,GAC1B6D,EAAO,CACTzE,KAAMq4C,EACNxL,WAAYwL,EAAGrzC,QAAQ,aAAc,MACrC/C,IAAK,SAASA,IAAIiE,EAAQlG,GACxB,OAAOwtC,EAAUvrC,IAAIiE,EAAQlG,EAC/B;AAQF,OAAoB,gBAAoB8/C,EAAU,CAChDC,KANS,SAASA,KAAKvF,GACvB,IAAIt0C,EAASs0C,EAAMt0C;AACnB,OAAOkvC,EAASlvC,EAAQzB,EAC1B,GAIgB,gBAAoBw7C,EAAmB7Y,SAAS,CAC9DxmC,MAAOA,GACNkmC,IACL,CACE,OAAoB,gBAAoBmZ,EAAmB7Y,SAAS,CAClExmC,MAAOA,GACNkmC,GAEP,EAEImZ,EAAoB,SAASA,kBAAkBpF,GACjD,IAAIznB,EAAWynB,EAAMznB,SACjB0T,EAAQoB,yBAAyB2S,EAAO,CAAC,aAEzCqF,EAAiBtC,EAAc9W,GAC/BoU,EAASgF,EAAehF,OACxBkE,EAAkBc,EAAed,gBACjCF,EAAgBgB,EAAehB,cAC/Bt+C,EAAQs/C,EAAet/C;AAE3B,OACSs6C,EADe,mBAAb9nB,EACKA,EAASsU,eAAeA,eAAe,CACnD9mC,MAAOA,EACPs+C,cAAeA,EACfE,gBAAiBA,GAChBF,GAAgBE,IAGPhsB,EAChB,EAEI+sB,EAAiB,SAASA,eAAenF,GAC3C,IAAIiE,EAAsBjE,EAAMiE,oBAC5BH,EAAoB9D,EAAM8D,kBAC1B1rB,EAAW4nB,EAAM5nB,SAEjB9W,GAAU,IAAA0c,YAAW8U,GAErB4H,EAAUrG,aAGVG,EAAalG,gBADD,IAAAvP,UAAS,GACkB,GAEvC0V,GADQD,EAAW,GACRA,EAAW,IAKtBsO,EADaxU,gBADA,IAAAvP,UAAS,IAAIloB,KACc,GAChB,GAGxBjR,EAAQq+C,EAAoBr+C,MAE5Bw/C,EAAYX,aAAa7+C,IAkB7B,IAAAg5B,YAAU,WAER,IAAI0kB,EAAkB,SAASA,gBAAgB17C,GAE5BA,EAAUiF,MAAM,GAAkC,GAA/BjF,EAAU+9B,YAAY,KAAa/9B,EAAU+9B,YAAY,KAAO,EAAI/9B,EAAUgD,UAE/FhF,GACjB6uC,EAASlgB,KAAKG,SAElB;AAKA,OAFAgmB,EAAQ6I,QAAQC,GAAG,QAASF,GAErB,WACL5I,EAAQ6I,QAAQE,eAAe,QAASH,EAC1C,CACF,GAAG,CAAC19C;AAEJ,IAOIy/C,EA1CW,SAASC,WACtB,IAAIC,EAAoB7K,EAAQ4K,WAC5Bp6C,EAASq6C,EAAkBr6C,OAC3BkT,EAASmnC,EAAkBnnC,OAC3Bs9B,EAAU6J,EAAkB7J;AAQhC,MALgB,CACdxwC,OAAQsnC,EAAUvrC,IAAIiE,EAAQtF,GAC9BwY,OAAQo0B,EAAUvrC,IAAImX,EAAQxY,GAC9B81C,QAASlJ,EAAUvrC,IAAIy0C,EAAS91C,GAGpC,CA6BgB0/C,GAEZjB,EAAiB3X,eAAeA,eAAe,CAAC,EAAGprB,GAAU,CAAC,EAAG,CACnEyxB,SAAU,SAASA,SAAS9uC,EAAIqgD,EAAKkB,GACnC1C,EAAWrzC,IAAIxL,EAAIqgD,GACnBhjC,EAAQyxB,SAAS9uC,EAAIqgD,EAAKkB,EAC5B,EACAxS,WAAY,SAASA,WAAW/uC,GAC9B6+C,EAAmB,OAAE7+C;AAErB,IAAK,IAAImsC,EAAO9kC,UAAUV,OAAQnB,EAAO,IAAIhE,MAAM2qC,EAAO,EAAIA,EAAO,EAAI,GAAI/L,EAAO,EAAGA,EAAO+L,EAAM/L,IAClG56B,EAAK46B,EAAO,GAAK/4B,UAAU+4B;AAG7B/iB,EAAQ0xB,WAAWjkC,MAAMuS,EAAS,CAACrd,GAAIkqB,OAAO1kB,GAChD,IAGEg8C,EAAyB/Y,eAAeA,eAAeA,eAAe,CAAC,EAAGoX,GAAoBsB,GAAY,CAAC,EAAG,CAChHxtC,MA1BU,SAASA,QACnBkrC,EAAWp6C,SAAQ,SAAU47C,GAC3BA,EAAIpG,SAAStmC,OACf,GACF,IAyBI8tC,EAA2BhZ,eAAeA,eAAe,CAAC,EAAGuX,GAAsBoB;AAEvF,MAAwB,mBAAbjtB,EACW,gBAAoB0a,EAAoBva,SAAU,CACpE/yB,MAAO6+C,GACO,gBAAoBnQ,EAAyB3b,SAAU,CACrE/yB,MAAOigD,GACO,gBAAoBtR,EAA2B5b,SAAU,CACvE/yB,MAAOkgD,GACNttB,EAASsU,eAAeA,eAAe,CACxCoX,kBAAmB2B,EACnBxB,oBAAqByB,GACpBD,GAAyBC,OAGV,gBAAoB5S,EAAoBva,SAAU,CACpE/yB,MAAO6+C,GACO,gBAAoBnQ,EAAyB3b,SAAU,CACrE/yB,MAAOigD,GACO,gBAAoBtR,EAA2B5b,SAAU,CACvE/yB,MAAOkgD,GACNttB,IACL;AAEA4sB,EAAWW,MAAQ,SAAUC,GAC3B,IAAIxtB,EAAWwtB,EAAMxtB;AAKrB,OAHkB,IAAA4F,YAAWgW,GACJprC,OAEXgH,KAAI,SAAUi2C,GAC1B,IAAI5B,EAAsB4B,EAAM5B,oBAC5BH,EAAoB+B,EAAM/B,kBAC1BpyB,EAAMuyB,EAAoBvyB;AAC9B,OAAoB,gBAAoByzB,EAAgB,CACtDzzB,IAAKA,EACLoyB,kBAAmBA,EACnBG,oBAAqBA,GACpB7rB,EACL,GACF;AAEA,IAAI0tB,EAAiB,SAASA,eAAe5K,GAC3C,IAAI6K,EAAa7K,EAAK6K,WAIlBC,GADc,IAAAhoB,YAAW8U,GACFkT;AAE3B,OAAKD,EACEA,EAAWn2C,KAAI,SAAUq2C,EAAMt2C,GACpC,IAAI8mC,EAAgBwP,EAAK,cACrB3F,EAAY0F,EAASvP;AACzB,OAAoB,gBAAoB6J,EAAW,CACjD5uB,IAAK,WAAWvD,OAAOxe,IAE3B,IAPwB,IAQ1B,EAEIu2C,GAAW9c,EAAM,yBAEjB+c,GAAa,SAASA,WAAWjL,GACnC,IAAIE,EAASF,EAAKE,OACd3R,EAASyR,EAAKzR,OACd2c,EAAqBlL,EAAKkL,mBAI1BJ,GADc,IAAAhoB,YAAW8U,GACFkT,SAGvBp9C,GAAS,IAAAu3C,UAAQ,WACnB,IAAIkG,EAzxDsB,SAASC,wBAAwBlL,EAAQgL,EAAoB3c,GACzF,IAAK2R,GAAUgL,EACb,MAAO;AAIT,IAAIG,EAAqBnL,EAAO5E,WAC5BA,OAAoC,IAAvB+P,EAAgC,CAAC,EAAIA,EAClDC,EAAQpL,EAAOoL,MACfC,EAAwBrL,EAAOsL,cAC/BA,OAA0C,IAA1BD,EAAmC,GAAKA;AAE5D,GAAIvhD,OAAOuD,KAAK+tC,GAAY5rC,OAAS,EAAG,CAEtC,IAAIhC,EAAS1D,OAAOuD,KAAK+tC,GAAY7U,MAAK,SAAU/J,EAAGnC,GACrD,IAAIkxB,EAASD,EAAch2C,QAAQknB,GAC/BgvB,EAASF,EAAch2C,QAAQ+kB;AACnC,OAAQkxB,GAAU,EAAIA,EAASD,EAAc97C,OAAS,IAAMg8C,GAAU,EAAIA,EAASF,EAAc97C,OAAS,EAC5G,IAAGgF,KAAI,SAAU4lC,GACf,IAAIvvC,EAAWuwC,EAAWhB;AAE1B,OADYD,EAAyBC,EAAcvvC,EAAUwjC,EAE/D;AAUA,OARI+c,GACF59C,EAAOkG,KAAK,CACV2nC,cAAe,eAEf+P,MAAOA,IAIJ59C,CACT,CAEA,MAAO,EACT,CAqvDuB09C,CAAwBlL,EAAQgL,EAAoB3c;AAkGvE,OAjGkB4c,EAAaz2C,KAAI,SAAUi3C,EAAal3C,GACxD,IAAI/J,EAAQihD,EAAYjhD,MACpBkmC,EAAQ+a,EAAY/a,MACpBpT,EAAOmuB,EAAYnuB,KACnB8d,EAAaqQ,EAAYrQ,WACzBT,EAAQ8Q,EAAY9Q,MACpBU,EAAgBoQ,EAAYpQ,cAC5Bb,EAAWiR,EAAYjR,SACvBC,EAAUgR,EAAYhR,QACtB2Q,EAAQK,EAAYL,MACpBlG,EAAY0F,EAASvP;AAIzB,OAFAyP,GAAS,kBAAmBtgD,EAAOihD,IAE9BvG,GAAsB,WAAT5nB,GAAqB8d,EACjB,gBAAoB2P,WAAY,CAClD/K,OAAQyL,EACRpd,OAAQ7jC,EACR8rB,IAAK,eAAevD,OAAOxe,MAK1B2wC,GAAsB,UAAT5nB,GAAoBqd,EAChB,gBAAoB+Q,GAAc1a,SAAS,CAC7D1a,IAAK,eAAevD,OAAOxe,GAC3B/J,MAAOA,EACPmwC,MAAOA,EACPH,SAAUA,EACVC,QAASA,GACR/J,IAIDwU,GAA+B,UAAlB7J,GAA6BV,GAAkB,UAATrd,EACjC,gBAAoB4nB,EAAWlU,SAAS,CAC1D1a,IAAK,eAAevD,OAAOxe,GAC3B/J,MAAOA,EACPmwC,MAAOA,EACPH,SAAUA,EACVC,QAASA,GACR/J,IAIiB,iBAAlB2K,EACK+P,EAAM52C,KAAI,SAAUm3C,GAWzB,IAAIC,EAAYD,EAAYrtC,KASxButC,EAAaF,EAAgB,GAAEvQ;AAYnC,OAAoB,gBAAoBsO,EAAU,CAChDpzB,IAAK,eAAevD,OAAOxe,GAC3Bo1C,KAZS,SAASA,KAAKvF,GACvB,IAAIt0C,EAASs0C,EAAMt0C;AAEnB,OAAOhG,OAAOuD,KAAKw+C,GAAY1zB,OAAM,SAAU7B,GAC7C,IAAIw1B,EAAYD,EAAWv1B;AAE3B,OAAOxmB,EAAOwmB,KAASw1B,EAAiB,KAC1C,GACF,GAKgB,gBAAoBf,WAAY,CAC9C/K,OAAQ4L,IAEZ,IAIG1G,EAIe,gBAAoBA,EAAWlU,SAAS,CAC1D1a,IAAK,eAAevD,OAAOxe,GAC3B/J,MAAOA,GACNkmC,IANM,IAOX,GAEF,GAAG,CAACsP,EAAQ3R;AACZ,OAAO7gC,CACT,EAEIk+C,GAAe,SAASA,aAAa5L,GACvC,IAAIt1C,EAAQs1C,EAAKt1C,MACbmwC,EAAQmF,EAAKnF,MACbH,EAAWsF,EAAKtF,SAChBC,EAAUqF,EAAKrF,QACf/J,EAAQoB,yBAAyBgO,EAAM,CAAC,QAAS,QAAS,WAAY;AAE1E,OAAoB,gBAAoB8J,EAAY5Y,SAAS,CAC3DxmC,MAAOA,GACNkmC,GAAqB,gBAAoBga,EAAgB,CAC1DC,WAAYnQ,IACG,gBAAoBoP,EAAWW,MAAO,MAAM,SAAUnG,GACrE,IAAI55C,EAAQ45C,EAAM55C;AAClB,OAAoB,gBAAoB,WAAgB,KAAmB,gBAAoBkgD,EAAgB,CAC7GC,WAAYhQ,EAAM,eACH,gBAAoBoQ,GAAY,CAC/C/K,OAAQrF,EACRtM,OAAQ7jC,IACO,gBAAoBkgD,EAAgB,CACnDC,WAAYhQ,EAAM,cAEtB,IAAiB,gBAAoB+P,EAAgB,CACnDC,WAAYlQ,IAEhB,EAEIsR,GAAkB,CACpBC,OAAQzF,EACR0F,MAAOlG,EACPmG,SAAUjG,EACVkG,SAAU1F,EACV2F,MAAO9E,EACPl4C,IArpBc,SAASi9C,YACvB,IACIj9C,EANN,SAASk9C,mBACP,OAAO,IAAA1pB,YAAWiW,EACpB,CAG0ByT,GACIl9C;AAE5B,OAAoB,gBAAoB,SAAU,CAChDm9C,QAAS,SAASA,UAChBn9C,GACF,EACAkuB,KAAM,UACL,MACL,EA4oBE6L,OAtoBgB,SAASkjB,YACzB,IACIljB,EANN,SAASqjB,uBACP,OAAO,IAAA5pB,YAAWkW,EACpB,CAG8B0T,GACOrjB;AAEnC,OAAoB,gBAAoB,SAAU,CAChDojB,QAAS,SAASA,UAChBpjB,GACF,EACA7L,KAAM,UACL,SACL,EA6nBEjrB,MAAOq5C,IAGLe,GAAUze,EAAM,yBAWhB0e,GAAO,SAASA,OAAQ,EAExBC,GAA8B,SAAUC,GAC1Cnb,UAAUkb,eAAgBC;AAE1B,IAAIn8C,EAAS4hC,aAAasa;AAE1B,SAASA,iBACP,IAAInhD,EAEAjD,EAAU2H,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,GAAmBA,UAAU,GAAK,CAAC;AAEnFogC,gBAAgB5oC,KAAMilD,iBAGtBnhD,EAAQiF,EAAO/D,KAAKhF,OACda,QAAUA;AAChB,IAAIskD,EAAMtkD,EAAQskD,IACd7M,EAASz3C,EAAQy3C,OACjB4K,EAAWriD,EAAQqiD;AAmPvB,OA3OAp/C,EAAMqhD,IAAMA,EAAM,IAAIA,EAAI,CACxBC,WAAW,IACR,KACLthD,EAAMuhD,YAAcF,EAAMrhD,EAAMqhD,IAAIG,QAAQhN,GAAU,KAEtDx0C,EAAMo/C,SAAWA,GAAYmB,GAK7BvgD,EAAMk8C,WAAa,IAAIjsC,IAKvBjQ,EAAMyhD,aAAe,CACnBphD,IAAK,SAASA,IAAIoI,GAChB,IAAIi5C;AAQJ,OANA1hD,EAAMk8C,WAAWp6C,SAAQ,SAAUlD,GAC7BA,GAASA,EAAMI,QAAUyJ,IAC3Bi5C,EAAc9iD,EAElB,IAEO8iD,CACT,GAGF1hD,EAAM2hD,SAAW,CAAC,EAElB3hD,EAAM4hD,iBAAmB,CAAC,EAC1B5hD,EAAM6hD,UAAY,CAAC,EAEnB7hD,EAAM8hD,YAAc,CAAC,EAErB9hD,EAAMihB,MAAQ,CACZ8gC,UAAU,EACVhgD,OAAO,EACPigD,SAAS,EACTC,QAAS,EACTnyB,KAAM,EACNoyB,WAAY,EACZC,YAAY,EACZ79C,OAAQ,CAAC,EACTkT,OAAQ,CAAC,EACTs9B,QAAS,CAAC,GAGZ90C,EAAMoiD,WAAa,CACjB9K,SAAU,CACRjL,SAAU6U,GACV5U,WAAY4U,GACZ3U,SAAU2U,GACVlwC,MAAOkwC,GACPhP,SAAUgP,GACVv2C,SAAUu2C,GACVzJ,WAAYyJ,GACZxJ,SAAUwJ,GACVvJ,cAAeuJ,GACfrJ,cAAeqJ,KAInBlhD,EAAMosC,WAAapsC,EAAMosC,WAAWxrB,KAAK+lB,uBAAuB3mC,IAChEA,EAAMmsC,SAAWnsC,EAAMmsC,SAASvrB,KAAK+lB,uBAAuB3mC,IAC5DA,EAAM2K,SAAW3K,EAAM2K,SAASiW,KAAK+lB,uBAAuB3mC,IAC5DA,EAAMy3C,WAAaz3C,EAAMy3C,WAAW72B,KAAK+lB,uBAAuB3mC,IAChEA,EAAM03C,SAAW13C,EAAM03C,SAAS92B,KAAK+lB,uBAAuB3mC,IAC5DA,EAAMqiD,UAAYriD,EAAMqiD,UAAUzhC,KAAK+lB,uBAAuB3mC,IAC9DA,EAAMqsC,SAAWrsC,EAAMqsC,SAASzrB,KAAK+lB,uBAAuB3mC,IAC5DA,EAAM8sC,UAAY9sC,EAAM8sC,UAAUlsB,KAAK+lB,uBAAuB3mC,IAC9DA,EAAMg3C,QAAUh3C,EAAMg3C,QAAQp2B,KAAK+lB,uBAAuB3mC,IAC1DA,EAAMsiD,QAAUtiD,EAAMsiD,QAAQ1hC,KAAK+lB,uBAAuB3mC,IAC1DA,EAAMuiD,KAAOviD,EAAMuiD,KAAK3hC,KAAK+lB,uBAAuB3mC,IACpDA,EAAMkb,KAAOlb,EAAMkb,KAAK0F,KAAK+lB,uBAAuB3mC,IACpDA,EAAMwiD,WAAaxiD,EAAMwiD,WAAW5hC,KAAK+lB,uBAAuB3mC,IAChEA,EAAMssC,WAAatsC,EAAMssC,WAAW1rB,KAAK+lB,uBAAuB3mC,IAChEA,EAAMusC,SAAWvsC,EAAMusC,SAAS3rB,KAAK+lB,uBAAuB3mC,IAC5DA,EAAMyiD,aAAeziD,EAAMyiD,aAAa7hC,KAAK+lB,uBAAuB3mC,IACpEA,EAAM0iD,WAAa1iD,EAAM0iD,WAAW9hC,KAAK+lB,uBAAuB3mC,IAChEA,EAAMgR,MAAQhR,EAAMgR,MAAM4P,KAAK+lB,uBAAuB3mC,IACtDA,EAAM6Z,OAAS7Z,EAAM6Z,OAAO+G,KAAK+lB,uBAAuB3mC,IACxDA,EAAMkyC,SAAWlyC,EAAMkyC,SAAStxB,KAAK+lB,uBAAuB3mC,IAC5DA,EAAM2iD,YAAc3iD,EAAM2iD,YAAY/hC,KAAK+lB,uBAAuB3mC,IAClEA,EAAM4iD,QAAU5iD,EAAM4iD,QAAQhiC,KAAK+lB,uBAAuB3mC,IAC1DA,EAAMwsC,SAAWxsC,EAAMwsC,SAAS5rB,KAAK+lB,uBAAuB3mC,IAC5DA,EAAM0sC,gBAAkB1sC,EAAM0sC,gBAAgB9rB,KAAK+lB,uBAAuB3mC,IAC1EA,EAAM+sC,gBAAkB/sC,EAAM+sC,gBAAgBnsB,KAAK+lB,uBAAuB3mC,IAC1EA,EAAMqyB,WAAaryB,EAAMqyB,WAAWzR,KAAK+lB,uBAAuB3mC,IAChEA,EAAM6iD,aAAe7iD,EAAM6iD,aAAajiC,KAAK+lB,uBAAuB3mC,IACpEA,EAAMysC,cAAgBzsC,EAAMysC,cAAc7rB,KAAK+lB,uBAAuB3mC,IACtEA,EAAMitC,cAAgBjtC,EAAMitC,cAAcrsB,KAAK+lB,uBAAuB3mC,IACtEA,EAAMktC,iBAAmBltC,EAAMktC,iBAAiBtsB,KAAK+lB,uBAAuB3mC,IAC5EA,EAAMgtC,iBAAmBhtC,EAAMgtC,iBAAiBpsB,KAAK+lB,uBAAuB3mC,IAC5EA,EAAM8iD,UAAY9iD,EAAM8iD,UAAUliC,KAAK+lB,uBAAuB3mC,IAC9DA,EAAM+iD,WAAa/iD,EAAM+iD,WAAWniC,KAAK+lB,uBAAuB3mC,IAChEA,EAAMgjD,YAAchjD,EAAMgjD,YAAYpiC,KAAK+lB,uBAAuB3mC,IAClEA,EAAMijD,cAAgBjjD,EAAMijD,cAAcriC,KAAK+lB,uBAAuB3mC,IACtEA,EAAMyW,OAASzW,EAAMyW,OAAOmK,KAAK+lB,uBAAuB3mC,IACxDA,EAAMkiD,WAAaliD,EAAMkiD,WAAWthC,KAAK+lB,uBAAuB3mC,IAChEA,EAAMkjD,UAAYljD,EAAMkjD,UAAUtiC,KAAK+lB,uBAAuB3mC,IAI9DA,EAAM0a,QAAU,CACdyxB,SAAUnsC,EAAMmsC,SAChBC,WAAYpsC,EAAMosC,WAClBI,SAAUxsC,EAAMwsC,SAChB3yB,OAAQ7Z,EAAM6Z,OAEdulC,SAAUp/C,EAAMo/C,SAChB/S,SAAU,SAASA,SAASsH,EAAS/0C,GACnC,IAAI8jC,IAAOh+B,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,KAAmBA,UAAU,GAEtE1F,EAAQgB,EAAMk8C,WAAW77C,IAAIszC;AAE5B30C,EAAMi0C,QACTrH,EAAU/iC,IAAI7I,EAAMihB,MAAM3c,OAAQtF,EAAMA,MAAOA,EAAMs4C,SAAS3sC,YAG3D3L,EAAMs4C,SAAS9D,SAASxzC,EAAMihB,MAAM3c,SACvCsnC,EAAkB,OAAE5rC,EAAMihB,MAAM3c,OAAQtF,EAAMA,OAKhDgB,EAAMk8C,WAAWp6C,SAAQ,SAAUquB,GAGjC,IAAI2nB,EAAS3nB,EAAEmnB,SAASO;AAEnB1nB,EAAEmnB,SAASM,kBAAkB53C,EAAMihB,MAAM3c,UAAYwzC,GAAW3nB,EAAE4iB,aACrEnH,EAAkB,OAAE5rC,EAAMihB,MAAM3c,OAAQ6rB,EAAEnxB,OAC1C4sC,EAAkB,OAAE5rC,EAAMihB,MAAM6zB,QAAS3kB,EAAEnxB,OAC3C4sC,EAAkB,OAAE5rC,EAAMihB,MAAMzJ,OAAQ2Y,EAAEnxB,OAE9C,IAEI0jC,IACF1iC,EAAM0iC,KAAK,UAEX1iC,EAAM0iC,KAAK,QAAS1jC,EAAMA,MAAOJ,GAErC,EACA0tC,WAAY,SAASA,WAAWqH,EAASwP,GACvC,IAAIzgB,IAAOh+B,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,KAAmBA,UAAU,GAEtE1F,EAAQgB,EAAMk8C,WAAW77C,IAAIszC;CAE5B30C,EAAMi0C,QAAUj0C,EAAMs4C,SAAST,iBAClCjL,EAAU/iC,IAAI7I,EAAMihB,MAAM6zB,QAAS91C,EAAMA,MAAOA,EAAMs4C,SAASG,cAI7Dz4C,EAAMi0C,QAAuCp3B,MAA7B7c,EAAMs4C,SAASI,YAA2B14C,EAAMs4C,SAAS9D,SAASxzC,EAAMihB,MAAM3c,SAChGsnC,EAAU/iC,IAAI7I,EAAMihB,MAAM6zB,QAAS91C,EAAMA,MAAOA,EAAMs4C,SAASG,cAG7D/U,GACF1iC,EAAM0iC,KAAK,SAGf,EACA6J,SAAU,SAASA,SAASoH,EAAS7hC,GACnC,IAAI4wB,IAAOh+B,UAAUV,OAAS,QAAsB6X,IAAjBnX,UAAU,KAAmBA,UAAU,GAEtE1F,EAAQgB,EAAMk8C,WAAW77C,IAAIszC;CAE5B30C,EAAMi0C,QAAUj0C,EAAMs4C,SAAST,iBAClCjL,EAAU/iC,IAAI7I,EAAMihB,MAAMzJ,OAAQxY,EAAMA,MAAOA,EAAMs4C,SAASI;AAIhE,IAAI0L,EAAexX,EAAUvrC,IAAIL,EAAMihB,MAAMzJ,OAAQxY,EAAMA,QAEvDA,EAAMi0C,QAAuCp3B,MAA7B7c,EAAMs4C,SAASI,YAA2B14C,EAAMs4C,SAAS9D,SAASxzC,EAAMihB,MAAM3c,SAGzFtF,EAAMi0C,aAAwCp3B,IAA9B7c,EAAMs4C,SAASI,YAA4B14C,EAAMs4C,SAAS9D,SAASxzC,EAAMihB,MAAM3c,SAC9E,iBAAjB8+C,IAHPxX,EAAU/iC,IAAI7I,EAAMihB,MAAMzJ,OAAQxY,EAAMA,MAAOA,EAAMs4C,SAASI,YAO5DhV,GACF1iC,EAAM0iC,KAAK,SAGf,EACA+J,cAAezsC,EAAMysC,cACrBC,gBAAiB1sC,EAAM0sC,iBAGzB1sC,EAAM8zC,QAAU,CACdzH,SAAUrsC,EAAMqsC,SAChBC,WAAYtsC,EAAMssC,WAClBC,SAAUvsC,EAAMusC,SAChBkW,aAAcziD,EAAMyiD,aACpBK,UAAW9iD,EAAM8iD,UACjB/V,gBAAiB/sC,EAAM+sC,gBACvBpiC,SAAU3K,EAAM2K,SAChB8sC,WAAYz3C,EAAMy3C,WAClBC,SAAU13C,EAAM03C,SAChB1mC,MAAOhR,EAAMgR,MACb0xC,WAAY1iD,EAAM0iD,WAClBhE,SAAU1+C,EAAM6iD,aAChB/V,UAAW9sC,EAAM8sC,UACjBD,aAAc7sC,EAAM6sC,aACpBmW,YAAahjD,EAAMgjD,YACnBtW,gBAAiB1sC,EAAM0sC,gBACvBwF,SAAUlyC,EAAMkyC,SAChB+Q,cAAejjD,EAAMijD,cACrBN,YAAa3iD,EAAM2iD,YACnBI,WAAY/iD,EAAM+iD,WAClB1wB,WAAYryB,EAAMqyB,WAClBsqB,QAAShW,uBAAuB3mC,GAChCitC,cAAejtC,EAAMitC,cACrBC,iBAAkBltC,EAAMktC,iBACxBF,iBAAkBhtC,EAAMgtC,iBACxBgK,QAASh3C,EAAMg3C,QACfsL,QAAStiD,EAAMsiD,QACfpnC,KAAMlb,EAAMkb,KACZqnC,KAAMviD,EAAMuiD,KACZC,WAAYxiD,EAAMwiD,WAClBU,UAAWljD,EAAMkjD,UACjBhB,WAAYliD,EAAMkiD,YAGpBliD,EAAM48C,GAAG,SAAS,SAAU59C,UAEnBgB,EAAMihB,MAAMnP,MAEnB9R,EAAMyW,OAAOzX,EACf,IAEOgB,CACT,CA2pBA,OAvpBAolC,aAAa+b,eAAgB,CAAC,CAC5Br2B,IAAK,aACLlsB,MAAO,SAASgmB,WAAW7nB,GACzBb,KAAKa,QAAUA,CACjB,GACC,CACD+tB,IAAK,WACLlsB,MAAO,SAASytC,SAAS5jC,EAAM7J,EAAO7B,GACpCb,KAAKswC,SAAS/jC,GAAM6uC,SAASjL,SAASztC,EAAO,KAAMknC,eAAe,CAChE+M,iBAAkB32C,KAAKa,QAAQo6C,mBAC9Bp6C,GACL,GACC,CACD+tB,IAAK,aACLlsB,MAAO,SAAS0tC,WAAW7jC,EAAM7J,GAC/B1C,KAAKswC,SAAS/jC,GAAM6uC,SAAShL,WAAW1tC,EAC1C,GACC,CACDksB,IAAK,WACLlsB,MAAO,SAAS2tC,SAAS9jC,EAAM7J,GAC7B1C,KAAKswC,SAAS/jC,GAAM6uC,SAAS/K,SAAS3tC,EACxC,GACC,CACDksB,IAAK,eACLlsB,MAAO,SAAS6jD,aAAa7jD,GAC3B1C,KAAK+kB,MAAMnP,MAAQlT,EACnB1C,KAAKwmC,KAAK,SACZ,GACC,CACD5X,IAAK,aACLlsB,MAAO,SAASsjD,aACdhmD,KAAK+kB,MAAMihC,WAAahmD,KAAK+kB,MAAMihC,WAAa,EAChDhmD,KAAKwmC,KAAK,SACZ,GACC,CACD5X,IAAK,YACLlsB,MAAO,SAASskD,UAAUz6C,EAAMqJ,GAE9B5V,KAAK+kB,MAAMihC,WAAahmD,KAAK+kB,MAAMihC,WAAa,EAE3ChmD,KAAKw7C,SAASjvC,IACjBvM,KAAKqwC,SAAS9jC,EAAMqJ,GAKlB5V,KAAK+kB,MAAMihC,WAAa,GAMxBhmD,KAAK+kB,MAAMkhC,aAETjmD,KAAKmnD,SACPpC,GAAQ,SAAU/kD,KAAK+kB,OACvB/kB,KAAKwmC,KAAK,YAEVue,GAAQ,SAAU/kD,KAAK+kB,OACvB/kB,KAAKwmC,KAAK,YAGZxmC,KAAK+kB,MAAMkhC,YAAa,GAfxBjmD,KAAKwmC,KAAK,SAmBd,GACC,CACD5X,IAAK,UACLlsB,MAAO,SAAS0jD,QAAQ1jD,GACtB1C,KAAK+kB,MAAM6O,KAAOlxB,EAClB1C,KAAKwmC,KAAK,SACZ,GACC,CACD5X,IAAK,aACLlsB,MAAO,SAAS4jD,WAAWc,GACzBpnD,KAAK+kB,MAAMsiC,QAAUD,EACrBpnD,KAAKwmC,KAAK,SACZ,GACC,CACD5X,IAAK,OACLlsB,MAAO,SAAS2jD,KAAKiB,GACnBtnD,KAAK+kB,MAAM6O,KAAO5zB,KAAK+kB,MAAM6O,KAAO,EACpC5zB,KAAK+kB,MAAMsiC,QAAUC,EACrBtnD,KAAKwmC,KAAK,SACZ,GACC,CACD5X,IAAK,OACLlsB,MAAO,SAASsc,KAAKuoC,GAEnBvnD,KAAKg2C,WAEDh2C,KAAKymD,gBACPzmD,KAAK+kB,MAAM6O,KAAO5zB,KAAK+kB,MAAM6O,KAAO,EACpC5zB,KAAK+kB,MAAMsiC,QAAUE,GAIvBvnD,KAAKwmC,KAAK,SACZ,GACC,CACD5X,IAAK,kBACLlsB,MAAO,SAASmuC,gBAAgB/tC,EAAOJ,GACrCgtC,EAAU/iC,IAAI3M,KAAKa,QAAQq/C,cAAep9C,EAAOJ,EACnD,GASC,CACDksB,IAAK,eACLlsB,MAAO,SAASikD,eAEd,OADA5B,GAAQ,wBACDnb,eAAeA,eAAe,CAAC,EAAG5pC,KAAK+kB,OAAQ,CAAC,EAAG,CACxD8gC,SAAU7lD,KAAK6lD,WACfhgD,MAAO7F,KAAK6F,QACZigD,QAAS9lD,KAAK8lD,WAElB,GA8BC,CACDl3B,IAAK,aACLlsB,MAAO,SAASs1C,aACd,OAAOh4C,KAAK43C,OACd,GACC,CACDhpB,IAAK,mBACLlsB,MAAO,SAASouC,iBAAiBvkC,GAC/B,IAAInE,EAASpI,KAAK4wC;AAClB,OAAOlB,EAAUvrC,IAAIiE,EAAQmE,EAC/B,GACC,CACDqiB,IAAK,WACLlsB,MAAO,SAAS+L,SAASlC,GACvB,IAAI7J,EAAQ1C,KAAKswC,SAAS/jC,GAAM6uC,SAAS3sC;AAEzC,OADAs2C,GAAQ,oBAAqBx4C,EAAM7J,GAC5BA,CACT,GACC,CACDksB,IAAK,aACLlsB,MAAO,SAAS64C,WAAWz4C,GACzB,IAAI81C,EAAU54C,KAAKswC,SAASxtC,GAAOs4C,SAASG;AAE5C,OADAwJ,GAAQ,sBAAuBjiD,EAAO81C,GAC/BA,CACT,GACC,CACDhqB,IAAK,WACLlsB,MAAO,SAAS84C,SAAS14C,GACvB,IAAI8S,EAAQ5V,KAAKswC,SAASxtC,GAAOs4C,SAASI;AAE1C,OADAuJ,GAAQ,oBAAqBjiD,EAAO8S,GAC7BA,CACT,GACC,CACDgZ,IAAK,YACLlsB,MAAO,SAASkuC,YAEd,OADAmU,GAAQ,mBACD/kD,KAAK+kB,MAAM3c,MACpB,GACC,CACDwmB,IAAK,gBACLlsB,MAAO,SAAS8kD,gBAEd,OADAzC,GAAQ,oBACD/kD,KAAK+kB,MAAM6zB,OACpB,GACC,CACDhqB,IAAK,YACLlsB,MAAO,SAASyjD,YAEd,OADApB,GAAQ,mBACD/kD,KAAK+kB,MAAMzJ,MACpB,GACC,CACDsT,IAAK,aACLlsB,MAAO,SAASyzB,aACd,OAAOn2B,KAAKa,OACd,GACC,CACD+tB,IAAK,UACLlsB,MAAO,SAASo4C,UACd,OAAO96C,KAAK+kB,MAAM6O,IACpB,GACC,CACDhF,IAAK,gBACLlsB,MAAO,SAASquC,cAAcxkC,GAC5B,IAAIzJ,EAAQ9C,KAAKulD,aAAaphD,IAAIoI;AAElC,OAAIzJ,GAASA,EAAMi0C,OACVrH,EAAUvrC,IAAInE,KAAK4lD,YAAa,UAAUv6B,OAAO9e,IAGnDmjC,EAAUvrC,IAAInE,KAAK4lD,YAAar5C,EACzC,GACC,CACDqiB,IAAK,mBACLlsB,MAAO,SAASsuC,iBAAiBzkC,GAC/B,IAAIzJ,EAAQ9C,KAAKulD,aAAaphD,IAAIoI;AAElC,OAAIzJ,GAASA,EAAMi0C,OACVrH,EAAkB,OAAE1vC,KAAK4lD,YAAa,UAAUv6B,OAAO9e,IAGzDmjC,EAAkB,OAAE1vC,KAAK4lD,YAAar5C,EAC/C,GACC,CACDqiB,IAAK,eACLlsB,MAAO,SAASiuC,aAAa7tC,GAC3B,OAAOA,CACT,GACC,CACD8rB,IAAK,kBACLlsB,MAAO,SAAS8tC,gBAAgB1tC,GAC9B,OAAO4sC,EAAUvrC,IAAInE,KAAKa,QAAQq/C,cAAep9C,EACnD,GACC,CACD8rB,IAAK,WACLlsB,MAAO,SAAS4tC,SAAS/jC,GACvBw4C,GAAQ,gBAAiBx4C;AACzB,IAAIzJ,EAAQ9C,KAAKulD,aAAaphD,IAAIoI;AAElC,OAAKzJ,GAII9C,KAAKkmD,UAIhB,GAEC,CACDt3B,IAAK,SACLlsB,MAAO,SAAS6X,OAAOzX,GACrB,IAAI2kD,EAASznD,KAIT0nD,EAAW1nD,KAAKswC,SAASxtC;AAEzB4kD,GAAYA,EAASntC,QAEvBmtC,EAASntC,OAAO3U,SAAQ,SAAUd,GAEhC,IAAI6iD,EAAQ,IAAIt8B,OAAOvoB,GACnBZ,EAAO,GAAGmpB,OAAOs8B,EAAMzgD,QAAQ,aAAc,MAAO,KAAKmkB,OAAOvmB,GAAWiF,MAAM,GAGjF69C,EAAWH,EAAOnX,SAASpuC;AAE3B0lD,IACF7C,GAAQ,YAAa6C,EAAS9kD,OAC9B8kD,EAASxM,SAASpF,WAClB4R,EAASxM,SAASO,gBAEtB,GAEJ,GACC,CACD/sB,IAAK,gBACLlsB,MAAO,SAASqkD,cAAcjkD,GAC5B9C,KAAKswC,SAASxtC,GAAOs4C,SAASpF,UAChC,GACC,CACDpnB,IAAK,aACLlsB,MAAO,SAASmkD,WAAW/jD,GACzB9C,KAAKswC,SAASxtC,GAAOs4C,SAAStmC,OAChC,GACC,CACD8Z,IAAK,cACLlsB,MAAO,SAASokD,YAAYhkD,GAC1B,OAAuC,MAAhC9C,KAAKulD,aAAaphD,IAAIrB,EAC/B,GACC,CACD8rB,IAAK,QACLlsB,MAAO,SAASykD,QACd,IAAI7rC,EAAStb,KAAKmmD;AAClB,SAAUzW,EAAUzkB,MAAM3P,IAAYtb,KAAK+kB,MAAMnP,MACnD,GACC,CACDgZ,IAAK,cACLlsB,MAAO,SAAS+jD,cAQd,OANYrkD,OAAOylD,QAAQ7nD,KAAKylD,UAAU9tC,MAAK,SAAUygC,GAIvD,OAHY5M,eAAe4M,EAAM,GACf,GAELgD,SAASI,UACxB,GAEF,GACC,CACD5sB,IAAK,UACLlsB,MAAO,SAASojD,UACd,IAAIxqC,EAAStb,KAAKmmD;AAClB,QAAWzW,EAAUzkB,MAAM3P,KAAWtb,KAAK+kB,MAAMnP,MACnD,GACC,CACDgZ,IAAK,WACLlsB,MAAO,SAASmjD,WACd,IAAIjN,EAAU54C,KAAKwnD,gBACfp/C,EAASpI,KAAK4wC;AAClB,OAAOlB,EAAUzkB,MAAM2tB,IAAYlJ,EAAUzkB,MAAM7iB,EACrD,GACC,CACDwmB,IAAK,QACLlsB,MAAO,SAASmD,QACd,OAAQ7F,KAAK6lD,UACf,GACC,CACDj3B,IAAK,QACLlsB,MAAO,SAASoS,QACdiwC,GAAQ,aAKR/kD,KAAKggD,WAAWp6C,SAAQ,SAAU9C,GAChCA,EAAMs4C,SAAStmC,MAAM,CACnB+lC,eAAe,GAEnB,IACA76C,KAAKwmC,KAAK,SACVxmC,KAAKwmC,KAAK,SACZ,GACC,CACD5X,IAAK,YACLlsB,MAAO,SAASkkD,UAAUx+C,GACxB28C,GAAQ,kBAKR/kD,KAAKggD,WAAWp6C,SAAQ,SAAU9C,GAEhC,IAAIJ,EAAQgtC,EAAUvrC,IAAIiE,EAAQtF,EAAMA;KAE1B6c,IAAVjd,GACFI,EAAMs4C,SAASjL,SAASztC,EAAO,KAAM,CACnCm4C,eAAe,GAGrB,IACA76C,KAAKwmC,KAAK,SACZ,GACC,CACD5X,IAAK,WACLlsB,MAAO,SAASszC,WACd,IAAI8R,EAAS9nD;AAEb+kD,GAAQ;AACR,IAAI38C,EAASpI,KAAK4wC;AAElB,GAAI5wC,KAAKa,QAAQq1C,iBAAkB,CACjC,IAAI56B,EA1sFY,SAASysC,kBAAkBzP,EAAQlwC,GACzD,IACEkwC,EAAOC,aAAanwC,EAAQ,CAC1BowC,YAAY,GAEhB,CAAE,MAAOv5B,GAEP,OADiB2yB,EAAgB3yB,EAEnC,CACF,CAisFqB8oC,CAAkB/nD,KAAKa,QAAQq1C,iBAAkB9tC;AAK9DpI,KAAKggD,WAAWp6C,SAAQ,SAAU9C,GAGhC,GAAI4sC,EAAUnrC,IAAI+W,EAAQxY,EAAMA,OAAQ,CACtC,IAAI8S,EAAQ85B,EAAUvrC,IAAImX,EAAQxY,EAAMA;AAExCglD,EAAOzX,SAASvtC,EAAMA,MAAO8S,EAC/B,MAEEkyC,EAAOzX,SAASvtC,EAAMA,WAAO6c,EAEjC,GACF,CAGA,GAAI3f,KAAKa,QAAQy3C,QAAUt4C,KAAKa,QAAQskD,IAAK,CAC3C,IAAI6C,EAlsFY,SAASC,kBAAkBjS,EAAUn0C,GAC3Dm0C,EAASn0C;AACT,IAAIyZ,EAAS,CAAC;AAsBd,OApBI06B,EAAS16B,QACX06B,EAAS16B,OAAO1V,SAAQ,SAAUwyC,GAChC,IAAIn2C,EAAUm2C,EAAKn2C,QACfimD,EAAW9P,EAAK8P,SAChBC,EAAU/P,EAAK+P,QACf9N,EAASjC,EAAKiC,OACdn4C,EAAOgmD;AAEK,aAAZC,IACFjmD,EAAO,GAAGmpB,OAAOnpB,EAAM,KAAKmpB,OAAOgvB,EAAO+N,kBAI5ClmD,EAAOA,EAAKgF,QAAQ,IAAK,IAGzBwoC,EAAU/iC,IAAI2O,EAAQpZ,EAAMD,EAC9B,IAGKqZ,CACT,CAyqFsB2sC,CAAkBjoD,KAAKqlD,YAAaj9C;AAMlDpI,KAAKggD,WAAWp6C,SAAQ,SAAU9C,GAGhC,GAAI4sC,EAAUnrC,IAAIyjD,EAASllD,EAAMA,OAAQ,CACvC,IAAI8S,EAAQ85B,EAAUvrC,IAAI6jD,EAASllD,EAAMA;AAEzCglD,EAAOzX,SAASvtC,EAAMA,MAAO8S,EAC/B,MAEEkyC,EAAOzX,SAASvtC,EAAMA,WAAO6c,EAEjC,GACF,CASA,GANA3f,KAAKggD,WAAWp6C,SAAQ,SAAU9C,GAChCA,EAAMs4C,SAASpF,SAAS5tC,GAExBtF,EAAMs4C,SAAShL,YAAW,GAAM,EAClC,IAEIpwC,KAAKa,QAAQm1C,SAAU,CACzB,IAAIlH,EAAM9uC,KAAKa,QAAQm1C,SAAS5tC;AAChCpI,KAAKumD,aAAazX,EACpB,CAGA,GAAI9uC,KAAKa,QAAQwnD,eAAgB,CAC/B,IAAIC,EAAWtoD,KAAKa,QAAQwnD,eAAejgD;AAM3CpI,KAAKggD,WAAWp6C,SAAQ,SAAU9C,GAGhC,GAAI4sC,EAAUnrC,IAAI+jD,EAAUxlD,EAAMA,OAAQ,CACxC,IAAI8S,EAAQ85B,EAAUvrC,IAAImkD,EAAUxlD,EAAMA;AAE1CglD,EAAOzX,SAASvtC,EAAMA,MAAO8S,EAC/B,CACF,GACF,CACF,GACC,CACDgZ,IAAK,gBACLlsB,MAAO,SAASuzC,gBACd8O,GAAQ;AACR,IAAI38C,EAASpI,KAAK4wC;AAElB5wC,KAAKggD,WAAWp6C,SAAQ,SAAU9C,GAChCA,EAAMs4C,SAASnF,cAAc7tC,EAC/B,GACF,GACC,CACDwmB,IAAK,UACLlsB,MAAO,SAASgkD,QAAQznC,GAEtB,GAAiB,IAAbA,EAAEspC,SAAiBvoD,KAAKa,QAAQ2nD,aAElC,OADAvpC,EAAEwpC,eAAexpC,IACV,CAEX,GACC,CACD2P,IAAK,aACLlsB,MAAO,SAAS8jD,WAAWvnC,GAEzBjf,KAAK+kB,MAAMghC,QAAU/lD,KAAK+kB,MAAMghC,QAAU,EAC1C/lD,KAAK+kB,MAAMkhC,YAAa,GAEnBjmD,KAAKa,QAAQ6nD,oBAAsBzpC,GAEtCA,EAAEwpC,eAAexpC,GAInBjf,KAAKg2C,WAELh2C,KAAKwmC,KAAK,UAEVxmC,KAAKi2C,gBAEDj2C,KAAK+kB,MAAMihC,WAAa,IAKxBhmD,KAAKmnD,SACPpC,GAAQ,SAAU/kD,KAAK+kB,OACvB/kB,KAAKwmC,KAAK,YAEVue,GAAQ,SAAU/kD,KAAK+kB,OACvB/kB,KAAKwmC,KAAK,YAGZxmC,KAAK+kB,MAAMkhC,YAAa,EACxBjmD,KAAKwmC,KAAK,UACZ,GAKC,CACD5X,IAAK,WACLlsB,MAAO,SAASutC,SAAS9uC,EAAI2B,EAAO4/C,GAClC,IAAIn2C,EAAOzJ,EAAMA,MACbiiB,EAAQjiB,EAAMiiB;AAClBggC,GAAQ,eAAgB5jD,EAAI,QAASoL,EAAMwY,EAAO,UAAW29B;AAE7D,IAEIiG,EAFAC,EAAar8C,EAAKxC,MAAM,GAA6B,GAA1BwC,EAAKs2B,YAAY,KAAat2B,EAAKs2B,YAAY,KAAO,EAAIt2B,EAAKzE;AAG9F9H,KAAKggD,WAAWp6C,SAAQ,SAAUlD,EAAOksB,GACnClsB,GAASA,EAAMI,QAAUyJ,IAC3Bo8C,EAAoB/5B,EAExB,IAGA+5B,IAAsB7lD,EAAM+zC,WAAa/zC,EAAM60C,cAC7CoN,GAAQ,qBAAsBx4C,GAC9BvM,KAAKggD,WAAmB,OAAE2I,IAE5BA,KAAuB7lD,EAAM+zC,WAAc/zC,EAAM60C,aAKjDoN,GAAQ,oBAAqB/kD,KAAKggD,WAAWllC,MAE7C9a,KAAKylD,SAAStkD,GAAM2B,EAEpB9C,KAAKggD,WAAWrzC,IAAIxL,EAAI2B,GAExBiiD,GAAQ,4BAA6B6D,UAC9B5oD,KAAK0lD,iBAAiBkD,UACtB5oD,KAAK2lD,UAAUiD,GAElB9lD,EAAMi0C,SAKV/2C,KAAKwe,QAAQ2xB,SAAShvC,EAAI2B,EAAMs4C,SAAS3sC,YAAY,GACrDzO,KAAKwe,QAAQ6xB,SAASlvC,EAAI2B,EAAMs4C,SAASI,YAAY,GACrDx7C,KAAKwe,QAAQ4xB,WAAWjvC,EAAI2B,EAAMs4C,SAASG,cAAc,GAEpDmH,GACH1iD,KAAKwmC,KAAK,UAEd,GACC,CACD5X,IAAK,aACLlsB,MAAO,SAASwtC,WAAW/uC,GACzB,IAAI2B,EAAQ9C,KAAKggD,WAAW77C,IAAIhD,GAC5BoL,EAAOzJ,EAAMA;AACjBiiD,GAAQ,aAAc5jD,EAAIoL,UAEnBvM,KAAKylD,SAAStkD;AAErB,IAAI0nD,EA/0BO,SAASC,WAAW5mD,EAAMwjD,GACzC,IAAIqD,EAAc3mD,OAAOuD,KAAK+/C,GAAkBsD,MAAK,SAAUp6B,GAC7D,OAAO1sB,EAAK+mD,SAASr6B,EACvB;AACA,GAAKm6B,EAEL,OADY7mD,EAAK6H,MAAM,EAAGg/C,EAAYjhD,UACrBihD,CACnB,CAw0B4BD,CAAWv8C,EAAMvM,KAAK0lD,kBAExCkD,EAAar8C,EAAKxC,MAAM,GAA6B,GAA1BwC,EAAKs2B,YAAY,KAAat2B,EAAKs2B,YAAY,KAAO,EAAIt2B,EAAKzE;CAG7FhF,EAAM+zC,YAAa/zC,EAAM60C,aACzBkR,IAEC9D,GAAQ,gBAAgB15B,OAAO9e,EAAM,YAAazJ,EAAMs4C,SAASK,iBAE5D34C,EAAMi0C,OAITrH,EAAU/iC,IAAI3M,KAAK4lD,YAAa,UAAUv6B,OAAO9e,GAAOzJ,EAAMs4C,SAASK,iBAHvE/L,EAAU/iC,IAAI3M,KAAK4lD,YAAar5C,EAAMzJ,EAAMs4C,SAASK,mBASzDoN,IACC/lD,EAAM+zC,YAAc/zC,EAAM60C,cAI1B70C,EAAMs4C,SAAST,kBAAoB73C,EAAM+zC,aAExCkO,GAAQ,iBAAkBx4C,GAC1BvM,KAAKggD,WAAmB,OAAE7+C,GAErB0nD,IACHnZ,EAAkB,OAAE1vC,KAAK+kB,MAAM3c,OAAQmE,GACvCmjC,EAAkB,OAAE1vC,KAAK+kB,MAAM6zB,QAASrsC,GACxCmjC,EAAkB,OAAE1vC,KAAK+kB,MAAMzJ,OAAQ/O,GAElCzJ,EAAMi0C,OAGTrH,EAAkB,OAAE1vC,KAAK4lD,YAAa,UAAUv6B,OAAO9e,IAFvDmjC,EAAkB,OAAE1vC,KAAK4lD,YAAar5C,IAOtCs8C,GAAmB7oD,KAAK2lD,UAAUiD,KACpC7D,GAAQ,cAAex4C,EAAM,mBAAoBq8C,GACjDlZ,EAAUG,QAAQ7vC,KAAK+kB,MAAM3c,OAAQwgD,GACrClZ,EAAUG,QAAQ7vC,KAAK+kB,MAAM6zB,QAASgQ,GACtClZ,EAAUG,QAAQ7vC,KAAK+kB,MAAMzJ,OAAQstC,GACrClZ,EAAUG,QAAQ7vC,KAAK4lD,YAAagD,UAG7B5oD,KAAK2lD,UAAUiD,KAI1B5oD,KAAKwmC,KAAK,SACZ,GACC,CACD5X,IAAK,gBACLlsB,MAAO,SAAS6tC,cAAchkC,GAC5Bw4C,GAAQ,uBAAwBx4C,GAChCvM,KAAK0lD,iBAAiBn5C,IAAQ,EAC9BvM,KAAK2lD,UAAUp5C,IAAQ,CACzB,GACC,CACDqiB,IAAK,SACLlsB,MAAO,SAASib,OAAOxc,EAAI2B,EAAOomD,GAChCnE,GAAQ,SAAU5jD,EAAI2B,EAAMA,MAAOomD,EAASpmD,EAAM+4C,WAAWn5C;AAG7D,IAAIA,EAAQI,EAAMs4C,SAAS3sC,WACvBmH,EAAQ9S,EAAMs4C,SAASI,WACvBvoB,EAAInwB,EAAMs4C,SAASG,aAEnB4N,EAAWnpD,KAAKulD,aAAaphD,IAAI+kD;AAGjCA,IAAYC,IAEdzZ,EAAU/iC,IAAI3M,KAAK+kB,MAAM3c,OAAQ8gD,GACjCxZ,EAAU/iC,IAAI3M,KAAK+kB,MAAMzJ,OAAQ4tC,GACjCxZ,EAAU/iC,IAAI3M,KAAK+kB,MAAM6zB,QAASsQ,IAIpCxZ,EAAU/iC,IAAI3M,KAAK+kB,MAAM3c,OAAQtF,EAAMA,MAAOJ,GAC9CgtC,EAAU/iC,IAAI3M,KAAK+kB,MAAMzJ,OAAQxY,EAAMA,MAAO8S,GAC9C85B,EAAU/iC,IAAI3M,KAAK+kB,MAAM6zB,QAAS91C,EAAMA,MAAOmwB,GAC/CjzB,KAAKwmC,KAAK,SACZ,KAGKye,cACT,CAj6BkC,CAi6BhC,EAAAmE,cAEEC,GAAW/iB,EAAM,6BAEjBgjB,GAAe,SAASA,aAAalR,GACvC,IAAI9iB,EAAW8iB,EAAK9iB,SAChBsiB,EAAUQ,EAAKR,QACfR,EAAiBgB,EAAKhB,eACtBmS,EAAYnR,EAAKmR,UACjBrL,EAAO9T,yBAAyBgO,EAAM,CAAC,WAAY,UAAW,iBAAkB;AAIpF,GAFAiR,GAAS,uBAELzR,EAIF,OAHAyR,GAAS,yCAGW,gBAAoBrZ,EAAoBva,SAAU,CACpE/yB,MAAO00C,EAAe54B,SACR,gBAAoBkyB,EAAejb,SAAU,CAC3D/yB,MAAOk1C,GACO,gBAAoBnH,EAAiBhb,SAAU,CAC7D/yB,MAAO6mD,GACNj0B;AAGL+zB,GAAS;AAGT,IAAI3mD,EAAQ8mD,GAAQtL;AACpB,OAAoB,gBAAoBlO,EAAoBva,SAAU,CACpE/yB,MAAOA,EAAM00C,eAAe54B,SACd,gBAAoBkyB,EAAejb,SAAU,CAC3D/yB,MAAOA,EAAMk1C,SACC,gBAAoBnH,EAAiBhb,SAAU,CAC7D/yB,MAAOA,EAAM6mD,WACZj0B,IACL,EAEIm0B,GAAWnjB,EAAM,wBAEjBkjB,GAAU,SAASA,QAAQpR,GAC7B,IAAIsQ,EAAqBtQ,EAAKsQ,mBAC1BxI,EAAgB9H,EAAK8H,cACrBlK,EAAWoC,EAAKpC,SAChBqS,EAAiBjQ,EAAKiQ,eACtBpN,EAAoB7C,EAAK6C,kBACzBuN,EAAepQ,EAAKoQ,aACpBkB,EAAStR,EAAKsR,OACdC,EAASvR,EAAKuR,OACdzS,EAAWkB,EAAKlB,SAChB0S,EAAUxR,EAAKwR,QACfC,EAAWzR,EAAKyR,SAChBjT,EAAgBwB,EAAKxB,cACrBkT,EAAkB1R,EAAK0R,gBACvB5T,EAAmBkC,EAAKlC,iBACxBoC,EAASF,EAAKE,OACd6M,EAAM/M,EAAK+M,IACXjC,EAAW9K,EAAK8K,SAChBI,EAAqBlL,EAAKkL,mBAC1B9L,EAAYpN,yBAAyBgO,EAAM,CAAC,qBAAsB,gBAAiB,WAAY,iBAAkB,oBAAqB,eAAgB,SAAU,SAAU,WAAY,UAAW,WAAY,gBAAiB,kBAAmB,mBAAoB,SAAU,MAAO,WAAY;AAEtSqR,GAAS;AAET,IAAIM,GAAwB,IAAA1M,UAAQ,WAClC,MAAO,CACLqL,mBAAoBA,EACpBxI,cAAeA,EACflK,SAAUA,EACVqS,eAAgBA,EAChBpN,kBAAmBA,EACnBuN,aAAcA,EACdtS,iBAAkBA,EAClBoC,OAAQA,EACR6M,IAAKA,EACLjC,SAAUA,EAEd,GAAG,CAACwF,EAAoBxI,EAAelK,EAAUqS,EAAgBpN,EAAmBuN,EAActS,EAAkBoC,EAAQ6M,EAAKjC,IAM7H9L,EADa5L,gBAHD,IAAAvP,WAAS,WACvB,OAAO,IAAIgpB,GAAe8E,EAC5B,IAC2C,GACX,IAGhC,IAAAjuB,YAAU,WACRsb,EAAe1uB,WAAWqhC,EAC5B,GAAG,CAACA;AAEJ,IAGIC,EAAaxe,gBAHA,IAAAvP,WAAS,WACxB,OAAOmb,EAAeuP,cACxB,IAC4C,GACxC4C,EAAYS,EAAW,GACvBC,EAAeD,EAAW;AAG9B5U,GAA0B,WACxB,IAAIoL,EAAkB,SAASA,kBAC7B,OAAOtJ,GAAYA,EAASE,EAAeuP,eAC7C,EAEIuD,EAAiB,SAASA,iBAC5B,OAAON,GAAWA,GACpB,EAEIO,EAAkB,SAASA,kBAC7B,OAAON,GAAYA,EAASzS,EAAeuP,eAAev+C,OAC5D,EAEIgiD,EAAiB,SAASA,iBAC5B,OAAOxT,GAAiBA,EAAcQ,EAAeuP,eAAev+C,OACtE,EAEIiiD,EAAmB,SAASA,mBAC9B,OAAOP,GAAmBA,EAAgB1S,EAAeuP,eAAerrC,OAC1E;AASA,OANA87B,EAAesJ,GAAG,SAAUF,GAC5BpJ,EAAesJ,GAAG,QAASwJ,GAC3B9S,EAAesJ,GAAG,SAAUyJ,GAC5B/S,EAAesJ,GAAG,QAAS0J,GAC3BhT,EAAesJ,GAAG,UAAW2J,GAEtB,WACLjT,EAAeuJ,eAAe,SAAUH,GACxCpJ,EAAeuJ,eAAe,QAASuJ,GACvC9S,EAAeuJ,eAAe,SAAUwJ,GACxC/S,EAAeuJ,eAAe,QAASyJ,GACvChT,EAAeuJ,eAAe,UAAW0J,EAC3C,CACF,GAAG,CAACnT,EAAU0S,EAASC,EAAUjT,EAAekT,KAEhD,IAAA7tB,WAAS,WAQPmb,EAAesJ,GAAG,UANY,SAAS4J,0BACrCb,GAAS,sBACTQ,EAAa7S,EAAeuP,eAC9B,IAKI+C,GACFA,EAAOtS,EAAeY,cAGpB2R,IACFA,EAAOjuB,QAAU0b,EAAeY,aAEpC;AAEA,IAIIJ,EADapM,gBAHA,IAAAvP,WAAS,WACxB,OAAOmb,EAAeY,YACxB,IAC4C,GACnB;AAkBzB,MAAO,CACLJ,QAASA,EACT2R,UAAWA,EACXnS,eAAgBA,EAChBgG,OAfW,SAASA,OAAO9nB,GAC3B,OAAoB,gBAAoBg0B,GAAc,CACpD1R,QAASA,EACT2R,UAAWA,EACXnS,eAAgBA,GACF,gBAAoB,WAAgB,KAAO9hB,GAAwB,gBAAoB+tB,GAAY,CACjH/K,OAAQA,EACRgL,mBAAoBA,KAExB,EAOE9L,UAAWA,EAEf,EAEI+S,GAAUjkB,EAAM,qBAEhBkkB,GAAO,SAASA,KAAKpS,GACvB,IAAI9iB,EAAW8iB,EAAK9iB,SAChBm1B,EAAarS,EAAKgF,OAClBgK,EAAYhP,EAAKgP,UACjBlJ,EAAO9T,yBAAyBgO,EAAM,CAAC,WAAY,SAAU;AAEjEmS,GAAQ;AAER,IAAIG,EAAWlB,GAAQtL,GACnBtG,EAAU8S,EAAS9S,QACnBR,EAAiBsT,EAAStT,eAC1BmS,EAAYmB,EAASnB,UACrBnM,EAASsN,EAAStN,OAClB5F,EAAYkT,EAASlT;AAyBzB,OAAO4F,EAAqB,gBAAoB,OAAQ9T,SAAS,CAAC,EAAGkO,EAAW,CAC9EoS,QAASxS,EAAetiC,MACxB+0C,SAAUzS,EAAeoP,WACzBmE,UAAWvT,EAAesP,UA1BX,SAASkE,aACxB,IAAI5hB,EAAQ,CACVugB,UAAWA,EACX3R,QAASA;AAGX,OAAIwP,EACkB,gBAAoBA,EAAWpe,EAAO1T,GAGxDm1B,EACKA,EAAWzhB,GAGI,mBAAb1T,EACFA,EAAS0T,GAGX1T,CACT,CAQIs1B,IACN;AA0ZA,IA2EIC,GAAgB,SAASA,cAAcjT,EAAS90C,GAClD,MAAO,CAGL2L,SAAU,SAASA,WACjB,OAAOmpC,EAAQnpC,SAAS3L,EAC1B,EACAqtC,SAAU,SAASA,SAASztC,GAC1B,OAAOk1C,EAAQzH,SAASrtC,EAAOJ,EACjC,EACA64C,WAAY,SAASA,aACnB,OAAO3D,EAAQ2D,WAAWz4C,EAC5B,EACAstC,WAAY,SAASA,WAAW1tC,GAC9B,OAAOk1C,EAAQxH,WAAWttC,EAAOJ,EACnC,EACA84C,SAAU,SAASA,WACjB,OAAO5D,EAAQ4D,SAAS14C,EAC1B,EACAutC,SAAU,SAASA,SAAS3tC,GAC1B,OAAOk1C,EAAQvH,SAASvtC,EAAOJ,EACjC,EACAoS,MAAO,SAASA,QACd,OAAO8iC,EAAQiP,WAAW/jD,EAC5B,EACAkzC,SAAU,SAASA,WACjB,OAAO4B,EAAQmP,cAAcjkD,EAC/B,EACAgoD,OAAQ,SAASA,SACf,OAAOlT,EAAQkP,YAAYhkD,EAC7B,EAEJ;AAEA,SAASioD,YAAYjoD,GACnB,IAAI80C,EAAUrG;AAId,OAHe,IAAA8L,UAAQ,WACrB,OAAOwN,GAAcjT,EAAS90C,EAChC,GAAG,CAACA,GAEN,CAEA,IAAIkoD,GAAkB,SAASA,gBAAgB5P,GAC7C,MAAO,CACL14C,MAAO04C,EAAS3sC,WAChBmqC,QAASwC,EAASG,aAClB3lC,MAAOwlC,EAASI,WAEpB;AAEA,SAASyP,cAAcnoD,GACrB,IAAIs4C,EAAW2P,YAAYjoD;AAEXi/C;AAGhB,OADiBiJ,GAAgB5P,EAEnC,CAEA,IAsBI8P,GAAS,SAASA,OAAO9S,GAC3B,IAAI11C,EAAQ01C,EAAK11C,MACbi7C,EAAevF,EAAKuF,aACpBroB,EAAW8iB,EAAK9iB,SAChB4oB,EAAO9T,yBAAyBgO,EAAM,CAAC,QAAS,eAAgB;AAEpE,OAAoB,gBAAoB,SAAU9O,SAAS,CACzD3kC,IAAKg5C,EACLj7C,MAAOA,EACPksB,IAAKlsB,GACJw7C,GAAO5oB,EACZ,C;;AC3oJO,IAAI61B,EAAoB,IACpBC,EAAwB,I;;;ACDnC,uBAA0B1oD,GACxB,OAAOC,MAAMC,QAAQF,EACtB,ECFD,kBAA0BA,GACxB,MAAwB,iBAAVA,CACf;;ACFD,8BAA0BiI,GACxB,OAAOA,EAAMA,EAAM7C,OAAS,EAC7B;;ACAD,yBAA0B8tB,GACxB,OAAqC,IAA9BA,EAAKhoB,QAFG,KAE0B,IAAUgoB,GAAQA,EAAKtK,MAFjD,KAEmExe,IAAI,KAAWuiB,KAFlF,IAGhB,ECJD,uBAA0B1kB,EAAO0J,GAC/B,OAAO1J,EAAMwgB,QAAO,SAAUkgC,EAAeC,GAC3C,OAAOj3C,EAASg3C,EAAeC,EACjC,GAAG,CAAC,EACL;ACFD,SAAe,E,SAAA,GAAgBC,EAAA;;ACF/B,uBAA0B7oD,GACxB,OAAwB,IAAjBA,EAAMoF,MACd;ACCc,SAAS0jD,wBAAwBC,EAAoBC,GAClE,IAAItT,OAAiB,IAAVsT,EAAmB,CAAC,EAAIA,EAC/BC,EAAiBvT,EAAKtL,UACtBA,OAA+B,IAAnB6e,EAA4B,IAAoBA,EAC5DhlB,EAASyR,EAAKzR;AAElB,SAASilB,UAAUC,EAAgBC,EAA6BC,GAC9D,IAAIC,EAAgBC,UAAUF,EAA0BvmB;AAEpD/E,QAAQsrB,GACVD,EAA4BE,GAAiBP,EAAmBI,IAE3DC,EAA4BE,KAC/BF,EAA4BE,GAAiB,CAAC,GAGhDJ,UAAUC,EAAgBC,EAA4BE,GAAgBD,GAE1E,CAEA,IAAIG,EAAuB,CAAC;AAK5B,OAJA9pD,OAAO+pD,oBAAoBV,GAAoB7lD,SAAQ,SAAUgwB,GAC/D,IAAIw2B,EAAiBzlB,EAAS/Q,EAAK1uB,QAAQ,GAAKy/B,EAASmG,EAAW,IAAMlX;AAC1E,OAAOg2B,UAAUh2B,EAAMs2B,EAAsBE,EAAe9gC,MAAMwhB,GACpE,IACOof,CACT,CC7BA,sBAA0BxpD,GACxB,OAAiB,OAAVA,CACR;ACEc,SAAS2pD,aAAaz2B,EAAM02B,EAAgBC,QAClC,IAAnBD,IACFA,EAAiBE,EAAA,GAGnB,KAAU,EAAAC,EAAA,GAAWH,IAAmBI,OAAOJ,GAAiB;AAChE,IAAIK,EAAsBD,OAAOJ,IAAmBA,IAAmBE,EAAA,EAAWA,EAAA,EAAW,SAAUI,GACrG,IAAK,IAAItf,EAAO9kC,UAAUV,OAAQnB,EAAO,IAAIhE,MAAM2qC,EAAO,EAAIA,EAAO,EAAI,GAAI/L,EAAO,EAAGA,EAAO+L,EAAM/L,IAClG56B,EAAK46B,EAAO,GAAK/4B,UAAU+4B;AAG7B,OAAOqrB,aAAgB1iC,MAAQ0iC,EAAON,EAAergD,WAAM,EAAQ,CAAC2gD,GAAMvhC,OAAO1kB,GACnF,EACIkmD,GAAU,EAAAJ,EAAA,GAAWF,GACrBO,EAAal3B,EAAKsO,WAElB6oB,EAAgB,SAASA,gBAC3B,IAAI1nC,EAAUsnC,EAAoB1gD,WAAM,EAAQzD,WAC5Csc,EAAS,CACX8Q,KAAMA;AAeR,OAZIvQ,aAAmB6E,QACrBpF,EAAOlP,OAAQ,QAGD+J,IAAZ0F,IACFP,EAAOO,QAAUA,GAGfwnC,IACF/nC,EAAOkoC,KAAOT,EAAYtgD,WAAM,EAAQzD,YAGnCsc,CACT;AAMA,OAJAioC,EAAc7oB,SAAW,WACvB,OAAO4oB,CACT,EAEOC,CACT,CC9CA,SAASE,cAAc3sB,GAAU,IAAK,IAAIzzB,EAAI,EAAGA,EAAIrE,UAAUV,OAAQ+E,IAAK,CAAE,IAAI82B,EAAyB,MAAhBn7B,UAAUqE,GAAarE,UAAUqE,GAAK,CAAC,EAAO08B,EAAUnnC,OAAOuD,KAAKg+B;AAAqD,mBAAjCvhC,OAAOgxB,wBAAwCmW,EAAUA,EAAQle,OAAOjpB,OAAOgxB,sBAAsBuQ,GAAQt7B,QAAO,SAAUqhC,GAAO,OAAOtnC,OAAOunC,yBAAyBhG,EAAQ+F,GAAKtiB,UAAY,MAAOmiB,EAAQ3jC,SAAQ,SAAUgpB,GAAOya,gBAAgB/I,EAAQ1R,EAAK+U,EAAO/U,GAAO,GAAI,CAAE,OAAO0R,CAAQ,CAEhe,SAAS+I,gBAAgBlhC,EAAKymB,EAAKlsB,GAAiK,OAApJksB,KAAOzmB,EAAO/F,OAAO+kB,eAAehf,EAAKymB,EAAK,CAAElsB,MAAOA,EAAO0kB,YAAY,EAAMC,cAAc,EAAM+N,UAAU,IAAkBjtB,EAAIymB,GAAOlsB,EAAgByF,CAAK,CAgBjM,SAAS+kD,cAAcC,GACpC,IAAK,IAAI7f,EAAO9kC,UAAUV,OAAQslD,EAAkB,IAAIzqD,MAAM2qC,EAAO,EAAIA,EAAO,EAAI,GAAI/L,EAAO,EAAGA,EAAO+L,EAAM/L,IAC7G6rB,EAAgB7rB,EAAO,GAAK/4B,UAAU+4B;AAGxC,IAAI1gC,GAAU,EAAA0qD,EAAA,GAAc8B,eAAeD,IAAoBA,EAAgB3gD,MAAQ,CAAC;AAGxF,OAFA,IAAU2gD,EAAgB38B,MAAM68B,YAAcA,SAASH,KAAc,EAAA5B,EAAA,GAAc4B,IAAa,4DAE5FG,SAASH,GACJI,kCAAkC,CAACJ,GAAW9hC,OAAO+hC,GAAkBvsD,GAGzEosD,cAAc,CAAC,EAGxB,SAASO,4BAA4BL,EAAWtsD,GAC9C,IAAI4sD,EAAgBC,EAAiBP,EAAWtsD;AAEhD,OAAO2qD,wBADkBmC,0BAA0BF,GACA5sD,EACrD,CAP2B2sD,CAA4BL,EAAWtsD,GAAU0sD,kCAAkCH,EAAiBvsD,GAC/H,CAQA,SAAS8sD,0BAA0BR,EAAWzB,GAC5C,IAAItT,OAAiB,IAAVsT,EAAmB,CAAC,EAAIA,EAC/B/kB,EAASyR,EAAKzR,OACdglB,EAAiBvT,EAAKtL,UACtBA,OAA+B,IAAnB6e,EAA4B,IAAoBA;AAiBhE,OAAOiC,cAAcxrD,OAAOuD,KAAKwnD,IAAY,SAAUU,EAAuBj4B,GAC5E,IAAIgU,EAEAkkB,EAAiBX,EAAUv3B;AAC/B,IAnBF,SAASm4B,sBAAsBD,GAC7B,IAAI,EAAArB,EAAA,GAAWqB,KAAmB,EAAAE,EAAA,GAAMF,GACtC,OAAO;AAGT,GAAIlrD,QAAQkrD,GAAiB,CAC3B,IAAIG,EAAmBH,EAAe,GAClCzoC,OAA+B,IAArB4oC,EAA8BzB,EAAA,EAAWyB,EACnDjB,EAAOc,EAAe;AAC1B,OAAO,EAAArB,EAAA,GAAWpnC,KAAY,EAAAonC,EAAA,GAAWO,EAC3C,CAEA,OAAO,CACT,CAMYe,CAAsBD,GAAiB,oFAA4Fl4B;AAC7I,IAAIs4B,EAAevnB,EAAS,GAAKA,EAASmG,EAAYlX,EAAOA,EACzDm3B,EAAgBnqD,QAAQkrD,GAAkBzB,aAAapgD,WAAM,EAAQ,CAACiiD,GAAc7iC,OAAOyiC,IAAmBzB,aAAa6B,EAAcJ;AAC7I,OAAOb,cAAc,CAAC,EAAGY,IAAwBjkB,EAAiB,CAAC,GAAkBhU,GAAQm3B,EAAenjB,GAC9G,GACF,CAEA,SAAS2jB,kCAAkCH,EAAiBvsD,GAC1D,IAKIstD,EAAiBR,0BALLC,cAAcR,GAAiB,SAAUgB,EAAkBx4B,GACzE,IAAIy4B;AAEJ,OAAOpB,cAAc,CAAC,EAAGmB,IAAmBC,EAAiB,CAAC,GAAkBz4B,GAAQ42B,EAAA,EAAU6B,GACpG,IAC0DxtD;AAC1D,OAAO+sD,cAAcxrD,OAAOuD,KAAKwoD,IAAiB,SAAUN,EAAuBj4B,GACjF,IAAI04B;AAEJ,OAAOrB,cAAc,CAAC,EAAGY,IAAwBS,EAAiB,CAAC,GAAkBrC,UAAUr2B,IAASu4B,EAAev4B,GAAO04B,GAChI,GACF,C;;;AC/EA,SAAe,E,SAAA,IAAgB,SAAU52C,GACvC,QAAQ,EAAA6zC,EAAA,GAAc7zC,KAAS,EAAA62C,EAAA,GAAM72C,MCJxB,SAAS82C,sBAAsB3jC,GAC5C,IAAIllB,GAAO,EAAA4jC,EAAA,GAAQ1e,GACf4jC,EAAwB9oD,EAAK8qB,OAAM,SAAUi+B,GAC/C,MAAkB,SAAXA,GAAgC,UAAXA,CAC9B;AACA,OAAO/oD,EAAKmC,QAAUnC,EAAKmC,QAAU,GAAK2mD,CAC5C,CDFkDD,CAAsB92C,EACxE;;AENA,2BAA0BhV,GACxB,YAAiBid,IAAVjd,CACR,ECFD,wBAA0BA,GACxB,OAAOA,EAAMwhC,UACd;;;ACMc,SAASyqB,cAAcppB,EAAUqpB,EAAc/tD,QAC5C,IAAZA,IACFA,EAAU,CAAC,GAGb,KAAU,EAAA0qD,EAAA,GAAchmB,KAAa,EAAAgpB,EAAA,GAAMhpB,GAAW;AACtD,IAAIspB,EAAsBC,EAAkBvpB,EAAU1kC,GAClDkuD,GAAW,EAAAxlB,EAAA,GAAQslB,GAAqB/hD,KAAI,SAAU8oB,GACxD,OCRW,SAASo5B,aAAap5B,EAAMq5B,EAASL,QAClC,IAAZK,IACFA,EAAUzC,EAAA;AAGZ,IAAI0C,EAAQ,eAASt5B,GAAMtK,MAAM;AACjC,KAAW6jC,YAAYP,GAAe,qCAAuCM,EAAM7/B,KAAK,MAAQ,sBAChG,KAAU,EAAAo9B,EAAA,GAAWwC,KAAY,EAAA1D,EAAA,GAAc0D,GAAU;AAEzD,IAAI7W,GAAO,EAAAqU,EAAA,GAAWwC,GAAW,CAACA,EAASA,GAAW,CAACA,EAAQjwC,KAAMiwC,EAAQG,OAAOtiD,KAAI,SAAUuiD,GAChG,OAAO,EAAArB,EAAA,GAAMqB,GAAY7C,EAAA,EAAW6C,CACtC,IACIC,EAAclX,EAAK,GACnBmX,EAAenX,EAAK;AAExB,OAAO,SAAUrzB,EAAOD,QACR,IAAVC,IACFA,EAAQ6pC;AAGV,IAAIY,EAAa1qC,EAAO8Q;AAExB,OAAK45B,IAAuD,IAAzCN,EAAMthD,QAAQ,eAAS4hD,MAIjB,IAAjB1qC,EAAOlP,MAAiB25C,EAAeD,GAAavqC,EAAOD,GAH1DC,CAIX,CACF,CDpBWiqC,CAAap5B,GAAM,EAAAzxB,EAAA,GAAIyxB,EAAMi5B,GAAsBD,EAC5D,IACIK,EAAU,eAAqB,EAAQF,EAAS1jC,OAAO,CAACujC;AAC5D,OAAO,SAAU7pC,EAAOD,GAKtB,YAJc,IAAVC,IACFA,EAAQ6pC,GAGHK,EAAQlqC,EAAOD,EACxB,CACF,C;;;AEvBA,0CAA0B2qC,GACxB,OAAO,SAASC,QAAQ5iD,EAAK4+C,EAAOiE,EAAgBC,GAClD,IAAIxX,OAAiB,IAAVsT,EAAmB,CAAC,EAAIA,EAC/BC,EAAiBvT,EAAKtL,UACtBA,OAA+B,IAAnB6e,EAA4B,IAAoBA,EAC5DhlB,EAASyR,EAAKzR;AA4ClB,YA1CuB,IAAnBgpB,IACFA,EAAiB,CAAC,QAGU,IAA1BC,IACFA,EAAwB,KAwB1B,OAAQ9iD,GAAKlH,SAAQ,SAAUgwB,GAC7B,IAAIo2B,EATN,SAAS6D,cAAcj6B,GACrB,OAAIg6B,IAA0BjpB,GAAUA,GAAU,IAAI8G,OAAO,IAAM9G,EAASmG,GAAWvhB,KAAKqK,GACnFA,EAGF,GAAK+Q,EAASmG,EAAYlX,CACnC,CAGsBi6B,CAtBtB,SAASC,iBAAiBl6B,GACxB,IAAI8mB;AAEJ,IAAKkT,EAAuB,OAAOh6B;AACnC,IAAIs5B,EAAQt5B,EAAKsO,WAAW5Y,MAAM,KAC9BykC,EAAWH,EAAsBtkC,MAAM;AAC3C,OAAQoxB,EAAQ,IAAIrxB,OAAOpf,MAAMywC,EAAOqT,EAASjjD,KAAI,SAAUuf,GAC7D,OAAO6iC,EAAMpiD,KAAI,SAAUmmB,GACzB,MAAO,GAAK5G,EAAIygB,EAAY7Z,CAC9B,GACF,KAAI5D,KAAK,IACX,CAWoCygC,CAAiBl6B,IAC/Co6B,GAAW,OAAIp6B,EAAM9oB;AAErB2iD,EAAUO,GACZN,QAAQM,EAAU,CAChBljB,UAAWA,EACXnG,OAAQA,GACPgpB,EAAgB3D,GAEnB2D,EAAe3D,GAAiBgE,CAEpC,IACOL,CACT,CACD,C;;;ACrDc,SAASxrD,IAAIyqB,EAAKhN,GAC/B,OAAO,OAAMA,GAAKA,EAAEzd,IAAIyqB,GAAOhN,EAAEgN,EACnC,C;;ACHA,0CAA0BlsB,GACxB,OAAOA,CACR,C;;ACFD,0CAA0BA,GACxB,MAAwB,mBAAVA,CACf,C;;ACFD,0CAA0BA,GACxB,MAAsB,oBAARqR,KAAuBrR,aAAiBqR,GACvD,C;;ACFD,0CAA0BrR,GACxB,OAAOA,OACR,C;;ACFD,0CAA0BA,GACxB,GAAqB,iBAAVA,GAAgC,OAAVA,EAAgB,OAAO;AAGxD,IAFA,IAAIutD,EAAQvtD,EAE4B,OAAjCN,OAAO6hC,eAAegsB,IAC3BA,EAAQ7tD,OAAO6hC,eAAegsB;AAGhC,OAAO7tD,OAAO6hC,eAAevhC,KAAWutD,CACzC,C;;;ACRc,SAAS1mB,QAAQ7oC,GAC9B,IAAI,OAAMA,GAQR,OAAOiC,MAAMyD,KAAK1F,EAAOiF;AAG3B,GAAuB,oBAAZolC,SAAsD,mBAApBA,QAAQxB,QACnD,OAAOwB,QAAQxB,QAAQ7oC;AAGzB,IAAIiF,EAAOvD,OAAO+pD,oBAAoBzrD;AAMtC,MAJ4C,mBAAjC0B,OAAOgxB,wBAChBztB,EAAOA,EAAK0lB,OAAOjpB,OAAOgxB,sBAAsB1yB,KAG3CiF,CACT,C;ACxBA,SAASuqD,sBAAsBC,GAC7B,OAAO,SAAU/X,GACf,IAAIgY,EAAWhY,EAAKgY,SAChB5N,EAAWpK,EAAKoK;AACpB,OAAO,SAAUxjC,GACf,OAAO,SAAU8F,GACf,MAAsB,mBAAXA,EACFA,EAAOsrC,EAAU5N,EAAU2N,GAG7BnxC,EAAK8F,EACd,CACF,CACF,CACF,C;AAEA,IAAIurC,EAAQH;AACZG,EAAMC,kBAAoBJ;AAE1B,S;;cCXIK,EAAe,SAASA,eAC1B,OAAO9+B,KAAKG,SAASsS,SAAS,IAAIssB,UAAU,GAAGllC,MAAM,IAAI+D,KAAK,IAChE,EAEIohC,EAAc,CAChBC,KAAM,eAAiBH,IACvBI,QAAS,kBAAoBJ,IAC7BK,qBAAsB,SAASA,uBAC7B,MAAO,+BAAiCL,GAC1C;AAOF,SAAShF,cAAcpjD,GACrB,GAAmB,iBAARA,GAA4B,OAARA,EAAc,OAAO;AAGpD,IAFA,IAAI8nD,EAAQ9nD,EAE4B,OAAjC/F,OAAO6hC,eAAegsB,IAC3BA,EAAQ7tD,OAAO6hC,eAAegsB;AAGhC,OAAO7tD,OAAO6hC,eAAe97B,KAAS8nD,CACxC,CA4BA,SAASY,YAAY5B,EAAS6B,EAAgBC,GAC5C,IAAIrU;AAEJ,GAA8B,mBAAnBoU,GAAqD,mBAAbC,GAA+C,mBAAbA,GAAmD,mBAAjBvoD,UAAU,GAC/H,MAAM,IAAI0hB,MAAM;AAQlB,GAL8B,mBAAnB4mC,QAAqD,IAAbC,IACjDA,EAAWD,EACXA,OAAiBnxC,QAGK,IAAboxC,EAA0B,CACnC,GAAwB,mBAAbA,EACT,MAAM,IAAI7mC,MAAM;AAGlB,OAAO6mC,EAASF,YAATE,CAAsB9B,EAAS6B,EACxC,CAEA,GAAuB,mBAAZ7B,EACT,MAAM,IAAI/kC,MAAM;AAGlB,IAAI8mC,EAAiB/B,EACjBgC,EAAeH,EACfI,EAAmB,GACnBC,EAAgBD,EAChBE,GAAgB;AASpB,SAASC,+BACHF,IAAkBD,IACpBC,EAAgBD,EAAiBnnD,QAErC,CAQA,SAASy4C,WACP,GAAI4O,EACF,MAAM,IAAIlnC,MAAM;AAGlB,OAAO+mC,CACT,CA0BA,SAASlyC,UAAUlE,GACjB,GAAwB,mBAAbA,EACT,MAAM,IAAIqP,MAAM;AAGlB,GAAIknC,EACF,MAAM,IAAIlnC,MAAM;AAGlB,IAAIonC,GAAe;AAGnB,OAFAD,+BACAF,EAAcnlD,KAAK6O,GACZ,SAAS6G,cACd,GAAK4vC,EAAL,CAIA,GAAIF,EACF,MAAM,IAAIlnC,MAAM;AAGlBonC,GAAe,EACfD;AACA,IAAI7gC,EAAQ2gC,EAAcvjD,QAAQiN;AAClCs2C,EAAchkB,OAAO3c,EAAO,GAC5B0gC,EAAmB,IAVnB,CAWF,CACF,CA4BA,SAASd,SAAStrC,GAChB,IAAKymC,cAAczmC,GACjB,MAAM,IAAIoF,MAAM;AAGlB,QAA2B,IAAhBpF,EAAO8Q,KAChB,MAAM,IAAI1L,MAAM;AAGlB,GAAIknC,EACF,MAAM,IAAIlnC,MAAM;AAGlB,IACEknC,GAAgB,EAChBH,EAAeD,EAAeC,EAAcnsC,EAC9C,CAAE,QACAssC,GAAgB,CAClB,CAIA,IAFA,IAAI73C,EAAY23C,EAAmBC,EAE1BtkD,EAAI,EAAGA,EAAI0M,EAAUzR,OAAQ+E,IAAK,EAEzCgO,EADetB,EAAU1M,KAE3B,CAEA,OAAOiY,CACT,CA4EA,OAHAsrC,SAAS,CACPx6B,KAAM66B,EAAYC,QAEbhU,EAAQ,CACb0T,SACArxC,UACAyjC,SACA+O,eAnEF,SAASA,eAAejC,GACtB,GAA2B,mBAAhBA,EACT,MAAM,IAAIplC,MAAM;AAGlB8mC,EAAiB1B,EAKjBc,SAAS,CACPx6B,KAAM66B,EAAYE,SAEtB,IAuDS,KA9CT,SAASvwC,aACP,IAAIg4B,EAEAoZ,EAAiBzyC;AACrB,OAAOq5B,EAAO,CASZr5B,UAAW,SAASA,UAAUyC,GAC5B,GAAwB,iBAAbA,GAAsC,OAAbA,EAClC,MAAM,IAAIiT,UAAU;AAGtB,SAASg9B,eACHjwC,EAASxC,MACXwC,EAASxC,KAAKwjC,WAElB,CAIA,OAFAiP,eAEO,CACL/vC,YAFgB8vC,EAAeC,cAInC,IACM,KAAgB,WACtB,OAAOzxD,IACT,EAAGo4C,CACL,EAaqCsE,CACvC,CAyBA,SAASgV,8BAA8B9iC,EAAK9J,GAC1C,IAAI0qC,EAAa1qC,GAAUA,EAAO8Q;AAElC,MAAO,UADiB45B,GAAc,WAAcp/C,OAAOo/C,GAAc,KAAQ,aAC3C,cAAiB5gC,EAAhD,gLACT,CA+DA,SAAS+iC,gBAAgB5C,GAIvB,IAHA,IAAI6C,EAAcxvD,OAAOuD,KAAKopD,GAC1B8C,EAAgB,CAAC,EAEZhlD,EAAI,EAAGA,EAAI+kD,EAAY9pD,OAAQ+E,IAAK,CAC3C,IAAI+hB,EAAMgjC,EAAY/kD;AAElB,EAMyB,mBAAlBkiD,EAASngC,KAClBijC,EAAcjjC,GAAOmgC,EAASngC,GAElC,CAEA,IASIkjC,EATAC,EAAmB3vD,OAAOuD,KAAKksD;AAWnC,KAjEF,SAASG,mBAAmBjD,GAC1B3sD,OAAOuD,KAAKopD,GAAUnpD,SAAQ,SAAUgpB,GACtC,IAAIqgC,EAAUF,EAASngC;AAKvB,QAA4B,IAJTqgC,OAAQtvC,EAAW,CACpCiW,KAAM66B,EAAYC,OAIlB,MAAM,IAAIxmC,MAAM,YAAe0E,EAAf;AAGlB,QAEO,IAFIqgC,OAAQtvC,EAAW,CAC5BiW,KAAM66B,EAAYG,yBAElB,MAAM,IAAI1mC,MAAM,YAAe0E,EAAf,6EAA0G6hC,EAAYC,KAAtH,8SAEpB,GACF,CAiDIsB,CAAmBH,EACrB,CAAE,MAAO5yC,GACP6yC,EAAsB7yC,CACxB,CAEA,OAAO,SAASgzC,YAAYltC,EAAOD,GAKjC,QAJc,IAAVC,IACFA,EAAQ,CAAC,GAGP+sC,EACF,MAAMA;AAcR,IAX2C,IAQvCI,GAAa,EACbC,EAAY,CAAC,EAER5pD,EAAK,EAAGA,EAAKwpD,EAAiBjqD,OAAQS,IAAM,CACnD,IAAIg5B,EAAOwwB,EAAiBxpD,GACxB0mD,EAAU4C,EAActwB,GACxB6wB,EAAsBrtC,EAAMwc,GAC5B8wB,EAAkBpD,EAAQmD,EAAqBttC;AAEnD,QAA+B,IAApButC,EAAiC,CAC1C,IAAIvoC,EAAe4nC,8BAA8BnwB,EAAMzc;AACvD,MAAM,IAAIoF,MAAMJ,EAClB,CAEAqoC,EAAU5wB,GAAQ8wB,EAClBH,EAAaA,GAAcG,IAAoBD,CACjD,CAGA,OADAF,EAAaA,GAAcH,EAAiBjqD,SAAW1F,OAAOuD,KAAKof,GAAOjd,QACtDqqD,EAAYptC,CAClC,CACF,CAEA,SAASutC,kBAAkBvF,EAAeqD,GACxC,OAAO,WACL,OAAOA,EAASrD,EAAc9gD,MAAMjM,KAAMwI,WAC5C,CACF,CAwBA,SAAS+pD,mBAAmBpE,EAAgBiC,GAC1C,GAA8B,mBAAnBjC,EACT,OAAOmE,kBAAkBnE,EAAgBiC;AAG3C,GAA8B,iBAAnBjC,GAAkD,OAAnBA,EACxC,MAAM,IAAIjkC,MAAM,0EAA+F,OAAnBikC,EAA0B,cAAgBA,GAAtH;AAGlB,IAAIqE,EAAsB,CAAC;AAE3B,IAAK,IAAI5jC,KAAOu/B,EAAgB,CAC9B,IAAIpB,EAAgBoB,EAAev/B;AAEN,mBAAlBm+B,IACTyF,EAAoB5jC,GAAO0jC,kBAAkBvF,EAAeqD,GAEhE,CAEA,OAAOoC,CACT,CAEA,SAASnpB,gBAAgBlhC,EAAKymB,EAAKlsB,GAYjC,OAXIksB,KAAOzmB,EACT/F,OAAO+kB,eAAehf,EAAKymB,EAAK,CAC9BlsB,MAAOA,EACP0kB,YAAY,EACZC,cAAc,EACd+N,UAAU,IAGZjtB,EAAIymB,GAAOlsB,EAGNyF,CACT,CAEA,SAASohC,QAAQ7oC,EAAQ8oC,GACvB,IAAI7jC,EAAOvD,OAAOuD,KAAKjF;AASvB,OAPI0B,OAAOgxB,uBACTztB,EAAKqG,KAAKC,MAAMtG,EAAMvD,OAAOgxB,sBAAsB1yB,IAGjD8oC,IAAgB7jC,EAAOA,EAAK0C,QAAO,SAAUqhC,GAC/C,OAAOtnC,OAAOunC,yBAAyBjpC,EAAQgpC,GAAKtiB,UACtD,KACOzhB,CACT,CAgCA,SAAS8sD,UACP,IAAK,IAAInlB,EAAO9kC,UAAUV,OAAQ4qD,EAAQ,IAAI/vD,MAAM2qC,GAAO/L,EAAO,EAAGA,EAAO+L,EAAM/L,IAChFmxB,EAAMnxB,GAAQ/4B,UAAU+4B;AAG1B,OAAqB,IAAjBmxB,EAAM5qD,OACD,SAAU8P,GACf,OAAOA,CACT,EAGmB,IAAjB86C,EAAM5qD,OACD4qD,EAAM,GAGRA,EAAMvnC,QAAO,SAAU2J,EAAGnC,GAC/B,OAAO,WACL,OAAOmC,EAAEnC,EAAE1mB,WAAM,EAAQzD,WAC3B,CACF,GACF,CAmBA,SAASmqD,kBACP,IAAK,IAAIrlB,EAAO9kC,UAAUV,OAAQ8qD,EAAc,IAAIjwD,MAAM2qC,GAAO/L,EAAO,EAAGA,EAAO+L,EAAM/L,IACtFqxB,EAAYrxB,GAAQ/4B,UAAU+4B;AAGhC,OAAO,SAAUsvB,GACf,OAAO,WACL,IAAIvqD,EAAQuqD,EAAY5kD,WAAM,EAAQzD,WAElCqqD,EAAY,SAASzC,WACvB,MAAM,IAAIlmC,MAAM,yHAClB,EAEI4oC,EAAgB,CAClBtQ,SAAUl8C,EAAMk8C,SAChB4N,SAAU,SAASA,WACjB,OAAOyC,EAAU5mD,WAAM,EAAQzD,UACjC,GAEEuqD,EAAQH,EAAY9lD,KAAI,SAAUkmD,GACpC,OAAOA,EAAWF,EACpB;AAEA,OA5FN,SAASlpB,eAAetJ,GACtB,IAAK,IAAIzzB,EAAI,EAAGA,EAAIrE,UAAUV,OAAQ+E,IAAK,CACzC,IAAI82B,EAAyB,MAAhBn7B,UAAUqE,GAAarE,UAAUqE,GAAK,CAAC;AAEhDA,EAAI,EACN08B,QAAQ5F,GAAQ,GAAM/9B,SAAQ,SAAUgpB,GACtCya,gBAAgB/I,EAAQ1R,EAAK+U,EAAO/U,GACtC,IACSxsB,OAAOynC,0BAChBznC,OAAO0nC,iBAAiBxJ,EAAQl+B,OAAOynC,0BAA0BlG,IAEjE4F,QAAQ5F,GAAQ/9B,SAAQ,SAAUgpB,GAChCxsB,OAAO+kB,eAAemZ,EAAQ1R,EAAKxsB,OAAOunC,yBAAyBhG,EAAQ/U,GAC7E,GAEJ,CAEA,OAAO0R,CACT,CA0EasJ,CAAe,CAAC,EAAGtjC,EAAO,CAC/B8pD,SAFFyC,EAAYJ,QAAQxmD,WAAM,EAAQ8mD,EAAtBN,CAA6BnsD,EAAM8pD,WAIjD,CACF,CACF,C","file":"6496.09a42b25526f76a2c607.js","sourcesContent":["export var Cache;\n(function (Cache) {\n})(Cache || (Cache = {}));\n//# sourceMappingURL=Cache.js.map","import { wrap } from 'optimism';\nimport { getFragmentQueryDocument, } from \"../../utilities/index.js\";\nvar ApolloCache = (function () {\n    function ApolloCache() {\n        this.getFragmentDoc = wrap(getFragmentQueryDocument);\n    }\n    ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {\n        this.performTransaction(transaction, optimisticId);\n    };\n    ApolloCache.prototype.transformDocument = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.identify = function (object) {\n        return;\n    };\n    ApolloCache.prototype.gc = function () {\n        return [];\n    };\n    ApolloCache.prototype.modify = function (options) {\n        return false;\n    };\n    ApolloCache.prototype.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.read({\n            rootId: options.id || 'ROOT_QUERY',\n            query: options.query,\n            variables: options.variables,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.read({\n            query: this.getFragmentDoc(options.fragment, options.fragmentName),\n            variables: options.variables,\n            rootId: options.id,\n            optimistic: optimistic,\n        });\n    };\n    ApolloCache.prototype.writeQuery = function (options) {\n        return this.write({\n            dataId: options.id || 'ROOT_QUERY',\n            result: options.data,\n            query: options.query,\n            variables: options.variables,\n            broadcast: options.broadcast,\n        });\n    };\n    ApolloCache.prototype.writeFragment = function (options) {\n        return this.write({\n            dataId: options.id,\n            result: options.data,\n            variables: options.variables,\n            query: this.getFragmentDoc(options.fragment, options.fragmentName),\n            broadcast: options.broadcast,\n        });\n    };\n    return ApolloCache;\n}());\nexport { ApolloCache };\n//# sourceMappingURL=cache.js.map","var MissingFieldError = (function () {\n    function MissingFieldError(message, path, query, variables) {\n        this.message = message;\n        this.path = path;\n        this.query = query;\n        this.variables = variables;\n    }\n    return MissingFieldError;\n}());\nexport { MissingFieldError };\n//# sourceMappingURL=common.js.map","import { isReference, isField, DeepMerger, } from \"../../utilities/index.js\";\nexport var hasOwn = Object.prototype.hasOwnProperty;\nexport function getTypenameFromStoreObject(store, objectOrReference) {\n    return isReference(objectOrReference)\n        ? store.get(objectOrReference.__ref, \"__typename\")\n        : objectOrReference && objectOrReference.__typename;\n}\nvar FieldNamePattern = /^[_A-Za-z0-9]+/;\nexport function fieldNameFromStoreName(storeFieldName) {\n    var match = storeFieldName.match(FieldNamePattern);\n    return match ? match[0] : storeFieldName;\n}\nexport function storeValueIsStoreObject(value) {\n    return value !== null &&\n        typeof value === \"object\" &&\n        !isReference(value) &&\n        !Array.isArray(value);\n}\nexport function isFieldValueToBeMerged(value) {\n    var field = value && value.__field;\n    return field && isField(field);\n}\nexport function makeProcessedFieldsMerger() {\n    return new DeepMerger(reconcileProcessedFields);\n}\nvar reconcileProcessedFields = function (existingObject, incomingObject, property) {\n    var existing = existingObject[property];\n    var incoming = incomingObject[property];\n    if (isFieldValueToBeMerged(existing)) {\n        existing.__value = this.merge(existing.__value, isFieldValueToBeMerged(incoming)\n            ? incoming.__value\n            : incoming);\n        return existing;\n    }\n    if (isFieldValueToBeMerged(incoming)) {\n        incoming.__value = this.merge(existing, incoming.__value);\n        return incoming;\n    }\n    return this.merge(existing, incoming);\n};\n//# sourceMappingURL=helpers.js.map","import { __assign, __extends } from \"tslib\";\nimport { dep, KeyTrie } from 'optimism';\nimport { equal } from '@wry/equality';\nimport { isReference, makeReference, DeepMerger, maybeDeepFreeze, canUseWeakMap, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName } from \"./helpers.js\";\nvar DELETE = Object.create(null);\nvar delModifier = function () { return DELETE; };\nvar EntityStore = (function () {\n    function EntityStore(policies, group) {\n        var _this = this;\n        this.policies = policies;\n        this.group = group;\n        this.data = Object.create(null);\n        this.rootIds = Object.create(null);\n        this.refs = Object.create(null);\n        this.getFieldValue = function (objectOrReference, storeFieldName) { return maybeDeepFreeze(isReference(objectOrReference)\n            ? _this.get(objectOrReference.__ref, storeFieldName)\n            : objectOrReference && objectOrReference[storeFieldName]); };\n        this.canRead = function (objOrRef) {\n            return isReference(objOrRef)\n                ? _this.has(objOrRef.__ref)\n                : typeof objOrRef === \"object\";\n        };\n        this.toReference = function (objOrIdOrRef, mergeIntoStore) {\n            if (typeof objOrIdOrRef === \"string\") {\n                return makeReference(objOrIdOrRef);\n            }\n            if (isReference(objOrIdOrRef)) {\n                return objOrIdOrRef;\n            }\n            var id = _this.policies.identify(objOrIdOrRef)[0];\n            if (id) {\n                var ref = makeReference(id);\n                if (mergeIntoStore) {\n                    _this.merge(id, objOrIdOrRef);\n                }\n                return ref;\n            }\n        };\n    }\n    EntityStore.prototype.toObject = function () {\n        return __assign({}, this.data);\n    };\n    EntityStore.prototype.has = function (dataId) {\n        return this.lookup(dataId, true) !== void 0;\n    };\n    EntityStore.prototype.get = function (dataId, fieldName) {\n        this.group.depend(dataId, fieldName);\n        if (hasOwn.call(this.data, dataId)) {\n            var storeObject = this.data[dataId];\n            if (storeObject && hasOwn.call(storeObject, fieldName)) {\n                return storeObject[fieldName];\n            }\n        }\n        if (fieldName === \"__typename\" &&\n            hasOwn.call(this.policies.rootTypenamesById, dataId)) {\n            return this.policies.rootTypenamesById[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.get(dataId, fieldName);\n        }\n    };\n    EntityStore.prototype.lookup = function (dataId, dependOnExistence) {\n        if (dependOnExistence)\n            this.group.depend(dataId, \"__exists\");\n        return hasOwn.call(this.data, dataId) ? this.data[dataId] :\n            this instanceof Layer ? this.parent.lookup(dataId, dependOnExistence) : void 0;\n    };\n    EntityStore.prototype.merge = function (dataId, incoming) {\n        var _this = this;\n        var existing = this.lookup(dataId);\n        var merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);\n        this.data[dataId] = merged;\n        if (merged !== existing) {\n            delete this.refs[dataId];\n            if (this.group.caching) {\n                var fieldsToDirty_1 = Object.create(null);\n                if (!existing)\n                    fieldsToDirty_1.__exists = 1;\n                Object.keys(incoming).forEach(function (storeFieldName) {\n                    if (!existing || existing[storeFieldName] !== merged[storeFieldName]) {\n                        fieldsToDirty_1[fieldNameFromStoreName(storeFieldName)] = 1;\n                        if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {\n                            delete merged[storeFieldName];\n                        }\n                    }\n                });\n                Object.keys(fieldsToDirty_1).forEach(function (fieldName) { return _this.group.dirty(dataId, fieldName); });\n            }\n        }\n    };\n    EntityStore.prototype.modify = function (dataId, fields) {\n        var _this = this;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var changedFields_1 = Object.create(null);\n            var needToMerge_1 = false;\n            var allDeleted_1 = true;\n            var readField_1 = function (fieldNameOrOptions, from) { return _this.policies.readField(typeof fieldNameOrOptions === \"string\" ? {\n                fieldName: fieldNameOrOptions,\n                from: from || makeReference(dataId),\n            } : fieldNameOrOptions, { store: _this }); };\n            Object.keys(storeObject).forEach(function (storeFieldName) {\n                var fieldName = fieldNameFromStoreName(storeFieldName);\n                var fieldValue = storeObject[storeFieldName];\n                if (fieldValue === void 0)\n                    return;\n                var modify = typeof fields === \"function\"\n                    ? fields\n                    : fields[storeFieldName] || fields[fieldName];\n                if (modify) {\n                    var newValue = modify === delModifier ? DELETE :\n                        modify(maybeDeepFreeze(fieldValue), {\n                            DELETE: DELETE,\n                            fieldName: fieldName,\n                            storeFieldName: storeFieldName,\n                            isReference: isReference,\n                            toReference: _this.toReference,\n                            canRead: _this.canRead,\n                            readField: readField_1,\n                        });\n                    if (newValue === DELETE)\n                        newValue = void 0;\n                    if (newValue !== fieldValue) {\n                        changedFields_1[storeFieldName] = newValue;\n                        needToMerge_1 = true;\n                        fieldValue = newValue;\n                    }\n                }\n                if (fieldValue !== void 0) {\n                    allDeleted_1 = false;\n                }\n            });\n            if (needToMerge_1) {\n                this.merge(dataId, changedFields_1);\n                if (allDeleted_1) {\n                    if (this instanceof Layer) {\n                        this.data[dataId] = void 0;\n                    }\n                    else {\n                        delete this.data[dataId];\n                    }\n                    this.group.dirty(dataId, \"__exists\");\n                }\n                return true;\n            }\n        }\n        return false;\n    };\n    EntityStore.prototype.delete = function (dataId, fieldName, args) {\n        var _a;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var typename = this.getFieldValue(storeObject, \"__typename\");\n            var storeFieldName = fieldName && args\n                ? this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })\n                : fieldName;\n            return this.modify(dataId, storeFieldName ? (_a = {},\n                _a[storeFieldName] = delModifier,\n                _a) : delModifier);\n        }\n        return false;\n    };\n    EntityStore.prototype.evict = function (options) {\n        var evicted = false;\n        if (options.id) {\n            if (hasOwn.call(this.data, options.id)) {\n                evicted = this.delete(options.id, options.fieldName, options.args);\n            }\n            if (this instanceof Layer) {\n                evicted = this.parent.evict(options) || evicted;\n            }\n            if (options.fieldName || evicted) {\n                this.group.dirty(options.id, options.fieldName || \"__exists\");\n            }\n        }\n        return evicted;\n    };\n    EntityStore.prototype.clear = function () {\n        this.replace(null);\n    };\n    EntityStore.prototype.replace = function (newData) {\n        var _this = this;\n        Object.keys(this.data).forEach(function (dataId) {\n            if (!(newData && hasOwn.call(newData, dataId))) {\n                _this.delete(dataId);\n            }\n        });\n        if (newData) {\n            Object.keys(newData).forEach(function (dataId) {\n                _this.merge(dataId, newData[dataId]);\n            });\n        }\n    };\n    EntityStore.prototype.retain = function (rootId) {\n        return this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1;\n    };\n    EntityStore.prototype.release = function (rootId) {\n        if (this.rootIds[rootId] > 0) {\n            var count = --this.rootIds[rootId];\n            if (!count)\n                delete this.rootIds[rootId];\n            return count;\n        }\n        return 0;\n    };\n    EntityStore.prototype.getRootIdSet = function (ids) {\n        if (ids === void 0) { ids = new Set(); }\n        Object.keys(this.rootIds).forEach(ids.add, ids);\n        if (this instanceof Layer) {\n            this.parent.getRootIdSet(ids);\n        }\n        return ids;\n    };\n    EntityStore.prototype.gc = function () {\n        var _this = this;\n        var ids = this.getRootIdSet();\n        var snapshot = this.toObject();\n        ids.forEach(function (id) {\n            if (hasOwn.call(snapshot, id)) {\n                Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);\n                delete snapshot[id];\n            }\n        });\n        var idsToRemove = Object.keys(snapshot);\n        if (idsToRemove.length) {\n            var root_1 = this;\n            while (root_1 instanceof Layer)\n                root_1 = root_1.parent;\n            idsToRemove.forEach(function (id) { return root_1.delete(id); });\n        }\n        return idsToRemove;\n    };\n    EntityStore.prototype.findChildRefIds = function (dataId) {\n        if (!hasOwn.call(this.refs, dataId)) {\n            var found_1 = this.refs[dataId] = Object.create(null);\n            var workSet_1 = new Set([this.data[dataId]]);\n            var canTraverse_1 = function (obj) { return obj !== null && typeof obj === 'object'; };\n            workSet_1.forEach(function (obj) {\n                if (isReference(obj)) {\n                    found_1[obj.__ref] = true;\n                }\n                else if (canTraverse_1(obj)) {\n                    Object.values(obj)\n                        .filter(canTraverse_1)\n                        .forEach(workSet_1.add, workSet_1);\n                }\n            });\n        }\n        return this.refs[dataId];\n    };\n    EntityStore.prototype.makeCacheKey = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return this.group.keyMaker.lookupArray(args);\n    };\n    return EntityStore;\n}());\nexport { EntityStore };\nvar CacheGroup = (function () {\n    function CacheGroup(caching) {\n        this.caching = caching;\n        this.d = null;\n        this.keyMaker = new KeyTrie(canUseWeakMap);\n        this.d = caching ? dep() : null;\n    }\n    CacheGroup.prototype.depend = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d(makeDepKey(dataId, storeFieldName));\n        }\n    };\n    CacheGroup.prototype.dirty = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d.dirty(makeDepKey(dataId, storeFieldName));\n        }\n    };\n    return CacheGroup;\n}());\nfunction makeDepKey(dataId, storeFieldName) {\n    return fieldNameFromStoreName(storeFieldName) + '#' + dataId;\n}\n(function (EntityStore) {\n    var Root = (function (_super) {\n        __extends(Root, _super);\n        function Root(_a) {\n            var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;\n            var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;\n            _this.sharedLayerGroup = new CacheGroup(resultCaching);\n            if (seed)\n                _this.replace(seed);\n            return _this;\n        }\n        Root.prototype.addLayer = function (layerId, replay) {\n            return new Layer(layerId, this, replay, this.sharedLayerGroup);\n        };\n        Root.prototype.removeLayer = function () {\n            return this;\n        };\n        return Root;\n    }(EntityStore));\n    EntityStore.Root = Root;\n})(EntityStore || (EntityStore = {}));\nvar Layer = (function (_super) {\n    __extends(Layer, _super);\n    function Layer(id, parent, replay, group) {\n        var _this = _super.call(this, parent.policies, group) || this;\n        _this.id = id;\n        _this.parent = parent;\n        _this.replay = replay;\n        _this.group = group;\n        replay(_this);\n        return _this;\n    }\n    Layer.prototype.addLayer = function (layerId, replay) {\n        return new Layer(layerId, this, replay, this.group);\n    };\n    Layer.prototype.removeLayer = function (layerId) {\n        var _this = this;\n        var parent = this.parent.removeLayer(layerId);\n        if (layerId === this.id) {\n            if (this.group.caching) {\n                Object.keys(this.data).forEach(function (dataId) {\n                    if (_this.data[dataId] !== parent.lookup(dataId)) {\n                        _this.delete(dataId);\n                    }\n                });\n            }\n            return parent;\n        }\n        if (parent === this.parent)\n            return this;\n        return parent.addLayer(this.id, this.replay);\n    };\n    Layer.prototype.toObject = function () {\n        return __assign(__assign({}, this.parent.toObject()), this.data);\n    };\n    Layer.prototype.findChildRefIds = function (dataId) {\n        var fromParent = this.parent.findChildRefIds(dataId);\n        return hasOwn.call(this.data, dataId) ? __assign(__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;\n    };\n    return Layer;\n}(EntityStore));\nfunction storeObjectReconciler(existingObject, incomingObject, property) {\n    var existingValue = existingObject[property];\n    var incomingValue = incomingObject[property];\n    return equal(existingValue, incomingValue) ? existingValue : incomingValue;\n}\nexport function supportsResultCaching(store) {\n    return !!(store instanceof EntityStore && store.group.caching);\n}\n//# sourceMappingURL=entityStore.js.map","import { __assign } from \"tslib\";\nimport { wrap } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { isField, isInlineFragment, resultKeyNameFromField, isReference, makeReference, createFragmentMap, shouldInclude, addTypenameToDocument, getDefaultValues, getFragmentDefinitions, getMainDefinition, getQueryDefinition, maybeDeepFreeze, mergeDeepArray, } from \"../../utilities/index.js\";\nimport { supportsResultCaching } from \"./entityStore.js\";\nimport { getTypenameFromStoreObject } from \"./helpers.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\n;\nfunction missingFromInvariant(err, context) {\n    return new MissingFieldError(err.message, context.path.slice(), context.query, context.variables);\n}\nvar StoreReader = (function () {\n    function StoreReader(config) {\n        var _this = this;\n        this.config = config;\n        this.executeSelectionSet = wrap(function (options) { return _this.execSelectionSetImpl(options); }, {\n            keyArgs: function (options) {\n                return [\n                    options.selectionSet,\n                    options.objectOrReference,\n                    options.context,\n                ];\n            },\n            makeCacheKey: function (selectionSet, parent, context) {\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(selectionSet, isReference(parent) ? parent.__ref : parent, context.varString);\n                }\n            }\n        });\n        this.knownResults = new WeakMap();\n        this.executeSubSelectedArray = wrap(function (options) {\n            return _this.execSubSelectedArrayImpl(options);\n        }, {\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, context = _a.context;\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(field, array, context.varString);\n                }\n            }\n        });\n        this.config = __assign({ addTypename: true }, config);\n    }\n    StoreReader.prototype.readQueryFromStore = function (options) {\n        return this.diffQueryAgainstStore(__assign(__assign({}, options), { returnPartialData: false })).result;\n    };\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, _b = _a.rootId, rootId = _b === void 0 ? 'ROOT_QUERY' : _b, variables = _a.variables, _c = _a.returnPartialData, returnPartialData = _c === void 0 ? true : _c;\n        var policies = this.config.cache.policies;\n        variables = __assign(__assign({}, getDefaultValues(getQueryDefinition(query))), variables);\n        var execResult = this.executeSelectionSet({\n            selectionSet: getMainDefinition(query).selectionSet,\n            objectOrReference: makeReference(rootId),\n            context: {\n                store: store,\n                query: query,\n                policies: policies,\n                variables: variables,\n                varString: JSON.stringify(variables),\n                fragmentMap: createFragmentMap(getFragmentDefinitions(query)),\n                path: [],\n            },\n        });\n        var hasMissingFields = execResult.missing && execResult.missing.length > 0;\n        if (hasMissingFields && !returnPartialData) {\n            throw execResult.missing[0];\n        }\n        return {\n            result: execResult.result,\n            missing: execResult.missing,\n            complete: !hasMissingFields,\n        };\n    };\n    StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {\n        if (supportsResultCaching(context.store) &&\n            this.knownResults.get(result) === selectionSet) {\n            var latest = this.executeSelectionSet.peek(selectionSet, parent, context);\n            if (latest && result === latest.result) {\n                return true;\n            }\n        }\n        return false;\n    };\n    StoreReader.prototype.execSelectionSetImpl = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, objectOrReference = _a.objectOrReference, context = _a.context;\n        if (isReference(objectOrReference) &&\n            !context.policies.rootTypenamesById[objectOrReference.__ref] &&\n            !context.store.has(objectOrReference.__ref)) {\n            return {\n                result: {},\n                missing: [missingFromInvariant(process.env.NODE_ENV === \"production\" ? new InvariantError(4) : new InvariantError(\"Dangling reference to missing \" + objectOrReference.__ref + \" object\"), context)],\n            };\n        }\n        var fragmentMap = context.fragmentMap, variables = context.variables, policies = context.policies, store = context.store;\n        var objectsToMerge = [];\n        var finalResult = { result: null };\n        var typename = store.getFieldValue(objectOrReference, \"__typename\");\n        if (this.config.addTypename &&\n            typeof typename === \"string\" &&\n            !policies.rootIdsByTypename[typename]) {\n            objectsToMerge.push({ __typename: typename });\n        }\n        function getMissing() {\n            return finalResult.missing || (finalResult.missing = []);\n        }\n        function handleMissing(result) {\n            var _a;\n            if (result.missing)\n                (_a = getMissing()).push.apply(_a, result.missing);\n            return result.result;\n        }\n        var workSet = new Set(selectionSet.selections);\n        workSet.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, variables))\n                return;\n            if (isField(selection)) {\n                var fieldValue = policies.readField({\n                    fieldName: selection.name.value,\n                    field: selection,\n                    variables: context.variables,\n                    from: objectOrReference,\n                }, context);\n                var resultName = resultKeyNameFromField(selection);\n                context.path.push(resultName);\n                if (fieldValue === void 0) {\n                    if (!addTypenameToDocument.added(selection)) {\n                        getMissing().push(missingFromInvariant(process.env.NODE_ENV === \"production\" ? new InvariantError(5) : new InvariantError(\"Can't find field '\" + selection.name.value + \"' on \" + (isReference(objectOrReference)\n                            ? objectOrReference.__ref + \" object\"\n                            : \"object \" + JSON.stringify(objectOrReference, null, 2))), context));\n                    }\n                }\n                else if (Array.isArray(fieldValue)) {\n                    fieldValue = handleMissing(_this.executeSubSelectedArray({\n                        field: selection,\n                        array: fieldValue,\n                        context: context,\n                    }));\n                }\n                else if (!selection.selectionSet) {\n                    if (process.env.NODE_ENV !== 'production') {\n                        assertSelectionSetForIdValue(context.store, selection, fieldValue);\n                        maybeDeepFreeze(fieldValue);\n                    }\n                }\n                else if (fieldValue != null) {\n                    fieldValue = handleMissing(_this.executeSelectionSet({\n                        selectionSet: selection.selectionSet,\n                        objectOrReference: fieldValue,\n                        context: context,\n                    }));\n                }\n                if (fieldValue !== void 0) {\n                    objectsToMerge.push((_a = {}, _a[resultName] = fieldValue, _a));\n                }\n                invariant(context.path.pop() === resultName);\n            }\n            else {\n                var fragment = void 0;\n                if (isInlineFragment(selection)) {\n                    fragment = selection;\n                }\n                else {\n                    process.env.NODE_ENV === \"production\" ? invariant(fragment = fragmentMap[selection.name.value], 6) : invariant(fragment = fragmentMap[selection.name.value], \"No fragment named \" + selection.name.value);\n                }\n                if (policies.fragmentMatches(fragment, typename)) {\n                    fragment.selectionSet.selections.forEach(workSet.add, workSet);\n                }\n            }\n        });\n        finalResult.result = mergeDeepArray(objectsToMerge);\n        if (process.env.NODE_ENV !== 'production') {\n            Object.freeze(finalResult.result);\n        }\n        this.knownResults.set(finalResult.result, selectionSet);\n        return finalResult;\n    };\n    StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, context = _a.context;\n        var missing;\n        function handleMissing(childResult, i) {\n            if (childResult.missing) {\n                missing = missing || [];\n                missing.push.apply(missing, childResult.missing);\n            }\n            invariant(context.path.pop() === i);\n            return childResult.result;\n        }\n        if (field.selectionSet) {\n            array = array.filter(context.store.canRead);\n        }\n        array = array.map(function (item, i) {\n            if (item === null) {\n                return null;\n            }\n            context.path.push(i);\n            if (Array.isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    context: context,\n                }), i);\n            }\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    objectOrReference: item,\n                    context: context,\n                }), i);\n            }\n            if (process.env.NODE_ENV !== 'production') {\n                assertSelectionSetForIdValue(context.store, field, item);\n            }\n            invariant(context.path.pop() === i);\n            return item;\n        });\n        if (process.env.NODE_ENV !== 'production') {\n            Object.freeze(array);\n        }\n        return { result: array, missing: missing };\n    };\n    return StoreReader;\n}());\nexport { StoreReader };\nfunction assertSelectionSetForIdValue(store, field, fieldValue) {\n    if (!field.selectionSet) {\n        var workSet_1 = new Set([fieldValue]);\n        workSet_1.forEach(function (value) {\n            if (value && typeof value === \"object\") {\n                process.env.NODE_ENV === \"production\" ? invariant(!isReference(value), 7) : invariant(!isReference(value), \"Missing selection set for object of type \" + getTypenameFromStoreObject(store, value) + \" returned for query field \" + field.name.value);\n                Object.values(value).forEach(workSet_1.add, workSet_1);\n            }\n        });\n    }\n}\n//# sourceMappingURL=readFromStore.js.map","import { __assign } from \"tslib\";\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { equal } from '@wry/equality';\nimport { createFragmentMap, getFragmentFromSelection, getDefaultValues, getFragmentDefinitions, getOperationDefinition, getTypenameFromResult, makeReference, isField, resultKeyNameFromField, isReference, shouldInclude, hasDirectives, cloneDeep, } from \"../../utilities/index.js\";\nimport { makeProcessedFieldsMerger, fieldNameFromStoreName } from \"./helpers.js\";\n;\nvar StoreWriter = (function () {\n    function StoreWriter(cache, reader) {\n        this.cache = cache;\n        this.reader = reader;\n    }\n    StoreWriter.prototype.writeToStore = function (_a) {\n        var query = _a.query, result = _a.result, dataId = _a.dataId, store = _a.store, variables = _a.variables;\n        var operationDefinition = getOperationDefinition(query);\n        var merger = makeProcessedFieldsMerger();\n        variables = __assign(__assign({}, getDefaultValues(operationDefinition)), variables);\n        var objOrRef = this.processSelectionSet({\n            result: result || Object.create(null),\n            dataId: dataId,\n            selectionSet: operationDefinition.selectionSet,\n            context: {\n                store: store,\n                written: Object.create(null),\n                merge: function (existing, incoming) {\n                    return merger.merge(existing, incoming);\n                },\n                variables: variables,\n                varString: JSON.stringify(variables),\n                fragmentMap: createFragmentMap(getFragmentDefinitions(query)),\n            },\n        });\n        var ref = isReference(objOrRef) ? objOrRef :\n            dataId && makeReference(dataId) || void 0;\n        if (ref) {\n            store.retain(ref.__ref);\n        }\n        return ref;\n    };\n    StoreWriter.prototype.processSelectionSet = function (_a) {\n        var _this = this;\n        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, _b = _a.out, out = _b === void 0 ? {\n            shouldApplyMerges: false,\n        } : _b;\n        var policies = this.cache.policies;\n        var _c = policies.identify(result, selectionSet, context.fragmentMap), id = _c[0], keyObject = _c[1];\n        dataId = dataId || id;\n        if (\"string\" === typeof dataId) {\n            var sets = context.written[dataId] || (context.written[dataId] = []);\n            var ref = makeReference(dataId);\n            if (sets.indexOf(selectionSet) >= 0)\n                return ref;\n            sets.push(selectionSet);\n            if (this.reader && this.reader.isFresh(result, ref, selectionSet, context)) {\n                return ref;\n            }\n        }\n        var mergedFields = Object.create(null);\n        if (keyObject) {\n            mergedFields = context.merge(mergedFields, keyObject);\n        }\n        var typename = (dataId && policies.rootTypenamesById[dataId]) ||\n            getTypenameFromResult(result, selectionSet, context.fragmentMap) ||\n            (dataId && context.store.get(dataId, \"__typename\"));\n        if (\"string\" === typeof typename) {\n            mergedFields.__typename = typename;\n        }\n        var workSet = new Set(selectionSet.selections);\n        workSet.forEach(function (selection) {\n            var _a;\n            if (!shouldInclude(selection, context.variables))\n                return;\n            if (isField(selection)) {\n                var resultFieldKey = resultKeyNameFromField(selection);\n                var value = result[resultFieldKey];\n                if (typeof value !== 'undefined') {\n                    var storeFieldName = policies.getStoreFieldName({\n                        typename: typename,\n                        fieldName: selection.name.value,\n                        field: selection,\n                        variables: context.variables,\n                    });\n                    var incomingValue = _this.processFieldValue(value, selection, context, out);\n                    if (policies.hasMergeFunction(typename, selection.name.value)) {\n                        incomingValue = {\n                            __field: selection,\n                            __typename: typename,\n                            __value: incomingValue,\n                        };\n                        out.shouldApplyMerges = true;\n                    }\n                    mergedFields = context.merge(mergedFields, (_a = {},\n                        _a[storeFieldName] = incomingValue,\n                        _a));\n                }\n                else if (policies.usingPossibleTypes &&\n                    !hasDirectives([\"defer\", \"client\"], selection)) {\n                    throw process.env.NODE_ENV === \"production\" ? new InvariantError(8) : new InvariantError(\"Missing field '\" + resultFieldKey + \"' in \" + JSON.stringify(result, null, 2).substring(0, 100));\n                }\n            }\n            else {\n                var fragment = getFragmentFromSelection(selection, context.fragmentMap);\n                if (fragment && policies.fragmentMatches(fragment, typename)) {\n                    fragment.selectionSet.selections.forEach(workSet.add, workSet);\n                }\n            }\n        });\n        if (\"string\" === typeof dataId) {\n            var entityRef_1 = makeReference(dataId);\n            if (out.shouldApplyMerges) {\n                mergedFields = policies.applyMerges(entityRef_1, mergedFields, context);\n            }\n            if (process.env.NODE_ENV !== \"production\") {\n                Object.keys(mergedFields).forEach(function (storeFieldName) {\n                    var fieldName = fieldNameFromStoreName(storeFieldName);\n                    if (!policies.hasMergeFunction(typename, fieldName)) {\n                        warnAboutDataLoss(entityRef_1, mergedFields, storeFieldName, context.store);\n                    }\n                });\n            }\n            context.store.merge(dataId, mergedFields);\n            return entityRef_1;\n        }\n        return mergedFields;\n    };\n    StoreWriter.prototype.processFieldValue = function (value, field, context, out) {\n        var _this = this;\n        if (!field.selectionSet || value === null) {\n            return process.env.NODE_ENV === 'production' ? value : cloneDeep(value);\n        }\n        if (Array.isArray(value)) {\n            return value.map(function (item) { return _this.processFieldValue(item, field, context, out); });\n        }\n        return this.processSelectionSet({\n            result: value,\n            selectionSet: field.selectionSet,\n            context: context,\n            out: out,\n        });\n    };\n    return StoreWriter;\n}());\nexport { StoreWriter };\nvar warnings = new Set();\nfunction warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {\n    var getChild = function (objOrRef) {\n        var child = store.getFieldValue(objOrRef, storeFieldName);\n        return typeof child === \"object\" && child;\n    };\n    var existing = getChild(existingRef);\n    if (!existing)\n        return;\n    var incoming = getChild(incomingObj);\n    if (!incoming)\n        return;\n    if (isReference(existing))\n        return;\n    if (equal(existing, incoming))\n        return;\n    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {\n        return;\n    }\n    var parentType = store.getFieldValue(existingRef, \"__typename\") ||\n        store.getFieldValue(incomingObj, \"__typename\");\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var typeDotName = parentType + \".\" + fieldName;\n    if (warnings.has(typeDotName))\n        return;\n    warnings.add(typeDotName);\n    var childTypenames = [];\n    if (!Array.isArray(existing) &&\n        !Array.isArray(incoming)) {\n        [existing, incoming].forEach(function (child) {\n            var typename = store.getFieldValue(child, \"__typename\");\n            if (typeof typename === \"string\" &&\n                !childTypenames.includes(typename)) {\n                childTypenames.push(typename);\n            }\n        });\n    }\n    process.env.NODE_ENV === \"production\" || invariant.warn(\"Cache data may be lost when replacing the \" + fieldName + \" field of a \" + parentType + \" object.\\n\\nTo address this problem (which is not a bug in Apollo Client), \" + (childTypenames.length\n        ? \"either ensure all objects of type \" +\n            childTypenames.join(\" and \") + \" have IDs, or \"\n        : \"\") + \"define a custom merge function for the \" + typeDotName + \" field, so InMemoryCache can safely merge these objects:\\n\\n  existing: \" + JSON.stringify(existing).slice(0, 1000) + \"\\n  incoming: \" + JSON.stringify(incoming).slice(0, 1000) + \"\\n\\nFor more information about these options, please refer to the documentation:\\n\\n  * Ensuring entity objects have IDs: https://go.apollo.dev/c/generating-unique-identifiers\\n  * Defining custom merge functions: https://go.apollo.dev/c/merging-non-normalized-objects\\n\");\n}\n//# sourceMappingURL=writeToStore.js.map","import { Slot } from \"@wry/context\";\nimport { dep } from \"optimism\";\nvar varDep = dep();\nexport var cacheSlot = new Slot();\nexport function makeVar(value) {\n    var caches = new Set();\n    return function rv(newValue) {\n        if (arguments.length > 0) {\n            if (value !== newValue) {\n                value = newValue;\n                varDep.dirty(rv);\n                caches.forEach(broadcast);\n            }\n        }\n        else {\n            var cache = cacheSlot.getValue();\n            if (cache)\n                caches.add(cache);\n            varDep(rv);\n        }\n        return value;\n    };\n}\nfunction broadcast(cache) {\n    if (cache.broadcastWatches) {\n        cache.broadcastWatches();\n    }\n}\n//# sourceMappingURL=reactiveVars.js.map","import { __assign } from \"tslib\";\nimport { KeyTrie } from 'optimism';\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { getFragmentFromSelection, isField, getTypenameFromResult, storeKeyNameFromField, argumentsObjectFromField, isReference, getStoreKeyName, canUseWeakMap, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName, isFieldValueToBeMerged, storeValueIsStoreObject, } from \"./helpers.js\";\nimport { cacheSlot } from \"./reactiveVars.js\";\nfunction argsFromFieldSpecifier(spec) {\n    return spec.args !== void 0 ? spec.args :\n        spec.field ? argumentsObjectFromField(spec.field, spec.variables) : null;\n}\nexport var defaultDataIdFromObject = function (_a, context) {\n    var __typename = _a.__typename, id = _a.id, _id = _a._id;\n    if (typeof __typename === \"string\") {\n        if (context) {\n            context.keyObject =\n                id !== void 0 ? { id: id } :\n                    _id !== void 0 ? { _id: _id } :\n                        void 0;\n        }\n        if (id === void 0)\n            id = _id;\n        if (id !== void 0) {\n            return __typename + \":\" + ((typeof id === \"number\" ||\n                typeof id === \"string\") ? id : JSON.stringify(id));\n        }\n    }\n};\nvar nullKeyFieldsFn = function () { return void 0; };\nvar simpleKeyArgsFn = function (_args, context) { return context.fieldName; };\nvar mergeTrueFn = function (existing, incoming, _a) {\n    var mergeObjects = _a.mergeObjects;\n    return mergeObjects(existing, incoming);\n};\nvar mergeFalseFn = function (_, incoming) { return incoming; };\nvar Policies = (function () {\n    function Policies(config) {\n        this.config = config;\n        this.typePolicies = Object.create(null);\n        this.rootIdsByTypename = Object.create(null);\n        this.rootTypenamesById = Object.create(null);\n        this.usingPossibleTypes = false;\n        this.storageTrie = new KeyTrie(true);\n        this.config = __assign({ dataIdFromObject: defaultDataIdFromObject }, config);\n        this.cache = this.config.cache;\n        this.setRootTypename(\"Query\");\n        this.setRootTypename(\"Mutation\");\n        this.setRootTypename(\"Subscription\");\n        if (config.possibleTypes) {\n            this.addPossibleTypes(config.possibleTypes);\n        }\n        if (config.typePolicies) {\n            this.addTypePolicies(config.typePolicies);\n        }\n    }\n    Policies.prototype.identify = function (object, selectionSet, fragmentMap) {\n        var typename = selectionSet && fragmentMap\n            ? getTypenameFromResult(object, selectionSet, fragmentMap)\n            : object.__typename;\n        if (typename === this.rootTypenamesById.ROOT_QUERY) {\n            return [\"ROOT_QUERY\"];\n        }\n        var context = {\n            typename: typename,\n            selectionSet: selectionSet,\n            fragmentMap: fragmentMap,\n        };\n        var id;\n        var policy = this.getTypePolicy(typename, false);\n        var keyFn = policy && policy.keyFn || this.config.dataIdFromObject;\n        while (keyFn) {\n            var specifierOrId = keyFn(object, context);\n            if (Array.isArray(specifierOrId)) {\n                keyFn = keyFieldsFnFromSpecifier(specifierOrId);\n            }\n            else {\n                id = specifierOrId;\n                break;\n            }\n        }\n        id = id && String(id);\n        return context.keyObject ? [id, context.keyObject] : [id];\n    };\n    Policies.prototype.addTypePolicies = function (typePolicies) {\n        var _this = this;\n        Object.keys(typePolicies).forEach(function (typename) {\n            var existing = _this.getTypePolicy(typename, true);\n            var incoming = typePolicies[typename];\n            var keyFields = incoming.keyFields, fields = incoming.fields;\n            if (incoming.queryType)\n                _this.setRootTypename(\"Query\", typename);\n            if (incoming.mutationType)\n                _this.setRootTypename(\"Mutation\", typename);\n            if (incoming.subscriptionType)\n                _this.setRootTypename(\"Subscription\", typename);\n            existing.keyFn =\n                keyFields === false ? nullKeyFieldsFn :\n                    Array.isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields) :\n                        typeof keyFields === \"function\" ? keyFields :\n                            existing.keyFn;\n            if (fields) {\n                Object.keys(fields).forEach(function (fieldName) {\n                    var existing = _this.getFieldPolicy(typename, fieldName, true);\n                    var incoming = fields[fieldName];\n                    if (typeof incoming === \"function\") {\n                        existing.read = incoming;\n                    }\n                    else {\n                        var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;\n                        existing.keyFn =\n                            keyArgs === false ? simpleKeyArgsFn :\n                                Array.isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs) :\n                                    typeof keyArgs === \"function\" ? keyArgs :\n                                        existing.keyFn;\n                        if (typeof read === \"function\")\n                            existing.read = read;\n                        existing.merge =\n                            typeof merge === \"function\" ? merge :\n                                merge === true ? mergeTrueFn :\n                                    merge === false ? mergeFalseFn :\n                                        existing.merge;\n                    }\n                    if (existing.read && existing.merge) {\n                        existing.keyFn = existing.keyFn || simpleKeyArgsFn;\n                    }\n                });\n            }\n        });\n    };\n    Policies.prototype.setRootTypename = function (which, typename) {\n        if (typename === void 0) { typename = which; }\n        var rootId = \"ROOT_\" + which.toUpperCase();\n        var old = this.rootTypenamesById[rootId];\n        if (typename !== old) {\n            process.env.NODE_ENV === \"production\" ? invariant(!old || old === which, 1) : invariant(!old || old === which, \"Cannot change root \" + which + \" __typename more than once\");\n            if (old)\n                delete this.rootIdsByTypename[old];\n            this.rootIdsByTypename[typename] = rootId;\n            this.rootTypenamesById[rootId] = typename;\n        }\n    };\n    Policies.prototype.addPossibleTypes = function (possibleTypes) {\n        var _this = this;\n        this.usingPossibleTypes = true;\n        Object.keys(possibleTypes).forEach(function (supertype) {\n            var subtypeSet = _this.getSubtypeSet(supertype, true);\n            possibleTypes[supertype].forEach(subtypeSet.add, subtypeSet);\n        });\n    };\n    Policies.prototype.getTypePolicy = function (typename, createIfMissing) {\n        if (typename) {\n            return this.typePolicies[typename] || (createIfMissing && (this.typePolicies[typename] = Object.create(null)));\n        }\n    };\n    Policies.prototype.getSubtypeSet = function (supertype, createIfMissing) {\n        var policy = this.getTypePolicy(supertype, createIfMissing);\n        if (policy) {\n            return policy.subtypes || (createIfMissing ? policy.subtypes = new Set() : void 0);\n        }\n    };\n    Policies.prototype.getFieldPolicy = function (typename, fieldName, createIfMissing) {\n        var typePolicy = this.getTypePolicy(typename, createIfMissing);\n        if (typePolicy) {\n            var fieldPolicies = typePolicy.fields || (createIfMissing && (typePolicy.fields = Object.create(null)));\n            if (fieldPolicies) {\n                return fieldPolicies[fieldName] || (createIfMissing && (fieldPolicies[fieldName] = Object.create(null)));\n            }\n        }\n    };\n    Policies.prototype.fragmentMatches = function (fragment, typename) {\n        var _this = this;\n        if (!fragment.typeCondition)\n            return true;\n        if (!typename)\n            return false;\n        var supertype = fragment.typeCondition.name.value;\n        if (typename === supertype)\n            return true;\n        if (this.usingPossibleTypes) {\n            var workQueue_1 = [this.getSubtypeSet(supertype, false)];\n            for (var i = 0; i < workQueue_1.length; ++i) {\n                var subtypes = workQueue_1[i];\n                if (subtypes) {\n                    if (subtypes.has(typename))\n                        return true;\n                    subtypes.forEach(function (subtype) {\n                        var subsubtypes = _this.getSubtypeSet(subtype, false);\n                        if (subsubtypes && workQueue_1.indexOf(subsubtypes) < 0) {\n                            workQueue_1.push(subsubtypes);\n                        }\n                    });\n                }\n            }\n        }\n        return false;\n    };\n    Policies.prototype.getStoreFieldName = function (fieldSpec) {\n        var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        var storeFieldName;\n        var keyFn = policy && policy.keyFn;\n        if (keyFn && typename) {\n            var context = {\n                typename: typename,\n                fieldName: fieldName,\n                field: fieldSpec.field || null,\n                variables: fieldSpec.variables,\n            };\n            var args = argsFromFieldSpecifier(fieldSpec);\n            while (keyFn) {\n                var specifierOrString = keyFn(args, context);\n                if (Array.isArray(specifierOrString)) {\n                    keyFn = keyArgsFnFromSpecifier(specifierOrString);\n                }\n                else {\n                    storeFieldName = specifierOrString || fieldName;\n                    break;\n                }\n            }\n        }\n        if (storeFieldName === void 0) {\n            storeFieldName = fieldSpec.field\n                ? storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)\n                : getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));\n        }\n        return fieldName === fieldNameFromStoreName(storeFieldName)\n            ? storeFieldName\n            : fieldName + \":\" + storeFieldName;\n    };\n    Policies.prototype.readField = function (options, context) {\n        var objectOrReference = options.from;\n        if (!objectOrReference)\n            return;\n        var nameOrField = options.field || options.fieldName;\n        if (!nameOrField)\n            return;\n        if (options.typename === void 0) {\n            var typename = context.store.getFieldValue(objectOrReference, \"__typename\");\n            if (typename)\n                options.typename = typename;\n        }\n        var storeFieldName = this.getStoreFieldName(options);\n        var fieldName = fieldNameFromStoreName(storeFieldName);\n        var existing = context.store.getFieldValue(objectOrReference, storeFieldName);\n        var policy = this.getFieldPolicy(options.typename, fieldName, false);\n        var read = policy && policy.read;\n        if (read) {\n            var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, this.storageTrie.lookup(isReference(objectOrReference)\n                ? objectOrReference.__ref\n                : objectOrReference, storeFieldName));\n            return cacheSlot.withValue(this.cache, read, [existing, readOptions]);\n        }\n        return existing;\n    };\n    Policies.prototype.hasMergeFunction = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        return !!(policy && policy.merge);\n    };\n    Policies.prototype.applyMerges = function (existing, incoming, context, storageKeys) {\n        var _this = this;\n        if (isFieldValueToBeMerged(incoming)) {\n            var field = incoming.__field;\n            var fieldName = field.name.value;\n            var merge = this.getFieldPolicy(incoming.__typename, fieldName, false).merge;\n            var storage = storageKeys\n                ? this.storageTrie.lookupArray(storageKeys)\n                : null;\n            incoming = merge(existing, incoming.__value, makeFieldFunctionOptions(this, void 0, { typename: incoming.__typename, fieldName: fieldName,\n                field: field, variables: context.variables }, context, storage));\n        }\n        if (Array.isArray(incoming)) {\n            return incoming.map(function (item) { return _this.applyMerges(void 0, item, context); });\n        }\n        if (storeValueIsStoreObject(incoming)) {\n            var e_1 = existing;\n            var i_1 = incoming;\n            var firstStorageKey_1 = isReference(e_1)\n                ? e_1.__ref\n                : typeof e_1 === \"object\" && e_1;\n            var newFields_1;\n            Object.keys(i_1).forEach(function (storeFieldName) {\n                var incomingValue = i_1[storeFieldName];\n                var appliedValue = _this.applyMerges(context.store.getFieldValue(e_1, storeFieldName), incomingValue, context, firstStorageKey_1 ? [firstStorageKey_1, storeFieldName] : void 0);\n                if (appliedValue !== incomingValue) {\n                    newFields_1 = newFields_1 || Object.create(null);\n                    newFields_1[storeFieldName] = appliedValue;\n                }\n            });\n            if (newFields_1) {\n                return __assign(__assign({}, i_1), newFields_1);\n            }\n        }\n        return incoming;\n    };\n    return Policies;\n}());\nexport { Policies };\nfunction makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {\n    var storeFieldName = policies.getStoreFieldName(fieldSpec);\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var variables = fieldSpec.variables || context.variables;\n    var _a = context.store, getFieldValue = _a.getFieldValue, toReference = _a.toReference, canRead = _a.canRead;\n    return {\n        args: argsFromFieldSpecifier(fieldSpec),\n        field: fieldSpec.field || null,\n        fieldName: fieldName,\n        storeFieldName: storeFieldName,\n        variables: variables,\n        isReference: isReference,\n        toReference: toReference,\n        storage: storage,\n        cache: policies.cache,\n        canRead: canRead,\n        readField: function (fieldNameOrOptions, from) {\n            var options = typeof fieldNameOrOptions === \"string\" ? {\n                fieldName: fieldNameOrOptions,\n                from: from,\n            } : __assign({}, fieldNameOrOptions);\n            if (void 0 === options.from) {\n                options.from = objectOrReference;\n            }\n            if (void 0 === options.variables) {\n                options.variables = variables;\n            }\n            return policies.readField(options, context);\n        },\n        mergeObjects: function (existing, incoming) {\n            if (Array.isArray(existing) || Array.isArray(incoming)) {\n                throw process.env.NODE_ENV === \"production\" ? new InvariantError(2) : new InvariantError(\"Cannot automatically merge arrays\");\n            }\n            if (existing && typeof existing === \"object\" &&\n                incoming && typeof incoming === \"object\") {\n                var eType = getFieldValue(existing, \"__typename\");\n                var iType = getFieldValue(incoming, \"__typename\");\n                var typesDiffer = eType && iType && eType !== iType;\n                var applied = policies.applyMerges(typesDiffer ? void 0 : existing, incoming, context);\n                if (typesDiffer ||\n                    !storeValueIsStoreObject(existing) ||\n                    !storeValueIsStoreObject(applied)) {\n                    return applied;\n                }\n                return __assign(__assign({}, existing), applied);\n            }\n            return incoming;\n        }\n    };\n}\nfunction keyArgsFnFromSpecifier(specifier) {\n    return function (args, context) {\n        return args ? context.fieldName + \":\" + JSON.stringify(computeKeyObject(args, specifier)) : context.fieldName;\n    };\n}\nfunction keyFieldsFnFromSpecifier(specifier) {\n    var trie = new KeyTrie(canUseWeakMap);\n    return function (object, context) {\n        var aliasMap;\n        if (context.selectionSet && context.fragmentMap) {\n            var info = trie.lookupArray([\n                context.selectionSet,\n                context.fragmentMap,\n            ]);\n            aliasMap = info.aliasMap || (info.aliasMap = makeAliasMap(context.selectionSet, context.fragmentMap));\n        }\n        var keyObject = context.keyObject =\n            computeKeyObject(object, specifier, aliasMap);\n        return context.typename + \":\" + JSON.stringify(keyObject);\n    };\n}\nfunction makeAliasMap(selectionSet, fragmentMap) {\n    var map = Object.create(null);\n    var workQueue = new Set([selectionSet]);\n    workQueue.forEach(function (selectionSet) {\n        selectionSet.selections.forEach(function (selection) {\n            if (isField(selection)) {\n                if (selection.alias) {\n                    var responseKey = selection.alias.value;\n                    var storeKey = selection.name.value;\n                    if (storeKey !== responseKey) {\n                        var aliases = map.aliases || (map.aliases = Object.create(null));\n                        aliases[storeKey] = responseKey;\n                    }\n                }\n                if (selection.selectionSet) {\n                    var subsets = map.subsets || (map.subsets = Object.create(null));\n                    subsets[selection.name.value] =\n                        makeAliasMap(selection.selectionSet, fragmentMap);\n                }\n            }\n            else {\n                var fragment = getFragmentFromSelection(selection, fragmentMap);\n                if (fragment) {\n                    workQueue.add(fragment.selectionSet);\n                }\n            }\n        });\n    });\n    return map;\n}\nfunction computeKeyObject(response, specifier, aliasMap) {\n    var keyObj = Object.create(null);\n    var prevKey;\n    specifier.forEach(function (s) {\n        if (Array.isArray(s)) {\n            if (typeof prevKey === \"string\") {\n                var subsets = aliasMap && aliasMap.subsets;\n                var subset = subsets && subsets[prevKey];\n                keyObj[prevKey] = computeKeyObject(response[prevKey], s, subset);\n            }\n        }\n        else {\n            var aliases = aliasMap && aliasMap.aliases;\n            var responseName = aliases && aliases[s] || s;\n            process.env.NODE_ENV === \"production\" ? invariant(hasOwn.call(response, responseName), 3) : invariant(hasOwn.call(response, responseName), \"Missing field '\" + responseName + \"' while computing key fields\");\n            keyObj[prevKey = s] = response[responseName];\n        }\n    });\n    return keyObj;\n}\n//# sourceMappingURL=policies.js.map","import { __assign, __extends } from \"tslib\";\nimport \"./fixPolyfills.js\";\nimport { dep, wrap } from 'optimism';\nimport { ApolloCache } from \"../core/cache.js\";\nimport { addTypenameToDocument, isReference, } from \"../../utilities/index.js\";\nimport { StoreReader } from \"./readFromStore.js\";\nimport { StoreWriter } from \"./writeToStore.js\";\nimport { EntityStore, supportsResultCaching } from \"./entityStore.js\";\nimport { makeVar } from \"./reactiveVars.js\";\nimport { defaultDataIdFromObject, Policies, } from \"./policies.js\";\nimport { hasOwn } from \"./helpers.js\";\nvar defaultConfig = {\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    typePolicies: {},\n};\nvar InMemoryCache = (function (_super) {\n    __extends(InMemoryCache, _super);\n    function InMemoryCache(config) {\n        if (config === void 0) { config = {}; }\n        var _this = _super.call(this) || this;\n        _this.watches = new Set();\n        _this.typenameDocumentCache = new Map();\n        _this.makeVar = makeVar;\n        _this.txCount = 0;\n        _this.maybeBroadcastWatch = wrap(function (c) {\n            return _this.broadcastWatch.call(_this, c);\n        }, {\n            makeCacheKey: function (c) {\n                var store = c.optimistic ? _this.optimisticData : _this.data;\n                if (supportsResultCaching(store)) {\n                    var optimistic = c.optimistic, rootId = c.rootId, variables = c.variables;\n                    return store.makeCacheKey(c.query, c.callback, JSON.stringify({ optimistic: optimistic, rootId: rootId, variables: variables }));\n                }\n            }\n        });\n        _this.watchDep = dep();\n        _this.config = __assign(__assign({}, defaultConfig), config);\n        _this.addTypename = !!_this.config.addTypename;\n        _this.policies = new Policies({\n            cache: _this,\n            dataIdFromObject: _this.config.dataIdFromObject,\n            possibleTypes: _this.config.possibleTypes,\n            typePolicies: _this.config.typePolicies,\n        });\n        _this.data = new EntityStore.Root({\n            policies: _this.policies,\n            resultCaching: _this.config.resultCaching,\n        });\n        _this.optimisticData = _this.data;\n        _this.storeWriter = new StoreWriter(_this, _this.storeReader = new StoreReader({\n            cache: _this,\n            addTypename: _this.addTypename,\n        }));\n        return _this;\n    }\n    InMemoryCache.prototype.restore = function (data) {\n        if (data)\n            this.data.replace(data);\n        return this;\n    };\n    InMemoryCache.prototype.extract = function (optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return (optimistic ? this.optimisticData : this.data).toObject();\n    };\n    InMemoryCache.prototype.read = function (options) {\n        var store = options.optimistic ? this.optimisticData : this.data;\n        if (typeof options.rootId === 'string' && !store.has(options.rootId)) {\n            return null;\n        }\n        return this.storeReader.readQueryFromStore({\n            store: store,\n            query: options.query,\n            variables: options.variables,\n            rootId: options.rootId,\n            config: this.config,\n        }) || null;\n    };\n    InMemoryCache.prototype.write = function (options) {\n        try {\n            ++this.txCount;\n            return this.storeWriter.writeToStore({\n                store: this.data,\n                query: options.query,\n                result: options.result,\n                dataId: options.dataId,\n                variables: options.variables,\n            });\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.modify = function (options) {\n        if (hasOwn.call(options, \"id\") && !options.id) {\n            return false;\n        }\n        var store = options.optimistic\n            ? this.optimisticData\n            : this.data;\n        try {\n            ++this.txCount;\n            return store.modify(options.id || \"ROOT_QUERY\", options.fields);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.diff = function (options) {\n        return this.storeReader.diffQueryAgainstStore({\n            store: options.optimistic ? this.optimisticData : this.data,\n            rootId: options.id || \"ROOT_QUERY\",\n            query: options.query,\n            variables: options.variables,\n            returnPartialData: options.returnPartialData,\n            config: this.config,\n        });\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        this.watches.add(watch);\n        if (watch.immediate) {\n            this.maybeBroadcastWatch(watch);\n        }\n        return function () {\n            _this.watches.delete(watch);\n        };\n    };\n    InMemoryCache.prototype.gc = function () {\n        return this.optimisticData.gc();\n    };\n    InMemoryCache.prototype.retain = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).retain(rootId);\n    };\n    InMemoryCache.prototype.release = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).release(rootId);\n    };\n    InMemoryCache.prototype.identify = function (object) {\n        return isReference(object) ? object.__ref :\n            this.policies.identify(object)[0];\n    };\n    InMemoryCache.prototype.evict = function (options) {\n        if (!options.id) {\n            if (hasOwn.call(options, \"id\")) {\n                return false;\n            }\n            options = __assign(__assign({}, options), { id: \"ROOT_QUERY\" });\n        }\n        try {\n            ++this.txCount;\n            return this.optimisticData.evict(options);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.reset = function () {\n        this.data.clear();\n        this.optimisticData = this.data;\n        this.broadcastWatches();\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var newOptimisticData = this.optimisticData.removeLayer(idToRemove);\n        if (newOptimisticData !== this.optimisticData) {\n            this.optimisticData = newOptimisticData;\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.performTransaction = function (transaction, optimisticId) {\n        var _this = this;\n        var perform = function (layer) {\n            var _a = _this, data = _a.data, optimisticData = _a.optimisticData;\n            ++_this.txCount;\n            if (layer) {\n                _this.data = _this.optimisticData = layer;\n            }\n            try {\n                transaction(_this);\n            }\n            finally {\n                --_this.txCount;\n                _this.data = data;\n                _this.optimisticData = optimisticData;\n            }\n        };\n        if (typeof optimisticId === 'string') {\n            this.optimisticData = this.optimisticData.addLayer(optimisticId, perform);\n        }\n        else if (optimisticId === null) {\n            perform(this.data);\n        }\n        else {\n            perform();\n        }\n        this.broadcastWatches();\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        if (this.addTypename) {\n            var result = this.typenameDocumentCache.get(document);\n            if (!result) {\n                result = addTypenameToDocument(document);\n                this.typenameDocumentCache.set(document, result);\n                this.typenameDocumentCache.set(result, result);\n            }\n            return result;\n        }\n        return document;\n    };\n    InMemoryCache.prototype.broadcastWatches = function () {\n        var _this = this;\n        if (!this.txCount) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c); });\n        }\n    };\n    InMemoryCache.prototype.broadcastWatch = function (c) {\n        this.watchDep.dirty(c);\n        this.watchDep(c);\n        c.callback(this.diff({\n            query: c.query,\n            variables: c.variables,\n            optimistic: c.optimistic,\n        }));\n    };\n    return InMemoryCache;\n}(ApolloCache));\nexport { InMemoryCache };\n//# sourceMappingURL=inMemoryCache.js.map","var MutationStore = (function () {\n    function MutationStore() {\n        this.store = {};\n    }\n    MutationStore.prototype.getStore = function () {\n        return this.store;\n    };\n    MutationStore.prototype.get = function (mutationId) {\n        return this.store[mutationId];\n    };\n    MutationStore.prototype.initMutation = function (mutationId, mutation, variables) {\n        this.store[mutationId] = {\n            mutation: mutation,\n            variables: variables || {},\n            loading: true,\n            error: null,\n        };\n    };\n    MutationStore.prototype.markMutationError = function (mutationId, error) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = error;\n        }\n    };\n    MutationStore.prototype.markMutationResult = function (mutationId) {\n        var mutation = this.store[mutationId];\n        if (mutation) {\n            mutation.loading = false;\n            mutation.error = null;\n        }\n    };\n    MutationStore.prototype.reset = function () {\n        this.store = {};\n    };\n    return MutationStore;\n}());\nexport { MutationStore };\n//# sourceMappingURL=MutationStore.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { visit, BREAK } from 'graphql/language/visitor';\nimport { invariant } from 'ts-invariant';\nimport { argumentsObjectFromField, buildQueryFromSelectionSet, createFragmentMap, getFragmentDefinitions, getMainDefinition, hasDirectives, isField, isInlineFragment, mergeDeep, mergeDeepArray, removeClientSetsFromDocument, resultKeyNameFromField, shouldInclude, } from \"../utilities/index.js\";\nimport { cacheSlot } from \"../cache/index.js\";\nvar LocalState = (function () {\n    function LocalState(_a) {\n        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;\n        this.cache = cache;\n        if (client) {\n            this.client = client;\n        }\n        if (resolvers) {\n            this.addResolvers(resolvers);\n        }\n        if (fragmentMatcher) {\n            this.setFragmentMatcher(fragmentMatcher);\n        }\n    }\n    LocalState.prototype.addResolvers = function (resolvers) {\n        var _this = this;\n        this.resolvers = this.resolvers || {};\n        if (Array.isArray(resolvers)) {\n            resolvers.forEach(function (resolverGroup) {\n                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);\n            });\n        }\n        else {\n            this.resolvers = mergeDeep(this.resolvers, resolvers);\n        }\n    };\n    LocalState.prototype.setResolvers = function (resolvers) {\n        this.resolvers = {};\n        this.addResolvers(resolvers);\n    };\n    LocalState.prototype.getResolvers = function () {\n        return this.resolvers || {};\n    };\n    LocalState.prototype.runResolvers = function (_a) {\n        var document = _a.document, remoteResult = _a.remoteResult, context = _a.context, variables = _a.variables, _b = _a.onlyRunForcedResolvers, onlyRunForcedResolvers = _b === void 0 ? false : _b;\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_c) {\n                if (document) {\n                    return [2, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (__assign(__assign({}, remoteResult), { data: localResult.result })); })];\n                }\n                return [2, remoteResult];\n            });\n        });\n    };\n    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n        this.fragmentMatcher = fragmentMatcher;\n    };\n    LocalState.prototype.getFragmentMatcher = function () {\n        return this.fragmentMatcher;\n    };\n    LocalState.prototype.clientQuery = function (document) {\n        if (hasDirectives(['client'], document)) {\n            if (this.resolvers) {\n                return document;\n            }\n        }\n        return null;\n    };\n    LocalState.prototype.serverQuery = function (document) {\n        return removeClientSetsFromDocument(document);\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        var cache = this.cache;\n        return __assign(__assign({}, context), { cache: cache,\n            getCacheKey: function (obj) {\n                return cache.identify(obj);\n            } });\n    };\n    LocalState.prototype.addExportedVariables = function (document, variables, context) {\n        if (variables === void 0) { variables = {}; }\n        if (context === void 0) { context = {}; }\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                if (document) {\n                    return [2, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (__assign(__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2, __assign({}, variables)];\n            });\n        });\n    };\n    LocalState.prototype.shouldForceResolvers = function (document) {\n        var forceResolvers = false;\n        visit(document, {\n            Directive: {\n                enter: function (node) {\n                    if (node.name.value === 'client' && node.arguments) {\n                        forceResolvers = node.arguments.some(function (arg) {\n                            return arg.name.value === 'always' &&\n                                arg.value.kind === 'BooleanValue' &&\n                                arg.value.value === true;\n                        });\n                        if (forceResolvers) {\n                            return BREAK;\n                        }\n                    }\n                },\n            },\n        });\n        return forceResolvers;\n    };\n    LocalState.prototype.buildRootValueFromCache = function (document, variables) {\n        return this.cache.diff({\n            query: buildQueryFromSelectionSet(document),\n            variables: variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n    };\n    LocalState.prototype.resolveDocument = function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n        if (context === void 0) { context = {}; }\n        if (variables === void 0) { variables = {}; }\n        if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }\n        if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }\n        return __awaiter(this, void 0, void 0, function () {\n            var mainDefinition, fragments, fragmentMap, definitionOperation, defaultOperationType, _a, cache, client, execContext;\n            return __generator(this, function (_b) {\n                mainDefinition = getMainDefinition(document);\n                fragments = getFragmentDefinitions(document);\n                fragmentMap = createFragmentMap(fragments);\n                definitionOperation = mainDefinition\n                    .operation;\n                defaultOperationType = definitionOperation\n                    ? definitionOperation.charAt(0).toUpperCase() +\n                        definitionOperation.slice(1)\n                    : 'Query';\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: __assign(__assign({}, context), { cache: cache,\n                        client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                return [2, this.resolveSelectionSet(mainDefinition.selectionSet, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return __generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return __awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return __generator(this, function (_a) {\n                        if (!shouldInclude(selection, variables)) {\n                            return [2];\n                        }\n                        if (isField(selection)) {\n                            return [2, this.resolveField(selection, rootValue, execContext).then(function (fieldResult) {\n                                    var _a;\n                                    if (typeof fieldResult !== 'undefined') {\n                                        resultsToMerge.push((_a = {},\n                                            _a[resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            fragment = fragmentMap[selection.name.value];\n                            process.env.NODE_ENV === \"production\" ? invariant(fragment, 11) : invariant(fragment, \"No fragment named \" + selection.name.value);\n                        }\n                        if (fragment && fragment.typeCondition) {\n                            typeCondition = fragment.typeCondition.name.value;\n                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {\n                                return [2, this.resolveSelectionSet(fragment.selectionSet, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2];\n                    });\n                }); };\n                return [2, Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return __generator(this, function (_a) {\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = resultKeyNameFromField(field);\n                aliasUsed = fieldName !== aliasedFieldName;\n                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];\n                resultPromise = Promise.resolve(defaultResult);\n                if (!execContext.onlyRunForcedResolvers ||\n                    this.shouldForceResolvers(field)) {\n                    resolverType = rootValue.__typename || execContext.defaultOperationType;\n                    resolverMap = this.resolvers && this.resolvers[resolverType];\n                    if (resolverMap) {\n                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n                        if (resolve) {\n                            resultPromise = Promise.resolve(cacheSlot.withValue(this.cache, resolve, [\n                                rootValue,\n                                argumentsObjectFromField(field, variables),\n                                execContext.context,\n                                { field: field, fragmentMap: execContext.fragmentMap },\n                            ]));\n                        }\n                    }\n                }\n                return [2, resultPromise.then(function (result) {\n                        if (result === void 0) { result = defaultResult; }\n                        if (field.directives) {\n                            field.directives.forEach(function (directive) {\n                                if (directive.name.value === 'export' && directive.arguments) {\n                                    directive.arguments.forEach(function (arg) {\n                                        if (arg.name.value === 'as' && arg.value.kind === 'StringValue') {\n                                            execContext.exportedVariables[arg.value.value] = result;\n                                        }\n                                    });\n                                }\n                            });\n                        }\n                        if (!field.selectionSet) {\n                            return result;\n                        }\n                        if (result == null) {\n                            return result;\n                        }\n                        if (Array.isArray(result)) {\n                            return _this.resolveSubSelectedArray(field, result, execContext);\n                        }\n                        if (field.selectionSet) {\n                            return _this.resolveSelectionSet(field.selectionSet, result, execContext);\n                        }\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSubSelectedArray = function (field, result, execContext) {\n        var _this = this;\n        return Promise.all(result.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return _this.resolveSubSelectedArray(field, item, execContext);\n            }\n            if (field.selectionSet) {\n                return _this.resolveSelectionSet(field.selectionSet, item, execContext);\n            }\n        }));\n    };\n    return LocalState;\n}());\nexport { LocalState };\n//# sourceMappingURL=LocalState.js.map","import { equal } from \"@wry/equality\";\nimport { isNonEmptyArray, graphQLResultHasError, } from \"../utilities/index.js\";\nimport { NetworkStatus, isNetworkRequestInFlight, } from \"./networkStatus.js\";\nvar QueryInfo = (function () {\n    function QueryInfo(cache) {\n        this.cache = cache;\n        this.listeners = new Set();\n        this.document = null;\n        this.lastRequestId = 1;\n        this.subscriptions = new Set();\n        this.dirty = false;\n        this.diff = null;\n        this.observableQuery = null;\n    }\n    QueryInfo.prototype.init = function (query) {\n        var networkStatus = query.networkStatus || NetworkStatus.loading;\n        if (this.variables &&\n            this.networkStatus !== NetworkStatus.loading &&\n            !equal(this.variables, query.variables)) {\n            networkStatus = NetworkStatus.setVariables;\n        }\n        if (!equal(query.variables, this.variables)) {\n            this.diff = null;\n        }\n        Object.assign(this, {\n            document: query.document,\n            variables: query.variables,\n            networkError: null,\n            graphQLErrors: this.graphQLErrors || [],\n            networkStatus: networkStatus,\n        });\n        if (query.observableQuery) {\n            this.setObservableQuery(query.observableQuery);\n        }\n        if (query.lastRequestId) {\n            this.lastRequestId = query.lastRequestId;\n        }\n        return this;\n    };\n    QueryInfo.prototype.getDiff = function (variables) {\n        if (variables === void 0) { variables = this.variables; }\n        if (this.diff && equal(variables, this.variables)) {\n            return this.diff;\n        }\n        this.updateWatch(this.variables = variables);\n        return this.diff = this.cache.diff({\n            query: this.document,\n            variables: variables,\n            returnPartialData: true,\n            optimistic: true,\n        });\n    };\n    QueryInfo.prototype.setDiff = function (diff) {\n        var _this = this;\n        var oldDiff = this.diff;\n        this.diff = diff;\n        if (!this.dirty && (diff === null || diff === void 0 ? void 0 : diff.result) !== (oldDiff === null || oldDiff === void 0 ? void 0 : oldDiff.result)) {\n            this.dirty = true;\n            if (!this.notifyTimeout) {\n                this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);\n            }\n        }\n    };\n    QueryInfo.prototype.setObservableQuery = function (oq) {\n        if (oq === this.observableQuery)\n            return;\n        if (this.oqListener) {\n            this.listeners.delete(this.oqListener);\n        }\n        this.observableQuery = oq;\n        if (oq) {\n            oq[\"queryInfo\"] = this;\n            this.listeners.add(this.oqListener = function () { return oq.reobserve(); });\n        }\n        else {\n            delete this.oqListener;\n        }\n    };\n    QueryInfo.prototype.notify = function () {\n        var _this = this;\n        if (this.notifyTimeout) {\n            clearTimeout(this.notifyTimeout);\n            this.notifyTimeout = void 0;\n        }\n        if (this.shouldNotify()) {\n            this.listeners.forEach(function (listener) { return listener(_this); });\n        }\n        this.dirty = false;\n    };\n    QueryInfo.prototype.shouldNotify = function () {\n        if (!this.dirty || !this.listeners.size) {\n            return false;\n        }\n        if (isNetworkRequestInFlight(this.networkStatus) &&\n            this.observableQuery) {\n            var fetchPolicy = this.observableQuery.options.fetchPolicy;\n            if (fetchPolicy !== \"cache-only\" &&\n                fetchPolicy !== \"cache-and-network\") {\n                return false;\n            }\n        }\n        return true;\n    };\n    QueryInfo.prototype.stop = function () {\n        this.cancel();\n        delete this.cancel;\n        var oq = this.observableQuery;\n        if (oq)\n            oq.stopPolling();\n    };\n    QueryInfo.prototype.cancel = function () { };\n    QueryInfo.prototype.updateWatch = function (variables) {\n        var _this = this;\n        if (variables === void 0) { variables = this.variables; }\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return;\n        }\n        if (!this.lastWatch ||\n            this.lastWatch.query !== this.document ||\n            !equal(variables, this.lastWatch.variables)) {\n            this.cancel();\n            this.cancel = this.cache.watch(this.lastWatch = {\n                query: this.document,\n                variables: variables,\n                optimistic: true,\n                callback: function (diff) { return _this.setDiff(diff); },\n            });\n        }\n    };\n    QueryInfo.prototype.markResult = function (result, options, allowCacheWrite) {\n        var _this = this;\n        this.graphQLErrors = isNonEmptyArray(result.errors) ? result.errors : [];\n        if (options.fetchPolicy === 'no-cache') {\n            this.diff = { result: result.data, complete: true };\n        }\n        else if (allowCacheWrite) {\n            var ignoreErrors = options.errorPolicy === 'ignore' ||\n                options.errorPolicy === 'all';\n            var writeWithErrors = !graphQLResultHasError(result);\n            if (!writeWithErrors && ignoreErrors && result.data) {\n                writeWithErrors = true;\n            }\n            if (writeWithErrors) {\n                this.cache.performTransaction(function (cache) {\n                    if (_this.lastWrittenResult &&\n                        equal(result.data, _this.lastWrittenResult.data) &&\n                        equal(options.variables, _this.lastWrittenVars)) {\n                        if (_this.diff && _this.diff.complete) {\n                            result.data = _this.diff.result;\n                            return;\n                        }\n                    }\n                    else {\n                        cache.writeQuery({\n                            query: _this.document,\n                            data: result.data,\n                            variables: options.variables,\n                        });\n                        _this.lastWrittenResult = result;\n                        _this.lastWrittenVars = options.variables;\n                    }\n                    var diff = cache.diff({\n                        query: _this.document,\n                        variables: options.variables,\n                        returnPartialData: true,\n                        optimistic: true,\n                    });\n                    _this.updateWatch(options.variables);\n                    _this.diff = diff;\n                    if (diff.complete) {\n                        result.data = diff.result;\n                    }\n                });\n            }\n            else {\n                this.lastWrittenResult = this.lastWrittenVars = void 0;\n            }\n        }\n    };\n    QueryInfo.prototype.markReady = function () {\n        this.networkError = null;\n        return this.networkStatus = NetworkStatus.ready;\n    };\n    QueryInfo.prototype.markError = function (error) {\n        this.networkStatus = NetworkStatus.error;\n        this.lastWrittenResult = this.lastWrittenVars = void 0;\n        if (error.graphQLErrors) {\n            this.graphQLErrors = error.graphQLErrors;\n        }\n        if (error.networkError) {\n            this.networkError = error.networkError;\n        }\n        return error;\n    };\n    return QueryInfo;\n}());\nexport { QueryInfo };\n//# sourceMappingURL=QueryInfo.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { equal } from '@wry/equality';\nimport { execute } from \"../link/core/index.js\";\nimport { getDefaultValues, getOperationDefinition, getOperationName, hasClientExports, graphQLResultHasError, removeConnectionDirectiveFromDocument, canUseWeakMap, Observable, asyncMap, isNonEmptyArray, Concast, } from \"../utilities/index.js\";\nimport { ApolloError, isApolloError } from \"../errors/index.js\";\nimport { MutationStore } from \"./MutationStore.js\";\nimport { ObservableQuery } from \"./ObservableQuery.js\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { LocalState } from \"./LocalState.js\";\nimport { QueryInfo } from \"./QueryInfo.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar QueryManager = (function () {\n    function QueryManager(_a) {\n        var cache = _a.cache, link = _a.link, _b = _a.queryDeduplication, queryDeduplication = _b === void 0 ? false : _b, _c = _a.onBroadcast, onBroadcast = _c === void 0 ? function () { return undefined; } : _c, _d = _a.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = _a.clientAwareness, clientAwareness = _e === void 0 ? {} : _e, localState = _a.localState, assumeImmutableResults = _a.assumeImmutableResults;\n        this.mutationStore = new MutationStore();\n        this.clientAwareness = {};\n        this.queries = new Map();\n        this.fetchCancelFns = new Map();\n        this.transformCache = new (canUseWeakMap ? WeakMap : Map)();\n        this.queryIdCounter = 1;\n        this.requestIdCounter = 1;\n        this.mutationIdCounter = 1;\n        this.inFlightLinkObservables = new Map();\n        this.cache = cache;\n        this.link = link;\n        this.queryDeduplication = queryDeduplication;\n        this.onBroadcast = onBroadcast;\n        this.clientAwareness = clientAwareness;\n        this.localState = localState || new LocalState({ cache: cache });\n        this.ssrMode = ssrMode;\n        this.assumeImmutableResults = !!assumeImmutableResults;\n    }\n    QueryManager.prototype.stop = function () {\n        var _this = this;\n        this.queries.forEach(function (_info, queryId) {\n            _this.stopQueryNoBroadcast(queryId);\n        });\n        this.cancelPendingFetches(process.env.NODE_ENV === \"production\" ? new InvariantError(13) : new InvariantError('QueryManager stopped while query was in flight'));\n    };\n    QueryManager.prototype.cancelPendingFetches = function (error) {\n        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });\n        this.fetchCancelFns.clear();\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        var mutation = _a.mutation, variables = _a.variables, optimisticResponse = _a.optimisticResponse, updateQueriesByName = _a.updateQueries, _b = _a.refetchQueries, refetchQueries = _b === void 0 ? [] : _b, _c = _a.awaitRefetchQueries, awaitRefetchQueries = _c === void 0 ? false : _c, updateWithProxyFn = _a.update, _d = _a.errorPolicy, errorPolicy = _d === void 0 ? 'none' : _d, fetchPolicy = _a.fetchPolicy, _e = _a.context, context = _e === void 0 ? {} : _e;\n        return __awaiter(this, void 0, void 0, function () {\n            var mutationId, generateUpdateQueriesInfo, optimistic_1, self;\n            var _this = this;\n            return __generator(this, function (_f) {\n                switch (_f.label) {\n                    case 0:\n                        process.env.NODE_ENV === \"production\" ? invariant(mutation, 14) : invariant(mutation, 'mutation option is required. You must specify your GraphQL document in the mutation option.');\n                        process.env.NODE_ENV === \"production\" ? invariant(!fetchPolicy || fetchPolicy === 'no-cache', 15) : invariant(!fetchPolicy || fetchPolicy === 'no-cache', \"Mutations only support a 'no-cache' fetchPolicy. If you don't want to disable the cache, remove your fetchPolicy setting to proceed with the default mutation behavior.\");\n                        mutationId = this.generateMutationId();\n                        mutation = this.transform(mutation).document;\n                        variables = this.getVariables(mutation, variables);\n                        if (!this.transform(mutation).hasClientExports) return [3, 2];\n                        return [4, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = _f.sent();\n                        _f.label = 2;\n                    case 2:\n                        generateUpdateQueriesInfo = function () {\n                            var ret = {};\n                            if (updateQueriesByName) {\n                                _this.queries.forEach(function (_a, queryId) {\n                                    var observableQuery = _a.observableQuery;\n                                    if (observableQuery) {\n                                        var queryName = observableQuery.queryName;\n                                        if (queryName &&\n                                            hasOwnProperty.call(updateQueriesByName, queryName)) {\n                                            ret[queryId] = {\n                                                updater: updateQueriesByName[queryName],\n                                                queryInfo: _this.queries.get(queryId),\n                                            };\n                                        }\n                                    }\n                                });\n                            }\n                            return ret;\n                        };\n                        this.mutationStore.initMutation(mutationId, mutation, variables);\n                        if (optimisticResponse) {\n                            optimistic_1 = typeof optimisticResponse === 'function'\n                                ? optimisticResponse(variables)\n                                : optimisticResponse;\n                            this.cache.recordOptimisticTransaction(function (cache) {\n                                try {\n                                    markMutationResult({\n                                        mutationId: mutationId,\n                                        result: { data: optimistic_1 },\n                                        document: mutation,\n                                        variables: variables,\n                                        queryUpdatersById: generateUpdateQueriesInfo(),\n                                        update: updateWithProxyFn,\n                                    }, cache);\n                                }\n                                catch (error) {\n                                    process.env.NODE_ENV === \"production\" || invariant.error(error);\n                                }\n                            }, mutationId);\n                        }\n                        this.broadcastQueries();\n                        self = this;\n                        return [2, new Promise(function (resolve, reject) {\n                                var storeResult;\n                                var error;\n                                self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: optimisticResponse }), variables, false).subscribe({\n                                    next: function (result) {\n                                        if (graphQLResultHasError(result) && errorPolicy === 'none') {\n                                            error = new ApolloError({\n                                                graphQLErrors: result.errors,\n                                            });\n                                            return;\n                                        }\n                                        self.mutationStore.markMutationResult(mutationId);\n                                        if (fetchPolicy !== 'no-cache') {\n                                            try {\n                                                markMutationResult({\n                                                    mutationId: mutationId,\n                                                    result: result,\n                                                    document: mutation,\n                                                    variables: variables,\n                                                    queryUpdatersById: generateUpdateQueriesInfo(),\n                                                    update: updateWithProxyFn,\n                                                }, self.cache);\n                                            }\n                                            catch (e) {\n                                                error = new ApolloError({\n                                                    networkError: e,\n                                                });\n                                                return;\n                                            }\n                                        }\n                                        storeResult = result;\n                                    },\n                                    error: function (err) {\n                                        self.mutationStore.markMutationError(mutationId, err);\n                                        if (optimisticResponse) {\n                                            self.cache.removeOptimistic(mutationId);\n                                        }\n                                        self.broadcastQueries();\n                                        reject(new ApolloError({\n                                            networkError: err,\n                                        }));\n                                    },\n                                    complete: function () {\n                                        if (error) {\n                                            self.mutationStore.markMutationError(mutationId, error);\n                                        }\n                                        if (optimisticResponse) {\n                                            self.cache.removeOptimistic(mutationId);\n                                        }\n                                        self.broadcastQueries();\n                                        if (error) {\n                                            reject(error);\n                                            return;\n                                        }\n                                        if (typeof refetchQueries === 'function') {\n                                            refetchQueries = refetchQueries(storeResult);\n                                        }\n                                        var refetchQueryPromises = [];\n                                        if (isNonEmptyArray(refetchQueries)) {\n                                            refetchQueries.forEach(function (refetchQuery) {\n                                                if (typeof refetchQuery === 'string') {\n                                                    self.queries.forEach(function (_a) {\n                                                        var observableQuery = _a.observableQuery;\n                                                        if (observableQuery &&\n                                                            observableQuery.queryName === refetchQuery) {\n                                                            refetchQueryPromises.push(observableQuery.refetch());\n                                                        }\n                                                    });\n                                                }\n                                                else {\n                                                    var queryOptions = {\n                                                        query: refetchQuery.query,\n                                                        variables: refetchQuery.variables,\n                                                        fetchPolicy: 'network-only',\n                                                    };\n                                                    if (refetchQuery.context) {\n                                                        queryOptions.context = refetchQuery.context;\n                                                    }\n                                                    refetchQueryPromises.push(self.query(queryOptions));\n                                                }\n                                            });\n                                        }\n                                        Promise.all(awaitRefetchQueries ? refetchQueryPromises : []).then(function () {\n                                            if (errorPolicy === 'ignore' &&\n                                                storeResult &&\n                                                graphQLResultHasError(storeResult)) {\n                                                delete storeResult.errors;\n                                            }\n                                            resolve(storeResult);\n                                        }, reject);\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {\n        return this.fetchQueryObservable(queryId, options, networkStatus).promise;\n    };\n    QueryManager.prototype.getQueryStore = function () {\n        var store = Object.create(null);\n        this.queries.forEach(function (info, queryId) {\n            store[queryId] = {\n                variables: info.variables,\n                networkStatus: info.networkStatus,\n                networkError: info.networkError,\n                graphQLErrors: info.graphQLErrors,\n            };\n        });\n        return store;\n    };\n    QueryManager.prototype.resetErrors = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo) {\n            queryInfo.networkError = undefined;\n            queryInfo.graphQLErrors = [];\n        }\n    };\n    QueryManager.prototype.transform = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var transformed = this.cache.transformDocument(document);\n            var forLink = removeConnectionDirectiveFromDocument(this.cache.transformForLink(transformed));\n            var clientQuery = this.localState.clientQuery(transformed);\n            var serverQuery = forLink && this.localState.serverQuery(forLink);\n            var cacheEntry_1 = {\n                document: transformed,\n                hasClientExports: hasClientExports(transformed),\n                hasForcedResolvers: this.localState.shouldForceResolvers(transformed),\n                clientQuery: clientQuery,\n                serverQuery: serverQuery,\n                defaultVars: getDefaultValues(getOperationDefinition(transformed)),\n            };\n            var add = function (doc) {\n                if (doc && !transformCache.has(doc)) {\n                    transformCache.set(doc, cacheEntry_1);\n                }\n            };\n            add(document);\n            add(transformed);\n            add(clientQuery);\n            add(serverQuery);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return __assign(__assign({}, this.transform(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options) {\n        options = __assign(__assign({}, options), { variables: this.getVariables(options.query, options.variables) });\n        if (typeof options.notifyOnNetworkStatusChange === 'undefined') {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var queryInfo = new QueryInfo(this.cache);\n        var observable = new ObservableQuery({\n            queryManager: this,\n            queryInfo: queryInfo,\n            options: options,\n        });\n        this.queries.set(observable.queryId, queryInfo);\n        queryInfo.init({\n            document: options.query,\n            observableQuery: observable,\n            variables: options.variables,\n        });\n        return observable;\n    };\n    QueryManager.prototype.query = function (options) {\n        var _this = this;\n        process.env.NODE_ENV === \"production\" ? invariant(options.query, 16) : invariant(options.query, 'query option is required. You must specify your GraphQL document ' +\n            'in the query option.');\n        process.env.NODE_ENV === \"production\" ? invariant(options.query.kind === 'Document', 17) : invariant(options.query.kind === 'Document', 'You must wrap the query string in a \"gql\" tag.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.returnPartialData, 18) : invariant(!options.returnPartialData, 'returnPartialData option only supported on watchQuery.');\n        process.env.NODE_ENV === \"production\" ? invariant(!options.pollInterval, 19) : invariant(!options.pollInterval, 'pollInterval option only supported on watchQuery.');\n        var queryId = this.generateQueryId();\n        return this.fetchQuery(queryId, options).finally(function () { return _this.stopQuery(queryId); });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.queryIdCounter++);\n    };\n    QueryManager.prototype.generateRequestId = function () {\n        return this.requestIdCounter++;\n    };\n    QueryManager.prototype.generateMutationId = function () {\n        return String(this.mutationIdCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo)\n            queryInfo.stop();\n    };\n    QueryManager.prototype.clearStore = function () {\n        this.cancelPendingFetches(process.env.NODE_ENV === \"production\" ? new InvariantError(20) : new InvariantError('Store reset while query was in flight (not completed in link chain)'));\n        this.queries.forEach(function (queryInfo) {\n            if (queryInfo.observableQuery) {\n                queryInfo.networkStatus = NetworkStatus.loading;\n            }\n            else {\n                queryInfo.stop();\n            }\n        });\n        this.mutationStore.reset();\n        return this.cache.reset();\n    };\n    QueryManager.prototype.resetStore = function () {\n        var _this = this;\n        return this.clearStore().then(function () {\n            return _this.reFetchObservableQueries();\n        });\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.queries.forEach(function (_a, queryId) {\n            var observableQuery = _a.observableQuery;\n            if (observableQuery) {\n                var fetchPolicy = observableQuery.options.fetchPolicy;\n                observableQuery.resetLastResults();\n                if (fetchPolicy !== 'cache-only' &&\n                    (includeStandby || fetchPolicy !== 'standby')) {\n                    observableQueryPromises.push(observableQuery.refetch());\n                }\n                _this.getQuery(queryId).setDiff(null);\n            }\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.setObservableQuery = function (observableQuery) {\n        this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (_a) {\n        var _this = this;\n        var query = _a.query, fetchPolicy = _a.fetchPolicy, variables = _a.variables, _b = _a.context, context = _b === void 0 ? {} : _b;\n        query = this.transform(query).document;\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, context, variables, false).map(function (result) {\n                if (!fetchPolicy || fetchPolicy !== 'no-cache') {\n                    if (!graphQLResultHasError(result)) {\n                        _this.cache.write({\n                            query: query,\n                            result: result.data,\n                            dataId: 'ROOT_SUBSCRIPTION',\n                            variables: variables,\n                        });\n                    }\n                    _this.broadcastQueries();\n                }\n                if (graphQLResultHasError(result)) {\n                    throw new ApolloError({\n                        graphQLErrors: result.errors,\n                    });\n                }\n                return result;\n            });\n        };\n        if (this.transform(query).hasClientExports) {\n            var observablePromise_1 = this.localState.addExportedVariables(query, variables, context).then(makeObservable);\n            return new Observable(function (observer) {\n                var sub = null;\n                observablePromise_1.then(function (observable) { return sub = observable.subscribe(observer); }, observer.error);\n                return function () { return sub && sub.unsubscribe(); };\n            });\n        }\n        return makeObservable(variables);\n    };\n    QueryManager.prototype.stopQuery = function (queryId) {\n        this.stopQueryNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.removeQuery(queryId);\n    };\n    QueryManager.prototype.removeQuery = function (queryId) {\n        this.fetchCancelFns.delete(queryId);\n        this.getQuery(queryId).subscriptions.forEach(function (x) { return x.unsubscribe(); });\n        this.queries.delete(queryId);\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        this.onBroadcast();\n        this.queries.forEach(function (info) { return info.notify(); });\n    };\n    QueryManager.prototype.getLocalState = function () {\n        return this.localState;\n    };\n    QueryManager.prototype.getObservableFromLink = function (query, context, variables, deduplication) {\n        var _this = this;\n        var _a;\n        if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }\n        var observable;\n        var serverQuery = this.transform(query).serverQuery;\n        if (serverQuery) {\n            var _b = this, inFlightLinkObservables_1 = _b.inFlightLinkObservables, link = _b.link;\n            var operation = {\n                query: serverQuery,\n                variables: variables,\n                operationName: getOperationName(serverQuery) || void 0,\n                context: this.prepareContext(__assign(__assign({}, context), { forceFetch: !deduplication })),\n            };\n            context = operation.context;\n            if (deduplication) {\n                var byVariables_1 = inFlightLinkObservables_1.get(serverQuery) || new Map();\n                inFlightLinkObservables_1.set(serverQuery, byVariables_1);\n                var varJson_1 = JSON.stringify(variables);\n                observable = byVariables_1.get(varJson_1);\n                if (!observable) {\n                    var concast = new Concast([\n                        execute(link, operation)\n                    ]);\n                    byVariables_1.set(varJson_1, observable = concast);\n                    concast.cleanup(function () {\n                        if (byVariables_1.delete(varJson_1) &&\n                            byVariables_1.size < 1) {\n                            inFlightLinkObservables_1.delete(serverQuery);\n                        }\n                    });\n                }\n            }\n            else {\n                observable = new Concast([\n                    execute(link, operation)\n                ]);\n            }\n        }\n        else {\n            observable = new Concast([\n                Observable.of({ data: {} })\n            ]);\n            context = this.prepareContext(context);\n        }\n        var clientQuery = this.transform(query).clientQuery;\n        if (clientQuery) {\n            observable = asyncMap(observable, function (result) {\n                return _this.localState.runResolvers({\n                    document: clientQuery,\n                    remoteResult: result,\n                    context: context,\n                    variables: variables,\n                });\n            });\n        }\n        return observable;\n    };\n    QueryManager.prototype.getResultsFromLink = function (queryInfo, allowCacheWrite, options) {\n        var lastRequestId = queryInfo.lastRequestId;\n        return asyncMap(this.getObservableFromLink(queryInfo.document, options.context, options.variables), function (result) {\n            var hasErrors = isNonEmptyArray(result.errors);\n            if (lastRequestId >= queryInfo.lastRequestId) {\n                if (hasErrors && options.errorPolicy === \"none\") {\n                    throw queryInfo.markError(new ApolloError({\n                        graphQLErrors: result.errors,\n                    }));\n                }\n                queryInfo.markResult(result, options, allowCacheWrite);\n                queryInfo.markReady();\n            }\n            var aqr = {\n                data: result.data,\n                loading: false,\n                networkStatus: queryInfo.networkStatus || NetworkStatus.ready,\n            };\n            if (hasErrors && options.errorPolicy !== \"ignore\") {\n                aqr.errors = result.errors;\n            }\n            return aqr;\n        }, function (networkError) {\n            var error = isApolloError(networkError)\n                ? networkError\n                : new ApolloError({ networkError: networkError });\n            if (lastRequestId >= queryInfo.lastRequestId) {\n                queryInfo.markError(error);\n            }\n            throw error;\n        });\n    };\n    QueryManager.prototype.fetchQueryObservable = function (queryId, options, networkStatus) {\n        var _this = this;\n        if (networkStatus === void 0) { networkStatus = NetworkStatus.loading; }\n        var query = this.transform(options.query).document;\n        var variables = this.getVariables(query, options.variables);\n        var queryInfo = this.getQuery(queryId);\n        var oldNetworkStatus = queryInfo.networkStatus;\n        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? \"none\" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;\n        var mightUseNetwork = fetchPolicy === \"cache-first\" ||\n            fetchPolicy === \"cache-and-network\" ||\n            fetchPolicy === \"network-only\" ||\n            fetchPolicy === \"no-cache\";\n        if (mightUseNetwork &&\n            notifyOnNetworkStatusChange &&\n            typeof oldNetworkStatus === \"number\" &&\n            oldNetworkStatus !== networkStatus &&\n            isNetworkRequestInFlight(networkStatus)) {\n            if (fetchPolicy !== \"cache-first\") {\n                fetchPolicy = \"cache-and-network\";\n            }\n            returnPartialData = true;\n        }\n        var normalized = Object.assign({}, options, {\n            query: query,\n            variables: variables,\n            fetchPolicy: fetchPolicy,\n            errorPolicy: errorPolicy,\n            returnPartialData: returnPartialData,\n            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,\n            context: context,\n        });\n        var fromVariables = function (variables) {\n            normalized.variables = variables;\n            return _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);\n        };\n        this.fetchCancelFns.set(queryId, function (reason) {\n            Promise.resolve().then(function () { return concast.cancel(reason); });\n        });\n        var concast = new Concast(this.transform(normalized.query).hasClientExports\n            ? this.localState.addExportedVariables(normalized.query, normalized.variables, normalized.context).then(fromVariables)\n            : fromVariables(normalized.variables));\n        concast.cleanup(function () {\n            _this.fetchCancelFns.delete(queryId);\n            if (options.nextFetchPolicy) {\n                options.fetchPolicy = options.nextFetchPolicy;\n                options.nextFetchPolicy = void 0;\n            }\n        });\n        return concast;\n    };\n    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, options, networkStatus) {\n        var _this = this;\n        var query = options.query, variables = options.variables, fetchPolicy = options.fetchPolicy, errorPolicy = options.errorPolicy, returnPartialData = options.returnPartialData, context = options.context;\n        queryInfo.init({\n            document: query,\n            variables: variables,\n            lastRequestId: this.generateRequestId(),\n            networkStatus: networkStatus,\n        });\n        var readCache = function () { return queryInfo.getDiff(variables); };\n        var resultsFromCache = function (diff, networkStatus) {\n            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || NetworkStatus.loading; }\n            var data = diff.result;\n            if (process.env.NODE_ENV !== 'production' &&\n                isNonEmptyArray(diff.missing) &&\n                !equal(data, {})) {\n                process.env.NODE_ENV === \"production\" || invariant.warn(\"Missing cache result fields: \" + diff.missing.map(function (m) { return m.path.join('.'); }).join(', '), diff.missing);\n            }\n            var fromData = function (data) { return Observable.of(__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true }))); };\n            if (_this.transform(query).hasForcedResolvers) {\n                return _this.localState.runResolvers({\n                    document: query,\n                    remoteResult: { data: data },\n                    context: context,\n                    variables: variables,\n                    onlyRunForcedResolvers: true,\n                }).then(function (resolved) { return fromData(resolved.data); });\n            }\n            return fromData(data);\n        };\n        var resultsFromLink = function (allowCacheWrite) {\n            return _this.getResultsFromLink(queryInfo, allowCacheWrite, {\n                variables: variables,\n                context: context,\n                fetchPolicy: fetchPolicy,\n                errorPolicy: errorPolicy,\n            });\n        };\n        switch (fetchPolicy) {\n            default:\n            case \"cache-first\": {\n                var diff = readCache();\n                if (diff.complete) {\n                    return [\n                        resultsFromCache(diff, queryInfo.markReady()),\n                    ];\n                }\n                if (returnPartialData) {\n                    return [\n                        resultsFromCache(diff),\n                        resultsFromLink(true),\n                    ];\n                }\n                return [\n                    resultsFromLink(true),\n                ];\n            }\n            case \"cache-and-network\": {\n                var diff = readCache();\n                if (diff.complete || returnPartialData) {\n                    return [\n                        resultsFromCache(diff),\n                        resultsFromLink(true),\n                    ];\n                }\n                return [\n                    resultsFromLink(true),\n                ];\n            }\n            case \"cache-only\":\n                return [\n                    resultsFromCache(readCache(), queryInfo.markReady()),\n                ];\n            case \"network-only\":\n                return [resultsFromLink(true)];\n            case \"no-cache\":\n                return [resultsFromLink(false)];\n            case \"standby\":\n                return [];\n        }\n    };\n    QueryManager.prototype.getQuery = function (queryId) {\n        if (queryId && !this.queries.has(queryId)) {\n            this.queries.set(queryId, new QueryInfo(this.cache));\n        }\n        return this.queries.get(queryId);\n    };\n    QueryManager.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var newContext = this.localState.prepareContext(context);\n        return __assign(__assign({}, newContext), { clientAwareness: this.clientAwareness });\n    };\n    return QueryManager;\n}());\nexport { QueryManager };\nfunction markMutationResult(mutation, cache) {\n    if (!graphQLResultHasError(mutation.result)) {\n        var cacheWrites_1 = [{\n                result: mutation.result.data,\n                dataId: 'ROOT_MUTATION',\n                query: mutation.document,\n                variables: mutation.variables,\n            }];\n        var queryUpdatersById_1 = mutation.queryUpdatersById;\n        if (queryUpdatersById_1) {\n            Object.keys(queryUpdatersById_1).forEach(function (id) {\n                var _a = queryUpdatersById_1[id], updater = _a.updater, _b = _a.queryInfo, document = _b.document, variables = _b.variables;\n                var _c = cache.diff({\n                    query: document,\n                    variables: variables,\n                    returnPartialData: true,\n                    optimistic: false,\n                }), currentQueryResult = _c.result, complete = _c.complete;\n                if (complete && currentQueryResult) {\n                    var nextQueryResult = updater(currentQueryResult, {\n                        mutationResult: mutation.result,\n                        queryName: getOperationName(document) || undefined,\n                        queryVariables: variables,\n                    });\n                    if (nextQueryResult) {\n                        cacheWrites_1.push({\n                            result: nextQueryResult,\n                            dataId: 'ROOT_QUERY',\n                            query: document,\n                            variables: variables,\n                        });\n                    }\n                }\n            });\n        }\n        cache.performTransaction(function (c) {\n            cacheWrites_1.forEach(function (write) { return c.write(write); });\n            var update = mutation.update;\n            if (update) {\n                update(c, mutation.result);\n            }\n        }, null);\n    }\n}\n//# sourceMappingURL=QueryManager.js.map","import { __assign } from \"tslib\";\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { ApolloLink, execute } from \"../link/core/index.js\";\nimport { compact } from \"../utilities/index.js\";\nimport { version } from \"../version.js\";\nimport { HttpLink } from \"../link/http/index.js\";\nimport { QueryManager } from \"./QueryManager.js\";\nimport { LocalState, } from \"./LocalState.js\";\nvar hasSuggestedDevtools = false;\nvar ApolloClient = (function () {\n    function ApolloClient(options) {\n        var _this = this;\n        this.defaultOptions = {};\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, connectToDevTools = options.connectToDevTools, _c = options.queryDeduplication, queryDeduplication = _c === void 0 ? true : _c, defaultOptions = options.defaultOptions, _d = options.assumeImmutableResults, assumeImmutableResults = _d === void 0 ? false : _d, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version;\n        var link = options.link;\n        if (!link) {\n            link = uri\n                ? new HttpLink({ uri: uri, credentials: credentials, headers: headers })\n                : ApolloLink.empty();\n        }\n        if (!cache) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(9) : new InvariantError(\"To initialize Apollo Client, you must specify a 'cache' property \" +\n                \"in the options object. \\n\" +\n                \"For more information, please visit: https://go.apollo.dev/c/docs\");\n        }\n        this.link = link;\n        this.cache = cache;\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || {};\n        this.typeDefs = typeDefs;\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        var defaultConnectToDevTools = process.env.NODE_ENV !== 'production' &&\n            typeof window !== 'undefined' &&\n            !window.__APOLLO_CLIENT__;\n        if (typeof connectToDevTools === 'undefined'\n            ? defaultConnectToDevTools\n            : connectToDevTools && typeof window !== 'undefined') {\n            window.__APOLLO_CLIENT__ = this;\n        }\n        if (!hasSuggestedDevtools && process.env.NODE_ENV !== 'production') {\n            hasSuggestedDevtools = true;\n            if (typeof window !== 'undefined' &&\n                window.document &&\n                window.top === window.self) {\n                if (typeof window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n                    if (window.navigator &&\n                        window.navigator.userAgent &&\n                        window.navigator.userAgent.indexOf('Chrome') > -1) {\n                        console.debug('Download the Apollo DevTools ' +\n                            'for a better development experience: ' +\n                            'https://chrome.google.com/webstore/detail/apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm');\n                    }\n                }\n            }\n        }\n        this.version = version;\n        this.localState = new LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager({\n            cache: this.cache,\n            link: this.link,\n            queryDeduplication: queryDeduplication,\n            ssrMode: ssrMode,\n            clientAwareness: {\n                name: clientAwarenessName,\n                version: clientAwarenessVersion,\n            },\n            localState: this.localState,\n            assumeImmutableResults: assumeImmutableResults,\n            onBroadcast: function () {\n                if (_this.devToolsHookCb) {\n                    _this.devToolsHookCb({\n                        action: {},\n                        state: {\n                            queries: _this.queryManager.getQueryStore(),\n                            mutations: _this.queryManager.mutationStore.getStore(),\n                        },\n                        dataWithOptimisticResults: _this.cache.extract(true),\n                    });\n                }\n            },\n        });\n    }\n    ApolloClient.prototype.stop = function () {\n        this.queryManager.stop();\n    };\n    ApolloClient.prototype.watchQuery = function (options) {\n        if (this.defaultOptions.watchQuery) {\n            options = compact(this.defaultOptions.watchQuery, options);\n        }\n        if (this.disableNetworkFetches &&\n            (options.fetchPolicy === 'network-only' ||\n                options.fetchPolicy === 'cache-and-network')) {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.watchQuery(options);\n    };\n    ApolloClient.prototype.query = function (options) {\n        if (this.defaultOptions.query) {\n            options = compact(this.defaultOptions.query, options);\n        }\n        process.env.NODE_ENV === \"production\" ? invariant(options.fetchPolicy !== 'cache-and-network', 10) : invariant(options.fetchPolicy !== 'cache-and-network', 'The cache-and-network fetchPolicy does not work with client.query, because ' +\n            'client.query can only return a single result. Please use client.watchQuery ' +\n            'to receive multiple results from the cache and the network, or consider ' +\n            'using a different fetchPolicy, such as cache-first or network-only.');\n        if (this.disableNetworkFetches && options.fetchPolicy === 'network-only') {\n            options = __assign(__assign({}, options), { fetchPolicy: 'cache-first' });\n        }\n        return this.queryManager.query(options);\n    };\n    ApolloClient.prototype.mutate = function (options) {\n        if (this.defaultOptions.mutate) {\n            options = compact(this.defaultOptions.mutate, options);\n        }\n        return this.queryManager.mutate(options);\n    };\n    ApolloClient.prototype.subscribe = function (options) {\n        return this.queryManager.startGraphQLSubscription(options);\n    };\n    ApolloClient.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readQuery(options, optimistic);\n    };\n    ApolloClient.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readFragment(options, optimistic);\n    };\n    ApolloClient.prototype.writeQuery = function (options) {\n        this.cache.writeQuery(options);\n        this.queryManager.broadcastQueries();\n    };\n    ApolloClient.prototype.writeFragment = function (options) {\n        this.cache.writeFragment(options);\n        this.queryManager.broadcastQueries();\n    };\n    ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n        this.devToolsHookCb = cb;\n    };\n    ApolloClient.prototype.__requestRaw = function (payload) {\n        return execute(this.link, payload);\n    };\n    ApolloClient.prototype.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () { return _this.queryManager.clearStore(); })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    ApolloClient.prototype.onResetStore = function (cb) {\n        var _this = this;\n        this.resetStoreCallbacks.push(cb);\n        return function () {\n            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.onClearStore = function (cb) {\n        var _this = this;\n        this.clearStoreCallbacks.push(cb);\n        return function () {\n            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    ApolloClient.prototype.setLink = function (newLink) {\n        this.link = this.queryManager.link = newLink;\n    };\n    return ApolloClient;\n}());\nexport { ApolloClient };\n//# sourceMappingURL=ApolloClient.js.map","export var version = 'local';\n//# sourceMappingURL=version.js.map","import { NetworkStatus } from \"./networkStatus.js\";\nimport { compact } from \"../utilities/index.js\";\nimport { invariant } from 'ts-invariant';\nvar Reobserver = (function () {\n    function Reobserver(observer, options, fetch, shouldFetch) {\n        this.observer = observer;\n        this.options = options;\n        this.fetch = fetch;\n        this.shouldFetch = shouldFetch;\n    }\n    Reobserver.prototype.reobserve = function (newOptions, newNetworkStatus) {\n        if (newOptions) {\n            this.updateOptions(newOptions);\n        }\n        else {\n            this.updatePolling();\n        }\n        var concast = this.fetch(this.options, newNetworkStatus);\n        if (this.concast) {\n            this.concast.removeObserver(this.observer, true);\n        }\n        concast.addObserver(this.observer);\n        return (this.concast = concast).promise;\n    };\n    Reobserver.prototype.updateOptions = function (newOptions) {\n        Object.assign(this.options, compact(newOptions));\n        this.updatePolling();\n        return this;\n    };\n    Reobserver.prototype.stop = function () {\n        if (this.concast) {\n            this.concast.removeObserver(this.observer);\n            delete this.concast;\n        }\n        if (this.pollingInfo) {\n            clearTimeout(this.pollingInfo.timeout);\n            this.options.pollInterval = 0;\n            this.updatePolling();\n        }\n    };\n    Reobserver.prototype.updatePolling = function () {\n        var _this = this;\n        var _a = this, pollingInfo = _a.pollingInfo, pollInterval = _a.options.pollInterval;\n        if (!pollInterval) {\n            if (pollingInfo) {\n                clearTimeout(pollingInfo.timeout);\n                delete this.pollingInfo;\n            }\n            return;\n        }\n        if (pollingInfo &&\n            pollingInfo.interval === pollInterval) {\n            return;\n        }\n        process.env.NODE_ENV === \"production\" ? invariant(pollInterval, 21) : invariant(pollInterval, 'Attempted to start a polling query without a polling interval.');\n        if (this.shouldFetch === false) {\n            return;\n        }\n        var info = pollingInfo || (this.pollingInfo = {});\n        info.interval = pollInterval;\n        var maybeFetch = function () {\n            if (_this.pollingInfo) {\n                if (_this.shouldFetch && _this.shouldFetch()) {\n                    _this.reobserve({\n                        fetchPolicy: \"network-only\",\n                    }, NetworkStatus.poll).then(poll, poll);\n                }\n                else {\n                    poll();\n                }\n            }\n            ;\n        };\n        var poll = function () {\n            var info = _this.pollingInfo;\n            if (info) {\n                clearTimeout(info.timeout);\n                info.timeout = setTimeout(maybeFetch, info.interval);\n            }\n        };\n        poll();\n    };\n    return Reobserver;\n}());\nexport { Reobserver };\n//# sourceMappingURL=Reobserver.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant, InvariantError } from 'ts-invariant';\nimport { equal } from '@wry/equality';\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { cloneDeep, getOperationDefinition, Observable, iterateObserversSafely, isNonEmptyArray, } from \"../utilities/index.js\";\nimport { Reobserver } from \"./Reobserver.js\";\nvar warnedAboutUpdateQuery = false;\nvar ObservableQuery = (function (_super) {\n    __extends(ObservableQuery, _super);\n    function ObservableQuery(_a) {\n        var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;\n        var _this = _super.call(this, function (observer) {\n            return _this.onSubscribe(observer);\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        _this.observer = {\n            next: function (result) {\n                if (_this.lastError || _this.isDifferentFromLastResult(result)) {\n                    _this.updateLastResult(result);\n                    iterateObserversSafely(_this.observers, 'next', result);\n                }\n            },\n            error: function (error) {\n                _this.updateLastResult(__assign(__assign({}, _this.lastResult), { error: error, errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false }));\n                iterateObserversSafely(_this.observers, 'error', _this.lastError = error);\n            },\n        };\n        _this.isTornDown = false;\n        _this.options = options;\n        _this.queryId = queryManager.generateQueryId();\n        var opDef = getOperationDefinition(options.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        _this.queryManager = queryManager;\n        _this.queryInfo = queryInfo;\n        return _this;\n    }\n    Object.defineProperty(ObservableQuery.prototype, \"variables\", {\n        get: function () {\n            return this.options.variables;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    ObservableQuery.prototype.result = function () {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            var observer = {\n                next: function (result) {\n                    resolve(result);\n                    _this.observers.delete(observer);\n                    if (!_this.observers.size) {\n                        _this.queryManager.removeQuery(_this.queryId);\n                    }\n                    setTimeout(function () {\n                        subscription.unsubscribe();\n                    }, 0);\n                },\n                error: reject,\n            };\n            var subscription = _this.subscribe(observer);\n        });\n    };\n    ObservableQuery.prototype.getCurrentResult = function () {\n        var lastResult = this.lastResult;\n        var networkStatus = this.queryInfo.networkStatus ||\n            (lastResult && lastResult.networkStatus) ||\n            NetworkStatus.ready;\n        var result = __assign(__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });\n        if (this.isTornDown) {\n            return result;\n        }\n        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? 'cache-first' : _a;\n        if (fetchPolicy === 'no-cache' ||\n            fetchPolicy === 'network-only') {\n            result.partial = false;\n        }\n        else if (!result.data ||\n            !this.queryManager.transform(this.options.query).hasForcedResolvers) {\n            var diff = this.queryInfo.getDiff();\n            result.partial = !diff.complete;\n            result.data = (diff.complete ||\n                this.options.returnPartialData) ? diff.result : void 0;\n            if (diff.complete &&\n                result.networkStatus === NetworkStatus.loading &&\n                (fetchPolicy === 'cache-first' ||\n                    fetchPolicy === 'cache-only')) {\n                result.networkStatus = NetworkStatus.ready;\n                result.loading = false;\n            }\n        }\n        this.updateLastResult(result);\n        return result;\n    };\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult) {\n        return !equal(this.lastResultSnapshot, newResult);\n    };\n    ObservableQuery.prototype.getLastResult = function () {\n        return this.lastResult;\n    };\n    ObservableQuery.prototype.getLastError = function () {\n        return this.lastError;\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.lastResult;\n        delete this.lastResultSnapshot;\n        delete this.lastError;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        this.queryManager.resetErrors(this.queryId);\n    };\n    ObservableQuery.prototype.refetch = function (variables) {\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === 'cache-only') {\n            return Promise.reject(process.env.NODE_ENV === \"production\" ? new InvariantError(12) : new InvariantError('cache-only fetchPolicy option should not be used together with query refetch.'));\n        }\n        var reobserveOptions = {\n            pollInterval: 0,\n        };\n        if (fetchPolicy !== 'no-cache' &&\n            fetchPolicy !== 'cache-and-network') {\n            reobserveOptions.fetchPolicy = 'network-only';\n            reobserveOptions.nextFetchPolicy = fetchPolicy;\n        }\n        if (variables && !equal(this.options.variables, variables)) {\n            reobserveOptions.variables = this.options.variables = __assign(__assign({}, this.options.variables), variables);\n        }\n        return this.newReobserver(false).reobserve(reobserveOptions, NetworkStatus.refetch);\n    };\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : __assign(__assign(__assign({}, this.options), fetchMoreOptions), { variables: __assign(__assign({}, this.options.variables), fetchMoreOptions.variables) }))), { fetchPolicy: \"no-cache\" });\n        var qid = this.queryManager.generateQueryId();\n        if (combinedOptions.notifyOnNetworkStatusChange) {\n            var currentResult = this.getCurrentResult();\n            this.queryInfo.networkStatus = NetworkStatus.fetchMore;\n            this.observer.next(__assign(__assign({}, currentResult), { loading: true, networkStatus: NetworkStatus.fetchMore }));\n        }\n        return this.queryManager.fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore).then(function (fetchMoreResult) {\n            var data = fetchMoreResult.data;\n            var updateQuery = fetchMoreOptions.updateQuery;\n            if (updateQuery) {\n                if (process.env.NODE_ENV !== \"production\" &&\n                    !warnedAboutUpdateQuery) {\n                    process.env.NODE_ENV === \"production\" || invariant.warn(\"The updateQuery callback for fetchMore is deprecated, and will be removed\\nin the next major version of Apollo Client.\\n\\nPlease convert updateQuery functions to field policies with appropriate\\nread and merge functions, or use/adapt a helper function (such as\\nconcatPagination, offsetLimitPagination, or relayStylePagination) from\\n@apollo/client/utilities.\\n\\nThe field policy system handles pagination more effectively than a\\nhand-written updateQuery function, and you only need to define the policy\\nonce, rather than every time you call fetchMore.\");\n                    warnedAboutUpdateQuery = true;\n                }\n                _this.updateQuery(function (previous) { return updateQuery(previous, {\n                    fetchMoreResult: data,\n                    variables: combinedOptions.variables,\n                }); });\n            }\n            else {\n                _this.queryManager.cache.writeQuery({\n                    query: combinedOptions.query,\n                    variables: combinedOptions.variables,\n                    data: data,\n                });\n            }\n            return fetchMoreResult;\n        }).finally(function () {\n            _this.queryManager.stopQuery(qid);\n            _this.reobserve();\n        });\n    };\n    ObservableQuery.prototype.subscribeToMore = function (options) {\n        var _this = this;\n        var subscription = this.queryManager\n            .startGraphQLSubscription({\n            query: options.document,\n            variables: options.variables,\n            context: options.context,\n        })\n            .subscribe({\n            next: function (subscriptionData) {\n                var updateQuery = options.updateQuery;\n                if (updateQuery) {\n                    _this.updateQuery(function (previous, _a) {\n                        var variables = _a.variables;\n                        return updateQuery(previous, {\n                            subscriptionData: subscriptionData,\n                            variables: variables,\n                        });\n                    });\n                }\n            },\n            error: function (err) {\n                if (options.onError) {\n                    options.onError(err);\n                    return;\n                }\n                process.env.NODE_ENV === \"production\" || invariant.error('Unhandled GraphQL subscription error', err);\n            },\n        });\n        this.subscriptions.add(subscription);\n        return function () {\n            if (_this.subscriptions.delete(subscription)) {\n                subscription.unsubscribe();\n            }\n        };\n    };\n    ObservableQuery.prototype.setOptions = function (newOptions) {\n        return this.reobserve(newOptions);\n    };\n    ObservableQuery.prototype.setVariables = function (variables) {\n        if (equal(this.variables, variables)) {\n            return this.observers.size\n                ? this.result()\n                : Promise.resolve();\n        }\n        this.options.variables = variables;\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? 'cache-first' : _a;\n        if (fetchPolicy !== 'cache-first' &&\n            fetchPolicy !== 'no-cache' &&\n            fetchPolicy !== 'network-only') {\n            fetchPolicy = 'cache-and-network';\n        }\n        return this.reobserve({\n            fetchPolicy: fetchPolicy,\n            variables: variables,\n        }, NetworkStatus.setVariables);\n    };\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var _a;\n        var queryManager = this.queryManager;\n        var result = queryManager.cache.diff({\n            query: this.options.query,\n            variables: this.variables,\n            previousResult: (_a = this.lastResult) === null || _a === void 0 ? void 0 : _a.data,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n        var newResult = mapFn(result, {\n            variables: this.variables,\n        });\n        if (newResult) {\n            queryManager.cache.writeQuery({\n                query: this.options.query,\n                data: newResult,\n                variables: this.variables,\n            });\n            queryManager.broadcastQueries();\n        }\n    };\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        this.getReobserver().updateOptions({ pollInterval: pollInterval });\n    };\n    ObservableQuery.prototype.stopPolling = function () {\n        if (this.reobserver) {\n            this.reobserver.updateOptions({ pollInterval: 0 });\n        }\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult) {\n        var previousResult = this.lastResult;\n        this.lastResult = newResult;\n        this.lastResultSnapshot = this.queryManager.assumeImmutableResults\n            ? newResult\n            : cloneDeep(newResult);\n        if (!isNonEmptyArray(newResult.errors)) {\n            delete this.lastError;\n        }\n        return previousResult;\n    };\n    ObservableQuery.prototype.onSubscribe = function (observer) {\n        var _this = this;\n        if (observer === this.observer) {\n            return function () { };\n        }\n        try {\n            var subObserver = observer._subscription._observer;\n            if (subObserver && !subObserver.error) {\n                subObserver.error = defaultSubscriptionObserverErrorCallback;\n            }\n        }\n        catch (_a) { }\n        var first = !this.observers.size;\n        this.observers.add(observer);\n        if (this.lastError) {\n            observer.error && observer.error(this.lastError);\n        }\n        else if (this.lastResult) {\n            observer.next && observer.next(this.lastResult);\n        }\n        if (first) {\n            this.reobserve().catch(function (_) {\n            });\n        }\n        return function () {\n            if (_this.observers.delete(observer) && !_this.observers.size) {\n                _this.tearDownQuery();\n            }\n        };\n    };\n    ObservableQuery.prototype.getReobserver = function () {\n        return this.reobserver || (this.reobserver = this.newReobserver(true));\n    };\n    ObservableQuery.prototype.newReobserver = function (shareOptions) {\n        var _this = this;\n        var _a = this, queryManager = _a.queryManager, queryId = _a.queryId;\n        queryManager.setObservableQuery(this);\n        return new Reobserver(this.observer, shareOptions ? this.options : __assign({}, this.options), function (currentOptions, newNetworkStatus) {\n            queryManager.setObservableQuery(_this);\n            return queryManager.fetchQueryObservable(queryId, currentOptions, newNetworkStatus);\n        }, !queryManager.ssrMode && (function () { return !isNetworkRequestInFlight(_this.queryInfo.networkStatus); }));\n    };\n    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {\n        this.isTornDown = false;\n        return this.getReobserver().reobserve(newOptions, newNetworkStatus);\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        var queryManager = this.queryManager;\n        if (this.reobserver) {\n            this.reobserver.stop();\n            delete this.reobserver;\n        }\n        this.isTornDown = true;\n        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n        this.subscriptions.clear();\n        queryManager.stopQuery(this.queryId);\n        this.observers.clear();\n    };\n    return ObservableQuery;\n}(Observable));\nexport { ObservableQuery };\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    process.env.NODE_ENV === \"production\" || invariant.error('Unhandled error', error.message, error.stack);\n}\n//# sourceMappingURL=ObservableQuery.js.map","export { ApolloClient, } from \"./ApolloClient.js\";\nexport { ObservableQuery, } from \"./ObservableQuery.js\";\nexport { NetworkStatus } from \"./networkStatus.js\";\nexport * from \"./types.js\";\nexport { isApolloError, ApolloError } from \"../errors/index.js\";\nexport { Cache, ApolloCache, InMemoryCache, MissingFieldError, defaultDataIdFromObject, makeVar, } from \"../cache/index.js\";\nexport * from \"../cache/inmemory/types.js\";\nexport * from \"../link/core/index.js\";\nexport * from \"../link/http/index.js\";\nexport { fromError, toPromise, fromPromise, throwServerError, } from \"../link/utils/index.js\";\nexport { Observable, isReference, makeReference, } from \"../utilities/index.js\";\nimport gql from 'graphql-tag';\nexport var resetCaches = gql.resetCaches, disableFragmentWarnings = gql.disableFragmentWarnings, enableExperimentalFragmentVariables = gql.enableExperimentalFragmentVariables, disableExperimentalFragmentVariables = gql.disableExperimentalFragmentVariables;\nexport { gql };\n//# sourceMappingURL=index.js.map","export var NetworkStatus;\n(function (NetworkStatus) {\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n})(NetworkStatus || (NetworkStatus = {}));\nexport function isNetworkRequestInFlight(networkStatus) {\n    return networkStatus ? networkStatus < 7 : false;\n}\n//# sourceMappingURL=networkStatus.js.map","import { __extends } from \"tslib\";\nimport { isNonEmptyArray } from \"../utilities/index.js\";\nexport function isApolloError(err) {\n    return err.hasOwnProperty('graphQLErrors');\n}\nvar generateErrorMessage = function (err) {\n    var message = '';\n    if (isNonEmptyArray(err.graphQLErrors)) {\n        err.graphQLErrors.forEach(function (graphQLError) {\n            var errorMessage = graphQLError\n                ? graphQLError.message\n                : 'Error message not found.';\n            message += errorMessage + \"\\n\";\n        });\n    }\n    if (err.networkError) {\n        message += err.networkError.message + \"\\n\";\n    }\n    message = message.replace(/\\n$/, '');\n    return message;\n};\nvar ApolloError = (function (_super) {\n    __extends(ApolloError, _super);\n    function ApolloError(_a) {\n        var graphQLErrors = _a.graphQLErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;\n        var _this = _super.call(this, errorMessage) || this;\n        _this.graphQLErrors = graphQLErrors || [];\n        _this.networkError = networkError || null;\n        _this.message = errorMessage || generateErrorMessage(_this);\n        _this.extraInfo = extraInfo;\n        _this.__proto__ = ApolloError.prototype;\n        return _this;\n    }\n    return ApolloError;\n}(Error));\nexport { ApolloError };\n//# sourceMappingURL=index.js.map","import { __rest } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nexport function setContext(setter) {\n    return new ApolloLink(function (operation, forward) {\n        var request = __rest(operation, []);\n        return new Observable(function (observer) {\n            var handle;\n            Promise.resolve(request)\n                .then(function (req) { return setter(req, operation.getContext()); })\n                .then(operation.setContext)\n                .then(function () {\n                handle = forward(operation).subscribe({\n                    next: observer.next.bind(observer),\n                    error: observer.error.bind(observer),\n                    complete: observer.complete.bind(observer),\n                });\n            })\n                .catch(observer.error.bind(observer));\n            return function () {\n                if (handle)\n                    handle.unsubscribe();\n            };\n        });\n    });\n}\n//# sourceMappingURL=index.js.map","import { __extends } from \"tslib\";\nimport { InvariantError, invariant } from 'ts-invariant';\nimport { Observable } from \"../../utilities/index.js\";\nimport { validateOperation, createOperation, transformOperation, } from \"../utils/index.js\";\nfunction passthrough(op, forward) {\n    return (forward ? forward(op) : Observable.of());\n}\nfunction toLink(handler) {\n    return typeof handler === 'function' ? new ApolloLink(handler) : handler;\n}\nfunction isTerminating(link) {\n    return link.request.length <= 1;\n}\nvar LinkError = (function (_super) {\n    __extends(LinkError, _super);\n    function LinkError(message, link) {\n        var _this = _super.call(this, message) || this;\n        _this.link = link;\n        return _this;\n    }\n    return LinkError;\n}(Error));\nvar ApolloLink = (function () {\n    function ApolloLink(request) {\n        if (request)\n            this.request = request;\n    }\n    ApolloLink.empty = function () {\n        return new ApolloLink(function () { return Observable.of(); });\n    };\n    ApolloLink.from = function (links) {\n        if (links.length === 0)\n            return ApolloLink.empty();\n        return links.map(toLink).reduce(function (x, y) { return x.concat(y); });\n    };\n    ApolloLink.split = function (test, left, right) {\n        var leftLink = toLink(left);\n        var rightLink = toLink(right || new ApolloLink(passthrough));\n        if (isTerminating(leftLink) && isTerminating(rightLink)) {\n            return new ApolloLink(function (operation) {\n                return test(operation)\n                    ? leftLink.request(operation) || Observable.of()\n                    : rightLink.request(operation) || Observable.of();\n            });\n        }\n        else {\n            return new ApolloLink(function (operation, forward) {\n                return test(operation)\n                    ? leftLink.request(operation, forward) || Observable.of()\n                    : rightLink.request(operation, forward) || Observable.of();\n            });\n        }\n    };\n    ApolloLink.execute = function (link, operation) {\n        return (link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of());\n    };\n    ApolloLink.concat = function (first, second) {\n        var firstLink = toLink(first);\n        if (isTerminating(firstLink)) {\n            process.env.NODE_ENV === \"production\" || invariant.warn(new LinkError(\"You are calling concat on a terminating link, which will have no effect\", firstLink));\n            return firstLink;\n        }\n        var nextLink = toLink(second);\n        if (isTerminating(nextLink)) {\n            return new ApolloLink(function (operation) {\n                return firstLink.request(operation, function (op) { return nextLink.request(op) || Observable.of(); }) || Observable.of();\n            });\n        }\n        else {\n            return new ApolloLink(function (operation, forward) {\n                return (firstLink.request(operation, function (op) {\n                    return nextLink.request(op, forward) || Observable.of();\n                }) || Observable.of());\n            });\n        }\n    };\n    ApolloLink.prototype.split = function (test, left, right) {\n        return this.concat(ApolloLink.split(test, left, right || new ApolloLink(passthrough)));\n    };\n    ApolloLink.prototype.concat = function (next) {\n        return ApolloLink.concat(this, next);\n    };\n    ApolloLink.prototype.request = function (operation, forward) {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(22) : new InvariantError('request is not implemented');\n    };\n    ApolloLink.prototype.onError = function (reason) {\n        throw reason;\n    };\n    ApolloLink.prototype.setOnError = function (fn) {\n        this.onError = fn;\n        return this;\n    };\n    return ApolloLink;\n}());\nexport { ApolloLink };\n//# sourceMappingURL=ApolloLink.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var concat = ApolloLink.concat;\n//# sourceMappingURL=concat.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var empty = ApolloLink.empty;\n//# sourceMappingURL=empty.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var execute = ApolloLink.execute;\n//# sourceMappingURL=execute.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var from = ApolloLink.from;\n//# sourceMappingURL=from.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var split = ApolloLink.split;\n//# sourceMappingURL=split.js.map","import { __extends } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nexport function onError(errorHandler) {\n    return new ApolloLink(function (operation, forward) {\n        return new Observable(function (observer) {\n            var sub;\n            var retriedSub;\n            var retriedResult;\n            try {\n                sub = forward(operation).subscribe({\n                    next: function (result) {\n                        if (result.errors) {\n                            retriedResult = errorHandler({\n                                graphQLErrors: result.errors,\n                                response: result,\n                                operation: operation,\n                                forward: forward,\n                            });\n                            if (retriedResult) {\n                                retriedSub = retriedResult.subscribe({\n                                    next: observer.next.bind(observer),\n                                    error: observer.error.bind(observer),\n                                    complete: observer.complete.bind(observer),\n                                });\n                                return;\n                            }\n                        }\n                        observer.next(result);\n                    },\n                    error: function (networkError) {\n                        retriedResult = errorHandler({\n                            operation: operation,\n                            networkError: networkError,\n                            graphQLErrors: networkError &&\n                                networkError.result &&\n                                networkError.result.errors,\n                            forward: forward,\n                        });\n                        if (retriedResult) {\n                            retriedSub = retriedResult.subscribe({\n                                next: observer.next.bind(observer),\n                                error: observer.error.bind(observer),\n                                complete: observer.complete.bind(observer),\n                            });\n                            return;\n                        }\n                        observer.error(networkError);\n                    },\n                    complete: function () {\n                        if (!retriedResult) {\n                            observer.complete.bind(observer)();\n                        }\n                    },\n                });\n            }\n            catch (e) {\n                errorHandler({ networkError: e, operation: operation, forward: forward });\n                observer.error(e);\n            }\n            return function () {\n                if (sub)\n                    sub.unsubscribe();\n                if (retriedSub)\n                    sub.unsubscribe();\n            };\n        });\n    });\n}\nvar ErrorLink = (function (_super) {\n    __extends(ErrorLink, _super);\n    function ErrorLink(errorHandler) {\n        var _this = _super.call(this) || this;\n        _this.link = onError(errorHandler);\n        return _this;\n    }\n    ErrorLink.prototype.request = function (operation, forward) {\n        return this.link.request(operation, forward);\n    };\n    return ErrorLink;\n}(ApolloLink));\nexport { ErrorLink };\n//# sourceMappingURL=index.js.map","import { throwServerError } from \"../utils/index.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function parseAndCheckHttpResponse(operations) {\n    return function (response) { return response\n        .text()\n        .then(function (bodyText) {\n        try {\n            return JSON.parse(bodyText);\n        }\n        catch (err) {\n            var parseError = err;\n            parseError.name = 'ServerParseError';\n            parseError.response = response;\n            parseError.statusCode = response.status;\n            parseError.bodyText = bodyText;\n            throw parseError;\n        }\n    })\n        .then(function (result) {\n        if (response.status >= 300) {\n            throwServerError(response, result, \"Response not successful: Received status code \" + response.status);\n        }\n        if (!Array.isArray(result) &&\n            !hasOwnProperty.call(result, 'data') &&\n            !hasOwnProperty.call(result, 'errors')) {\n            throwServerError(response, result, \"Server response was missing for query '\" + (Array.isArray(operations)\n                ? operations.map(function (op) { return op.operationName; })\n                : operations.operationName) + \"'.\");\n        }\n        return result;\n    }); };\n}\n//# sourceMappingURL=parseAndCheckHttpResponse.js.map","import { InvariantError } from 'ts-invariant';\nexport var serializeFetchParameter = function (p, label) {\n    var serialized;\n    try {\n        serialized = JSON.stringify(p);\n    }\n    catch (e) {\n        var parseError = process.env.NODE_ENV === \"production\" ? new InvariantError(24) : new InvariantError(\"Network request failed. \" + label + \" is not serializable: \" + e.message);\n        parseError.parseError = e;\n        throw parseError;\n    }\n    return serialized;\n};\n//# sourceMappingURL=serializeFetchParameter.js.map","import { __assign } from \"tslib\";\nimport { print } from 'graphql/language/printer';\nvar defaultHttpOptions = {\n    includeQuery: true,\n    includeExtensions: false,\n};\nvar defaultHeaders = {\n    accept: '*/*',\n    'content-type': 'application/json',\n};\nvar defaultOptions = {\n    method: 'POST',\n};\nexport var fallbackHttpConfig = {\n    http: defaultHttpOptions,\n    headers: defaultHeaders,\n    options: defaultOptions,\n};\nexport var selectHttpOptionsAndBody = function (operation, fallbackConfig) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    var options = __assign(__assign({}, fallbackConfig.options), { headers: fallbackConfig.headers, credentials: fallbackConfig.credentials });\n    var http = fallbackConfig.http || {};\n    configs.forEach(function (config) {\n        options = __assign(__assign(__assign({}, options), config.options), { headers: __assign(__assign({}, options.headers), config.headers) });\n        if (config.credentials)\n            options.credentials = config.credentials;\n        http = __assign(__assign({}, http), config.http);\n    });\n    var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;\n    var body = { operationName: operationName, variables: variables };\n    if (http.includeExtensions)\n        body.extensions = extensions;\n    if (http.includeQuery)\n        body.query = print(query);\n    return {\n        options: options,\n        body: body,\n    };\n};\n//# sourceMappingURL=selectHttpOptionsAndBody.js.map","import { __assign, __rest } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { serializeFetchParameter } from \"./serializeFetchParameter.js\";\nimport { selectURI } from \"./selectURI.js\";\nimport { parseAndCheckHttpResponse } from \"./parseAndCheckHttpResponse.js\";\nimport { checkFetcher } from \"./checkFetcher.js\";\nimport { selectHttpOptionsAndBody, fallbackHttpConfig } from \"./selectHttpOptionsAndBody.js\";\nimport { createSignalIfSupported } from \"./createSignalIfSupported.js\";\nimport { rewriteURIForGET } from \"./rewriteURIForGET.js\";\nimport { fromError } from \"../utils/index.js\";\nexport var createHttpLink = function (linkOptions) {\n    if (linkOptions === void 0) { linkOptions = {}; }\n    var _a = linkOptions.uri, uri = _a === void 0 ? '/graphql' : _a, fetcher = linkOptions.fetch, includeExtensions = linkOptions.includeExtensions, useGETForQueries = linkOptions.useGETForQueries, requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"includeExtensions\", \"useGETForQueries\"]);\n    checkFetcher(fetcher);\n    if (!fetcher) {\n        fetcher = fetch;\n    }\n    var linkConfig = {\n        http: { includeExtensions: includeExtensions },\n        options: requestOptions.fetchOptions,\n        credentials: requestOptions.credentials,\n        headers: requestOptions.headers,\n    };\n    return new ApolloLink(function (operation) {\n        var chosenURI = selectURI(operation, uri);\n        var context = operation.getContext();\n        var clientAwarenessHeaders = {};\n        if (context.clientAwareness) {\n            var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;\n            if (name_1) {\n                clientAwarenessHeaders['apollographql-client-name'] = name_1;\n            }\n            if (version) {\n                clientAwarenessHeaders['apollographql-client-version'] = version;\n            }\n        }\n        var contextHeaders = __assign(__assign({}, clientAwarenessHeaders), context.headers);\n        var contextConfig = {\n            http: context.http,\n            options: context.fetchOptions,\n            credentials: context.credentials,\n            headers: contextHeaders,\n        };\n        var _b = selectHttpOptionsAndBody(operation, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;\n        var controller;\n        if (!options.signal) {\n            var _c = createSignalIfSupported(), _controller = _c.controller, signal = _c.signal;\n            controller = _controller;\n            if (controller)\n                options.signal = signal;\n        }\n        var definitionIsMutation = function (d) {\n            return d.kind === 'OperationDefinition' && d.operation === 'mutation';\n        };\n        if (useGETForQueries &&\n            !operation.query.definitions.some(definitionIsMutation)) {\n            options.method = 'GET';\n        }\n        if (options.method === 'GET') {\n            var _d = rewriteURIForGET(chosenURI, body), newURI = _d.newURI, parseError = _d.parseError;\n            if (parseError) {\n                return fromError(parseError);\n            }\n            chosenURI = newURI;\n        }\n        else {\n            try {\n                options.body = serializeFetchParameter(body, 'Payload');\n            }\n            catch (parseError) {\n                return fromError(parseError);\n            }\n        }\n        return new Observable(function (observer) {\n            fetcher(chosenURI, options)\n                .then(function (response) {\n                operation.setContext({ response: response });\n                return response;\n            })\n                .then(parseAndCheckHttpResponse(operation))\n                .then(function (result) {\n                observer.next(result);\n                observer.complete();\n                return result;\n            })\n                .catch(function (err) {\n                if (err.name === 'AbortError')\n                    return;\n                if (err.result && err.result.errors && err.result.data) {\n                    observer.next(err.result);\n                }\n                observer.error(err);\n            });\n            return function () {\n                if (controller)\n                    controller.abort();\n            };\n        });\n    });\n};\n//# sourceMappingURL=createHttpLink.js.map","import { InvariantError } from 'ts-invariant';\nexport var checkFetcher = function (fetcher) {\n    if (!fetcher && typeof fetch === 'undefined') {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(23) : new InvariantError(\"\\n\\\"fetch\\\" has not been found globally and no fetcher has been configured. To fix this, install a fetch package (like https://www.npmjs.com/package/cross-fetch), instantiate the fetcher, and pass it into your HttpLink constructor. For example:\\n\\nimport fetch from 'cross-fetch';\\nimport { ApolloClient, HttpLink } from '@apollo/client';\\nconst client = new ApolloClient({\\n  link: new HttpLink({ uri: '/graphql', fetch })\\n});\\n    \");\n    }\n};\n//# sourceMappingURL=checkFetcher.js.map","export var selectURI = function (operation, fallbackURI) {\n    var context = operation.getContext();\n    var contextURI = context.uri;\n    if (contextURI) {\n        return contextURI;\n    }\n    else if (typeof fallbackURI === 'function') {\n        return fallbackURI(operation);\n    }\n    else {\n        return fallbackURI || '/graphql';\n    }\n};\n//# sourceMappingURL=selectURI.js.map","export var createSignalIfSupported = function () {\n    if (typeof AbortController === 'undefined')\n        return { controller: false, signal: false };\n    var controller = new AbortController();\n    var signal = controller.signal;\n    return { controller: controller, signal: signal };\n};\n//# sourceMappingURL=createSignalIfSupported.js.map","import { serializeFetchParameter } from \"./serializeFetchParameter.js\";\nexport function rewriteURIForGET(chosenURI, body) {\n    var queryParams = [];\n    var addQueryParam = function (key, value) {\n        queryParams.push(key + \"=\" + encodeURIComponent(value));\n    };\n    if ('query' in body) {\n        addQueryParam('query', body.query);\n    }\n    if (body.operationName) {\n        addQueryParam('operationName', body.operationName);\n    }\n    if (body.variables) {\n        var serializedVariables = void 0;\n        try {\n            serializedVariables = serializeFetchParameter(body.variables, 'Variables map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('variables', serializedVariables);\n    }\n    if (body.extensions) {\n        var serializedExtensions = void 0;\n        try {\n            serializedExtensions = serializeFetchParameter(body.extensions, 'Extensions map');\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam('extensions', serializedExtensions);\n    }\n    var fragment = '', preFragment = chosenURI;\n    var fragmentStart = chosenURI.indexOf('#');\n    if (fragmentStart !== -1) {\n        fragment = chosenURI.substr(fragmentStart);\n        preFragment = chosenURI.substr(0, fragmentStart);\n    }\n    var queryParamsPrefix = preFragment.indexOf('?') === -1 ? '?' : '&';\n    var newURI = preFragment + queryParamsPrefix + queryParams.join('&') + fragment;\n    return { newURI: newURI };\n}\n//# sourceMappingURL=rewriteURIForGET.js.map","import { __extends } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { createHttpLink } from \"./createHttpLink.js\";\nvar HttpLink = (function (_super) {\n    __extends(HttpLink, _super);\n    function HttpLink(options) {\n        if (options === void 0) { options = {}; }\n        var _this = _super.call(this, createHttpLink(options).request) || this;\n        _this.options = options;\n        return _this;\n    }\n    return HttpLink;\n}(ApolloLink));\nexport { HttpLink };\n//# sourceMappingURL=HttpLink.js.map","import { __awaiter, __extends, __generator } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { buildDelayFunction, } from \"./delayFunction.js\";\nimport { buildRetryFunction, } from \"./retryFunction.js\";\nvar RetryableOperation = (function () {\n    function RetryableOperation(operation, nextLink, delayFor, retryIf) {\n        var _this = this;\n        this.operation = operation;\n        this.nextLink = nextLink;\n        this.delayFor = delayFor;\n        this.retryIf = retryIf;\n        this.retryCount = 0;\n        this.values = [];\n        this.complete = false;\n        this.canceled = false;\n        this.observers = [];\n        this.currentSubscription = null;\n        this.onNext = function (value) {\n            _this.values.push(value);\n            for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {\n                var observer = _a[_i];\n                if (!observer)\n                    continue;\n                observer.next(value);\n            }\n        };\n        this.onComplete = function () {\n            _this.complete = true;\n            for (var _i = 0, _a = _this.observers; _i < _a.length; _i++) {\n                var observer = _a[_i];\n                if (!observer)\n                    continue;\n                observer.complete();\n            }\n        };\n        this.onError = function (error) { return __awaiter(_this, void 0, void 0, function () {\n            var shouldRetry, _i, _a, observer;\n            return __generator(this, function (_b) {\n                switch (_b.label) {\n                    case 0:\n                        this.retryCount += 1;\n                        return [4, this.retryIf(this.retryCount, this.operation, error)];\n                    case 1:\n                        shouldRetry = _b.sent();\n                        if (shouldRetry) {\n                            this.scheduleRetry(this.delayFor(this.retryCount, this.operation, error));\n                            return [2];\n                        }\n                        this.error = error;\n                        for (_i = 0, _a = this.observers; _i < _a.length; _i++) {\n                            observer = _a[_i];\n                            if (!observer)\n                                continue;\n                            observer.error(error);\n                        }\n                        return [2];\n                }\n            });\n        }); };\n    }\n    RetryableOperation.prototype.subscribe = function (observer) {\n        if (this.canceled) {\n            throw new Error(\"Subscribing to a retryable link that was canceled is not supported\");\n        }\n        this.observers.push(observer);\n        for (var _i = 0, _a = this.values; _i < _a.length; _i++) {\n            var value = _a[_i];\n            observer.next(value);\n        }\n        if (this.complete) {\n            observer.complete();\n        }\n        else if (this.error) {\n            observer.error(this.error);\n        }\n    };\n    RetryableOperation.prototype.unsubscribe = function (observer) {\n        var index = this.observers.indexOf(observer);\n        if (index < 0) {\n            throw new Error(\"RetryLink BUG! Attempting to unsubscribe unknown observer!\");\n        }\n        this.observers[index] = null;\n        if (this.observers.every(function (o) { return o === null; })) {\n            this.cancel();\n        }\n    };\n    RetryableOperation.prototype.start = function () {\n        if (this.currentSubscription)\n            return;\n        this.try();\n    };\n    RetryableOperation.prototype.cancel = function () {\n        if (this.currentSubscription) {\n            this.currentSubscription.unsubscribe();\n        }\n        clearTimeout(this.timerId);\n        this.timerId = undefined;\n        this.currentSubscription = null;\n        this.canceled = true;\n    };\n    RetryableOperation.prototype.try = function () {\n        this.currentSubscription = this.nextLink(this.operation).subscribe({\n            next: this.onNext,\n            error: this.onError,\n            complete: this.onComplete,\n        });\n    };\n    RetryableOperation.prototype.scheduleRetry = function (delay) {\n        var _this = this;\n        if (this.timerId) {\n            throw new Error(\"RetryLink BUG! Encountered overlapping retries\");\n        }\n        this.timerId = setTimeout(function () {\n            _this.timerId = undefined;\n            _this.try();\n        }, delay);\n    };\n    return RetryableOperation;\n}());\nvar RetryLink = (function (_super) {\n    __extends(RetryLink, _super);\n    function RetryLink(options) {\n        var _this = _super.call(this) || this;\n        var _a = options || {}, attempts = _a.attempts, delay = _a.delay;\n        _this.delayFor =\n            typeof delay === 'function' ? delay : buildDelayFunction(delay);\n        _this.retryIf =\n            typeof attempts === 'function' ? attempts : buildRetryFunction(attempts);\n        return _this;\n    }\n    RetryLink.prototype.request = function (operation, nextLink) {\n        var retryable = new RetryableOperation(operation, nextLink, this.delayFor, this.retryIf);\n        retryable.start();\n        return new Observable(function (observer) {\n            retryable.subscribe(observer);\n            return function () {\n                retryable.unsubscribe(observer);\n            };\n        });\n    };\n    return RetryLink;\n}(ApolloLink));\nexport { RetryLink };\n//# sourceMappingURL=retryLink.js.map","export function buildDelayFunction(delayOptions) {\n    var _a = delayOptions || {}, _b = _a.initial, initial = _b === void 0 ? 300 : _b, _c = _a.jitter, jitter = _c === void 0 ? true : _c, _d = _a.max, max = _d === void 0 ? Infinity : _d;\n    var baseDelay = jitter ? initial : initial / 2;\n    return function delayFunction(count) {\n        var delay = Math.min(max, baseDelay * Math.pow(2, count));\n        if (jitter) {\n            delay = Math.random() * delay;\n        }\n        return delay;\n    };\n}\n//# sourceMappingURL=delayFunction.js.map","export function buildRetryFunction(retryOptions) {\n    var _a = retryOptions || {}, retryIf = _a.retryIf, _b = _a.max, max = _b === void 0 ? 5 : _b;\n    return function retryFunction(count, operation, error) {\n        if (count >= max)\n            return false;\n        return retryIf ? retryIf(error, operation) : !!error;\n    };\n}\n//# sourceMappingURL=retryFunction.js.map","import { Observable } from \"../../utilities/index.js\";\nexport function fromError(errorValue) {\n    return new Observable(function (observer) {\n        observer.error(errorValue);\n    });\n}\n//# sourceMappingURL=fromError.js.map","export var throwServerError = function (response, result, message) {\n    var error = new Error(message);\n    error.name = 'ServerError';\n    error.response = response;\n    error.statusCode = response.status;\n    error.result = result;\n    throw error;\n};\n//# sourceMappingURL=throwServerError.js.map","import { InvariantError } from 'ts-invariant';\nexport function validateOperation(operation) {\n    var OPERATION_FIELDS = [\n        'query',\n        'operationName',\n        'variables',\n        'extensions',\n        'context',\n    ];\n    for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (OPERATION_FIELDS.indexOf(key) < 0) {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(25) : new InvariantError(\"illegal argument: \" + key);\n        }\n    }\n    return operation;\n}\n//# sourceMappingURL=validateOperation.js.map","import { __assign } from \"tslib\";\nexport function createOperation(starting, operation) {\n    var context = __assign({}, starting);\n    var setContext = function (next) {\n        if (typeof next === 'function') {\n            context = __assign(__assign({}, context), next(context));\n        }\n        else {\n            context = __assign(__assign({}, context), next);\n        }\n    };\n    var getContext = function () { return (__assign({}, context)); };\n    Object.defineProperty(operation, 'setContext', {\n        enumerable: false,\n        value: setContext,\n    });\n    Object.defineProperty(operation, 'getContext', {\n        enumerable: false,\n        value: getContext,\n    });\n    return operation;\n}\n//# sourceMappingURL=createOperation.js.map","import { getOperationName } from \"../../utilities/index.js\";\nexport function transformOperation(operation) {\n    var transformedOperation = {\n        variables: operation.variables || {},\n        extensions: operation.extensions || {},\n        operationName: operation.operationName,\n        query: operation.query,\n    };\n    if (!transformedOperation.operationName) {\n        transformedOperation.operationName =\n            typeof transformedOperation.query !== 'string'\n                ? getOperationName(transformedOperation.query) || undefined\n                : '';\n    }\n    return transformedOperation;\n}\n//# sourceMappingURL=transformOperation.js.map","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import React from 'react';\nvar contextSymbol = typeof Symbol === 'function' && Symbol.for ?\n    Symbol.for('__APOLLO_CONTEXT__') :\n    '__APOLLO_CONTEXT__';\nexport function resetApolloContext() {\n    Object.defineProperty(React, contextSymbol, {\n        value: React.createContext({}),\n        enumerable: false,\n        configurable: true,\n        writable: false,\n    });\n}\nexport function getApolloContext() {\n    if (!React[contextSymbol]) {\n        resetApolloContext();\n    }\n    return React[contextSymbol];\n}\n//# sourceMappingURL=ApolloContext.js.map","import React from 'react';\nimport { invariant } from 'ts-invariant';\nimport { getApolloContext } from \"./ApolloContext.js\";\nexport var ApolloConsumer = function (props) {\n    var ApolloContext = getApolloContext();\n    return React.createElement(ApolloContext.Consumer, null, function (context) {\n        process.env.NODE_ENV === \"production\" ? invariant(context && context.client, 26) : invariant(context && context.client, 'Could not find \"client\" in the context of ApolloConsumer. ' +\n            'Wrap the root component in an <ApolloProvider>.');\n        return props.children(context.client);\n    });\n};\n//# sourceMappingURL=ApolloConsumer.js.map","import React from 'react';\nimport { invariant } from 'ts-invariant';\nimport { getApolloContext } from \"./ApolloContext.js\";\nexport var ApolloProvider = function (_a) {\n    var client = _a.client, children = _a.children;\n    var ApolloContext = getApolloContext();\n    return React.createElement(ApolloContext.Consumer, null, function (context) {\n        if (context === void 0) { context = {}; }\n        if (client && context.client !== client) {\n            context = Object.assign({}, context, { client: client });\n        }\n        process.env.NODE_ENV === \"production\" ? invariant(context.client, 27) : invariant(context.client, 'ApolloProvider was not passed a client instance. Make ' +\n            'sure you pass in your client via the \"client\" prop.');\n        return (React.createElement(ApolloContext.Provider, { value: context }, children));\n    });\n};\n//# sourceMappingURL=ApolloProvider.js.map","import React from 'react';\nimport { invariant } from 'ts-invariant';\nimport { getApolloContext } from \"../context/index.js\";\nexport function useApolloClient() {\n    var client = React.useContext(getApolloContext()).client;\n    process.env.NODE_ENV === \"production\" ? invariant(client, 32) : invariant(client, 'No Apollo Client instance can be found. Please ensure that you ' +\n        'have called `ApolloProvider` higher up in your tree.');\n    return client;\n}\n//# sourceMappingURL=useApolloClient.js.map","import { invariant } from 'ts-invariant';\nexport var DocumentType;\n(function (DocumentType) {\n    DocumentType[DocumentType[\"Query\"] = 0] = \"Query\";\n    DocumentType[DocumentType[\"Mutation\"] = 1] = \"Mutation\";\n    DocumentType[DocumentType[\"Subscription\"] = 2] = \"Subscription\";\n})(DocumentType || (DocumentType = {}));\nvar cache = new Map();\nexport function operationName(type) {\n    var name;\n    switch (type) {\n        case DocumentType.Query:\n            name = 'Query';\n            break;\n        case DocumentType.Mutation:\n            name = 'Mutation';\n            break;\n        case DocumentType.Subscription:\n            name = 'Subscription';\n            break;\n    }\n    return name;\n}\nexport function parser(document) {\n    var cached = cache.get(document);\n    if (cached)\n        return cached;\n    var variables, type, name;\n    process.env.NODE_ENV === \"production\" ? invariant(!!document && !!document.kind, 33) : invariant(!!document && !!document.kind, \"Argument of \" + document + \" passed to parser was not a valid GraphQL \" +\n        \"DocumentNode. You may need to use 'graphql-tag' or another method \" +\n        \"to convert your operation into a document\");\n    var fragments = document.definitions.filter(function (x) { return x.kind === 'FragmentDefinition'; });\n    var queries = document.definitions.filter(function (x) {\n        return x.kind === 'OperationDefinition' && x.operation === 'query';\n    });\n    var mutations = document.definitions.filter(function (x) {\n        return x.kind === 'OperationDefinition' && x.operation === 'mutation';\n    });\n    var subscriptions = document.definitions.filter(function (x) {\n        return x.kind === 'OperationDefinition' && x.operation === 'subscription';\n    });\n    process.env.NODE_ENV === \"production\" ? invariant(!fragments.length ||\n        (queries.length || mutations.length || subscriptions.length), 34) : invariant(!fragments.length ||\n        (queries.length || mutations.length || subscriptions.length), \"Passing only a fragment to 'graphql' is not yet supported. \" +\n        \"You must include a query, subscription or mutation as well\");\n    process.env.NODE_ENV === \"production\" ? invariant(queries.length + mutations.length + subscriptions.length <= 1, 35) : invariant(queries.length + mutations.length + subscriptions.length <= 1, \"react-apollo only supports a query, subscription, or a mutation per HOC. \" +\n        (document + \" had \" + queries.length + \" queries, \" + subscriptions.length + \" \") +\n        (\"subscriptions and \" + mutations.length + \" mutations. \") +\n        \"You can use 'compose' to join multiple operation types to a component\");\n    type = queries.length ? DocumentType.Query : DocumentType.Mutation;\n    if (!queries.length && !mutations.length)\n        type = DocumentType.Subscription;\n    var definitions = queries.length\n        ? queries\n        : mutations.length\n            ? mutations\n            : subscriptions;\n    process.env.NODE_ENV === \"production\" ? invariant(definitions.length === 1, 36) : invariant(definitions.length === 1, \"react-apollo only supports one definition per HOC. \" + document + \" had \" +\n        (definitions.length + \" definitions. \") +\n        \"You can use 'compose' to join multiple operation types to a component\");\n    var definition = definitions[0];\n    variables = definition.variableDefinitions || [];\n    if (definition.name && definition.name.kind === 'Name') {\n        name = definition.name.value;\n    }\n    else {\n        name = 'data';\n    }\n    var payload = { name: name, type: type, variables: variables };\n    cache.set(document, payload);\n    return payload;\n}\n//# sourceMappingURL=index.js.map","import { equal } from '@wry/equality';\nimport { invariant } from 'ts-invariant';\nimport { parser, operationName } from \"../parser/index.js\";\nvar OperationData = (function () {\n    function OperationData(options, context) {\n        this.isMounted = false;\n        this.previousOptions = {};\n        this.context = {};\n        this.options = {};\n        this.options = options || {};\n        this.context = context || {};\n    }\n    OperationData.prototype.getOptions = function () {\n        return this.options;\n    };\n    OperationData.prototype.setOptions = function (newOptions, storePrevious) {\n        if (storePrevious === void 0) { storePrevious = false; }\n        if (storePrevious && !equal(this.options, newOptions)) {\n            this.previousOptions = this.options;\n        }\n        this.options = newOptions;\n    };\n    OperationData.prototype.unmount = function () {\n        this.isMounted = false;\n    };\n    OperationData.prototype.refreshClient = function () {\n        var client = (this.options && this.options.client) ||\n            (this.context && this.context.client);\n        process.env.NODE_ENV === \"production\" ? invariant(!!client, 28) : invariant(!!client, 'Could not find \"client\" in the context or passed in as an option. ' +\n            'Wrap the root component in an <ApolloProvider>, or pass an ' +\n            'ApolloClient instance in via options.');\n        var isNew = false;\n        if (client !== this.client) {\n            isNew = true;\n            this.client = client;\n            this.cleanup();\n        }\n        return {\n            client: this.client,\n            isNew: isNew\n        };\n    };\n    OperationData.prototype.verifyDocumentType = function (document, type) {\n        var operation = parser(document);\n        var requiredOperationName = operationName(type);\n        var usedOperationName = operationName(operation.type);\n        process.env.NODE_ENV === \"production\" ? invariant(operation.type === type, 29) : invariant(operation.type === type, \"Running a \" + requiredOperationName + \" requires a graphql \" +\n            (requiredOperationName + \", but a \" + usedOperationName + \" was used instead.\"));\n    };\n    return OperationData;\n}());\nexport { OperationData };\n//# sourceMappingURL=OperationData.js.map","import { __assign, __extends } from \"tslib\";\nimport { equal } from '@wry/equality';\nimport { OperationData } from \"./OperationData.js\";\nvar SubscriptionData = (function (_super) {\n    __extends(SubscriptionData, _super);\n    function SubscriptionData(_a) {\n        var options = _a.options, context = _a.context, setResult = _a.setResult;\n        var _this = _super.call(this, options, context) || this;\n        _this.currentObservable = {};\n        _this.setResult = setResult;\n        _this.initialize(options);\n        return _this;\n    }\n    SubscriptionData.prototype.execute = function (result) {\n        if (this.getOptions().skip === true) {\n            this.cleanup();\n            return {\n                loading: false,\n                error: undefined,\n                data: undefined,\n                variables: this.getOptions().variables\n            };\n        }\n        var currentResult = result;\n        if (this.refreshClient().isNew) {\n            currentResult = this.getLoadingResult();\n        }\n        var shouldResubscribe = this.getOptions().shouldResubscribe;\n        if (typeof shouldResubscribe === 'function') {\n            shouldResubscribe = !!shouldResubscribe(this.getOptions());\n        }\n        if (shouldResubscribe !== false &&\n            this.previousOptions &&\n            Object.keys(this.previousOptions).length > 0 &&\n            (this.previousOptions.subscription !== this.getOptions().subscription ||\n                !equal(this.previousOptions.variables, this.getOptions().variables) ||\n                this.previousOptions.skip !== this.getOptions().skip)) {\n            this.cleanup();\n            currentResult = this.getLoadingResult();\n        }\n        this.initialize(this.getOptions());\n        this.startSubscription();\n        this.previousOptions = this.getOptions();\n        return __assign(__assign({}, currentResult), { variables: this.getOptions().variables });\n    };\n    SubscriptionData.prototype.afterExecute = function () {\n        this.isMounted = true;\n    };\n    SubscriptionData.prototype.cleanup = function () {\n        this.endSubscription();\n        delete this.currentObservable.query;\n    };\n    SubscriptionData.prototype.initialize = function (options) {\n        if (this.currentObservable.query || this.getOptions().skip === true)\n            return;\n        this.currentObservable.query = this.refreshClient().client.subscribe({\n            query: options.subscription,\n            variables: options.variables,\n            fetchPolicy: options.fetchPolicy\n        });\n    };\n    SubscriptionData.prototype.startSubscription = function () {\n        if (this.currentObservable.subscription)\n            return;\n        this.currentObservable.subscription = this.currentObservable.query.subscribe({\n            next: this.updateCurrentData.bind(this),\n            error: this.updateError.bind(this),\n            complete: this.completeSubscription.bind(this)\n        });\n    };\n    SubscriptionData.prototype.getLoadingResult = function () {\n        return {\n            loading: true,\n            error: undefined,\n            data: undefined\n        };\n    };\n    SubscriptionData.prototype.updateResult = function (result) {\n        if (this.isMounted) {\n            this.setResult(result);\n        }\n    };\n    SubscriptionData.prototype.updateCurrentData = function (result) {\n        var onSubscriptionData = this.getOptions().onSubscriptionData;\n        this.updateResult({\n            data: result.data,\n            loading: false,\n            error: undefined\n        });\n        if (onSubscriptionData) {\n            onSubscriptionData({\n                client: this.refreshClient().client,\n                subscriptionData: result\n            });\n        }\n    };\n    SubscriptionData.prototype.updateError = function (error) {\n        this.updateResult({\n            error: error,\n            loading: false\n        });\n    };\n    SubscriptionData.prototype.completeSubscription = function () {\n        var onSubscriptionComplete = this.getOptions().onSubscriptionComplete;\n        if (onSubscriptionComplete)\n            onSubscriptionComplete();\n        this.endSubscription();\n    };\n    SubscriptionData.prototype.endSubscription = function () {\n        if (this.currentObservable.subscription) {\n            this.currentObservable.subscription.unsubscribe();\n            delete this.currentObservable.subscription;\n        }\n    };\n    return SubscriptionData;\n}(OperationData));\nexport { SubscriptionData };\n//# sourceMappingURL=SubscriptionData.js.map","import { __assign, __extends } from \"tslib\";\nimport { equal } from '@wry/equality';\nimport { DocumentType } from \"../parser/index.js\";\nimport { ApolloError } from \"../../errors/index.js\";\nimport { OperationData } from \"./OperationData.js\";\nimport { compact } from \"../../utilities/index.js\";\nvar MutationData = (function (_super) {\n    __extends(MutationData, _super);\n    function MutationData(_a) {\n        var options = _a.options, context = _a.context, result = _a.result, setResult = _a.setResult;\n        var _this = _super.call(this, options, context) || this;\n        _this.runMutation = function (mutationFunctionOptions) {\n            if (mutationFunctionOptions === void 0) { mutationFunctionOptions = {}; }\n            _this.onMutationStart();\n            var mutationId = _this.generateNewMutationId();\n            return _this.mutate(mutationFunctionOptions)\n                .then(function (response) {\n                _this.onMutationCompleted(response, mutationId);\n                return response;\n            })\n                .catch(function (error) {\n                _this.onMutationError(error, mutationId);\n                if (!_this.getOptions().onError)\n                    throw error;\n            });\n        };\n        _this.verifyDocumentType(options.mutation, DocumentType.Mutation);\n        _this.result = result;\n        _this.setResult = setResult;\n        _this.mostRecentMutationId = 0;\n        return _this;\n    }\n    MutationData.prototype.execute = function (result) {\n        this.isMounted = true;\n        this.verifyDocumentType(this.getOptions().mutation, DocumentType.Mutation);\n        return [\n            this.runMutation,\n            __assign(__assign({}, result), { client: this.refreshClient().client })\n        ];\n    };\n    MutationData.prototype.afterExecute = function () {\n        this.isMounted = true;\n        return this.unmount.bind(this);\n    };\n    MutationData.prototype.cleanup = function () {\n    };\n    MutationData.prototype.mutate = function (mutationFunctionOptions) {\n        return this.refreshClient().client.mutate(compact(this.getOptions(), mutationFunctionOptions));\n    };\n    MutationData.prototype.onMutationStart = function () {\n        if (!this.result.loading && !this.getOptions().ignoreResults) {\n            this.updateResult({\n                loading: true,\n                error: undefined,\n                data: undefined,\n                called: true\n            });\n        }\n    };\n    MutationData.prototype.onMutationCompleted = function (response, mutationId) {\n        var _a = this.getOptions(), onCompleted = _a.onCompleted, ignoreResults = _a.ignoreResults;\n        var data = response.data, errors = response.errors;\n        var error = errors && errors.length > 0\n            ? new ApolloError({ graphQLErrors: errors })\n            : undefined;\n        var callOncomplete = function () {\n            return onCompleted ? onCompleted(data) : null;\n        };\n        if (this.isMostRecentMutation(mutationId) && !ignoreResults) {\n            this.updateResult({\n                called: true,\n                loading: false,\n                data: data,\n                error: error\n            });\n        }\n        callOncomplete();\n    };\n    MutationData.prototype.onMutationError = function (error, mutationId) {\n        var onError = this.getOptions().onError;\n        if (this.isMostRecentMutation(mutationId)) {\n            this.updateResult({\n                loading: false,\n                error: error,\n                data: undefined,\n                called: true\n            });\n        }\n        if (onError) {\n            onError(error);\n        }\n    };\n    MutationData.prototype.generateNewMutationId = function () {\n        return ++this.mostRecentMutationId;\n    };\n    MutationData.prototype.isMostRecentMutation = function (mutationId) {\n        return this.mostRecentMutationId === mutationId;\n    };\n    MutationData.prototype.updateResult = function (result) {\n        if (this.isMounted &&\n            (!this.previousResult || !equal(this.previousResult, result))) {\n            this.setResult(result);\n            this.previousResult = result;\n        }\n    };\n    return MutationData;\n}(OperationData));\nexport { MutationData };\n//# sourceMappingURL=MutationData.js.map","import { __assign, __extends } from \"tslib\";\nimport { equal } from '@wry/equality';\nimport { ApolloError } from \"../../errors/index.js\";\nimport { NetworkStatus } from \"../../core/index.js\";\nimport { DocumentType } from \"../parser/index.js\";\nimport { OperationData } from \"./OperationData.js\";\nvar QueryData = (function (_super) {\n    __extends(QueryData, _super);\n    function QueryData(_a) {\n        var options = _a.options, context = _a.context, onNewData = _a.onNewData;\n        var _this = _super.call(this, options, context) || this;\n        _this.previousData = {};\n        _this.runLazy = false;\n        _this.runLazyQuery = function (options) {\n            _this.cleanup();\n            _this.runLazy = true;\n            _this.lazyOptions = options;\n            _this.onNewData();\n        };\n        _this.getQueryResult = function () {\n            var result = _this.observableQueryFields();\n            var options = _this.getOptions();\n            if (options.skip) {\n                result = __assign(__assign({}, result), { data: undefined, error: undefined, loading: false, called: true });\n            }\n            else if (_this.currentObservable) {\n                var currentResult = _this.currentObservable.getCurrentResult();\n                var data = currentResult.data, loading = currentResult.loading, partial = currentResult.partial, networkStatus = currentResult.networkStatus, errors = currentResult.errors;\n                var error = currentResult.error;\n                if (errors && errors.length > 0) {\n                    error = new ApolloError({ graphQLErrors: errors });\n                }\n                result = __assign(__assign({}, result), { data: data,\n                    loading: loading,\n                    networkStatus: networkStatus,\n                    error: error, called: true });\n                if (loading) {\n                }\n                else if (error) {\n                    Object.assign(result, {\n                        data: (_this.currentObservable.getLastResult() || {})\n                            .data\n                    });\n                }\n                else {\n                    var fetchPolicy = _this.currentObservable.options.fetchPolicy;\n                    var partialRefetch = options.partialRefetch;\n                    if (partialRefetch &&\n                        partial &&\n                        (!data || Object.keys(data).length === 0) &&\n                        fetchPolicy !== 'cache-only') {\n                        Object.assign(result, {\n                            loading: true,\n                            networkStatus: NetworkStatus.loading\n                        });\n                        result.refetch();\n                        return result;\n                    }\n                }\n            }\n            result.client = _this.client;\n            _this.setOptions(options, true);\n            _this.previousData.loading =\n                _this.previousData.result && _this.previousData.result.loading || false;\n            _this.previousData.result = result;\n            _this.currentObservable && _this.currentObservable.resetQueryStoreErrors();\n            return result;\n        };\n        _this.obsRefetch = function (variables) {\n            return _this.currentObservable.refetch(variables);\n        };\n        _this.obsFetchMore = function (fetchMoreOptions) { return _this.currentObservable.fetchMore(fetchMoreOptions); };\n        _this.obsUpdateQuery = function (mapFn) { return _this.currentObservable.updateQuery(mapFn); };\n        _this.obsStartPolling = function (pollInterval) {\n            var _a;\n            (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.startPolling(pollInterval);\n        };\n        _this.obsStopPolling = function () {\n            var _a;\n            (_a = _this.currentObservable) === null || _a === void 0 ? void 0 : _a.stopPolling();\n        };\n        _this.obsSubscribeToMore = function (options) { return _this.currentObservable.subscribeToMore(options); };\n        _this.onNewData = onNewData;\n        return _this;\n    }\n    QueryData.prototype.execute = function () {\n        this.refreshClient();\n        var _a = this.getOptions(), skip = _a.skip, query = _a.query;\n        if (skip || query !== this.previousData.query) {\n            this.removeQuerySubscription();\n            this.previousData.query = query;\n        }\n        this.updateObservableQuery();\n        if (this.isMounted)\n            this.startQuerySubscription();\n        return this.getExecuteSsrResult() || this.getExecuteResult();\n    };\n    QueryData.prototype.executeLazy = function () {\n        return !this.runLazy\n            ? [\n                this.runLazyQuery,\n                {\n                    loading: false,\n                    networkStatus: NetworkStatus.ready,\n                    called: false,\n                    data: undefined\n                }\n            ]\n            : [this.runLazyQuery, this.execute()];\n    };\n    QueryData.prototype.fetchData = function () {\n        var _this = this;\n        var options = this.getOptions();\n        if (options.skip || options.ssr === false)\n            return false;\n        return new Promise(function (resolve) { return _this.startQuerySubscription(resolve); });\n    };\n    QueryData.prototype.afterExecute = function (_a) {\n        var _b = (_a === void 0 ? {} : _a).lazy, lazy = _b === void 0 ? false : _b;\n        this.isMounted = true;\n        if (!lazy || this.runLazy) {\n            this.handleErrorOrCompleted();\n        }\n        this.previousOptions = this.getOptions();\n        return this.unmount.bind(this);\n    };\n    QueryData.prototype.cleanup = function () {\n        this.removeQuerySubscription();\n        delete this.currentObservable;\n        delete this.previousData.result;\n    };\n    QueryData.prototype.getOptions = function () {\n        var options = _super.prototype.getOptions.call(this);\n        if (this.lazyOptions) {\n            options.variables = __assign(__assign({}, options.variables), this.lazyOptions.variables);\n            options.context = __assign(__assign({}, options.context), this.lazyOptions.context);\n        }\n        if (this.runLazy) {\n            delete options.skip;\n        }\n        return options;\n    };\n    QueryData.prototype.ssrInitiated = function () {\n        return this.context && this.context.renderPromises;\n    };\n    QueryData.prototype.getExecuteResult = function () {\n        var result = this.getQueryResult();\n        this.startQuerySubscription();\n        return result;\n    };\n    ;\n    QueryData.prototype.getExecuteSsrResult = function () {\n        var ssrDisabled = this.getOptions().ssr === false;\n        var fetchDisabled = this.refreshClient().client.disableNetworkFetches;\n        var ssrLoading = __assign({ loading: true, networkStatus: NetworkStatus.loading, called: true, data: undefined, stale: false, client: this.client }, this.observableQueryFields());\n        if (ssrDisabled && (this.ssrInitiated() || fetchDisabled)) {\n            this.previousData.result = ssrLoading;\n            return ssrLoading;\n        }\n        var result;\n        if (this.ssrInitiated()) {\n            result =\n                this.context.renderPromises.addQueryPromise(this, this.getQueryResult) || ssrLoading;\n        }\n        return result;\n    };\n    QueryData.prototype.prepareObservableQueryOptions = function () {\n        var options = this.getOptions();\n        this.verifyDocumentType(options.query, DocumentType.Query);\n        var displayName = options.displayName || 'Query';\n        if (this.ssrInitiated() &&\n            (options.fetchPolicy === 'network-only' ||\n                options.fetchPolicy === 'cache-and-network')) {\n            options.fetchPolicy = 'cache-first';\n        }\n        return __assign(__assign({}, options), { displayName: displayName, context: options.context });\n    };\n    QueryData.prototype.initializeObservableQuery = function () {\n        if (this.ssrInitiated()) {\n            this.currentObservable = this.context.renderPromises.getSSRObservable(this.getOptions());\n        }\n        if (!this.currentObservable) {\n            var observableQueryOptions = this.prepareObservableQueryOptions();\n            this.previousData.observableQueryOptions = __assign(__assign({}, observableQueryOptions), { children: null });\n            this.currentObservable = this.refreshClient().client.watchQuery(__assign({}, observableQueryOptions));\n            if (this.ssrInitiated()) {\n                this.context.renderPromises.registerSSRObservable(this.currentObservable, observableQueryOptions);\n            }\n        }\n    };\n    QueryData.prototype.updateObservableQuery = function () {\n        if (this.getOptions().skip)\n            return;\n        if (!this.currentObservable) {\n            this.initializeObservableQuery();\n            return;\n        }\n        var newObservableQueryOptions = __assign(__assign({}, this.prepareObservableQueryOptions()), { children: null });\n        if (!equal(newObservableQueryOptions, this.previousData.observableQueryOptions)) {\n            this.previousData.observableQueryOptions = newObservableQueryOptions;\n            this.currentObservable\n                .setOptions(newObservableQueryOptions)\n                .catch(function () { });\n        }\n    };\n    QueryData.prototype.startQuerySubscription = function (onNewData) {\n        var _this = this;\n        if (onNewData === void 0) { onNewData = this.onNewData; }\n        if (this.currentSubscription || this.getOptions().skip)\n            return;\n        this.currentSubscription = this.currentObservable.subscribe({\n            next: function (_a) {\n                var loading = _a.loading, networkStatus = _a.networkStatus, data = _a.data;\n                var previousResult = _this.previousData.result;\n                if (previousResult &&\n                    previousResult.loading === loading &&\n                    previousResult.networkStatus === networkStatus &&\n                    equal(previousResult.data, data)) {\n                    return;\n                }\n                onNewData();\n            },\n            error: function (error) {\n                _this.resubscribeToQuery();\n                if (!error.hasOwnProperty('graphQLErrors'))\n                    throw error;\n                var previousResult = _this.previousData.result;\n                if ((previousResult && previousResult.loading) ||\n                    !equal(error, _this.previousData.error)) {\n                    _this.previousData.error = error;\n                    onNewData();\n                }\n            }\n        });\n    };\n    QueryData.prototype.resubscribeToQuery = function () {\n        this.removeQuerySubscription();\n        var currentObservable = this.currentObservable;\n        if (currentObservable) {\n            var lastError = currentObservable.getLastError();\n            var lastResult = currentObservable.getLastResult();\n            currentObservable.resetLastResults();\n            this.startQuerySubscription();\n            Object.assign(currentObservable, {\n                lastError: lastError,\n                lastResult: lastResult\n            });\n        }\n    };\n    QueryData.prototype.handleErrorOrCompleted = function () {\n        if (!this.currentObservable || !this.previousData.result)\n            return;\n        var _a = this.previousData.result, data = _a.data, loading = _a.loading, error = _a.error;\n        if (!loading) {\n            var _b = this.getOptions(), query = _b.query, variables = _b.variables, onCompleted = _b.onCompleted, onError = _b.onError, skip = _b.skip;\n            if (this.previousOptions &&\n                !this.previousData.loading &&\n                equal(this.previousOptions.query, query) &&\n                equal(this.previousOptions.variables, variables)) {\n                return;\n            }\n            if (onCompleted && !error && !skip) {\n                onCompleted(data);\n            }\n            else if (onError && error) {\n                onError(error);\n            }\n        }\n    };\n    QueryData.prototype.removeQuerySubscription = function () {\n        if (this.currentSubscription) {\n            this.currentSubscription.unsubscribe();\n            delete this.currentSubscription;\n        }\n    };\n    QueryData.prototype.observableQueryFields = function () {\n        var _a;\n        return {\n            variables: (_a = this.currentObservable) === null || _a === void 0 ? void 0 : _a.variables,\n            refetch: this.obsRefetch,\n            fetchMore: this.obsFetchMore,\n            updateQuery: this.obsUpdateQuery,\n            startPolling: this.obsStartPolling,\n            stopPolling: this.obsStopPolling,\n            subscribeToMore: this.obsSubscribeToMore\n        };\n    };\n    return QueryData;\n}(OperationData));\nexport { QueryData };\n//# sourceMappingURL=QueryData.js.map","import { __assign } from \"tslib\";\nimport { useContext, useEffect, useReducer, useRef } from 'react';\nimport { QueryData } from \"../../data/index.js\";\nimport { useDeepMemo } from \"./useDeepMemo.js\";\nimport { getApolloContext } from \"../../context/index.js\";\nexport function useBaseQuery(query, options, lazy) {\n    if (lazy === void 0) { lazy = false; }\n    var context = useContext(getApolloContext());\n    var _a = useReducer(function (x) { return x + 1; }, 0), tick = _a[0], forceUpdate = _a[1];\n    var updatedOptions = options ? __assign(__assign({}, options), { query: query }) : { query: query };\n    var queryDataRef = useRef();\n    var queryData = queryDataRef.current ||\n        new QueryData({\n            options: updatedOptions,\n            context: context,\n            onNewData: function () {\n                if (!queryData.ssrInitiated()) {\n                    Promise.resolve().then(forceUpdate);\n                }\n                else {\n                    forceUpdate();\n                }\n            }\n        });\n    queryData.setOptions(updatedOptions);\n    queryData.context = context;\n    if (queryData.ssrInitiated() && !queryDataRef.current) {\n        queryDataRef.current = queryData;\n    }\n    var memo = {\n        options: __assign(__assign({}, updatedOptions), { onError: undefined, onCompleted: undefined }),\n        context: context,\n        tick: tick\n    };\n    var result = useDeepMemo(function () { return (lazy ? queryData.executeLazy() : queryData.execute()); }, memo);\n    var queryResult = lazy\n        ? result[1]\n        : result;\n    useEffect(function () {\n        if (!queryDataRef.current) {\n            queryDataRef.current = queryData;\n        }\n        return function () { return queryData.cleanup(); };\n    }, []);\n    useEffect(function () { return queryData.afterExecute({ lazy: lazy }); }, [\n        queryResult.loading,\n        queryResult.networkStatus,\n        queryResult.error,\n        queryResult.data,\n    ]);\n    return result;\n}\n//# sourceMappingURL=useBaseQuery.js.map","import { useRef } from 'react';\nimport { equal } from '@wry/equality';\nexport function useDeepMemo(memoFn, key) {\n    var ref = useRef();\n    if (!ref.current || !equal(key, ref.current.key)) {\n        ref.current = { key: key, value: memoFn() };\n    }\n    return ref.current.value;\n}\n//# sourceMappingURL=useDeepMemo.js.map","import { useBaseQuery } from \"./utils/useBaseQuery.js\";\nexport function useLazyQuery(query, options) {\n    return useBaseQuery(query, options, true);\n}\n//# sourceMappingURL=useLazyQuery.js.map","import { __assign } from \"tslib\";\nimport { useContext, useState, useRef, useEffect } from 'react';\nimport { MutationData } from \"../data/index.js\";\nimport { getApolloContext } from \"../context/index.js\";\nexport function useMutation(mutation, options) {\n    var context = useContext(getApolloContext());\n    var _a = useState({ called: false, loading: false }), result = _a[0], setResult = _a[1];\n    var updatedOptions = options ? __assign(__assign({}, options), { mutation: mutation }) : { mutation: mutation };\n    var mutationDataRef = useRef();\n    function getMutationDataRef() {\n        if (!mutationDataRef.current) {\n            mutationDataRef.current = new MutationData({\n                options: updatedOptions,\n                context: context,\n                result: result,\n                setResult: setResult\n            });\n        }\n        return mutationDataRef.current;\n    }\n    var mutationData = getMutationDataRef();\n    mutationData.setOptions(updatedOptions);\n    mutationData.context = context;\n    useEffect(function () { return mutationData.afterExecute(); });\n    return mutationData.execute(result);\n}\n//# sourceMappingURL=useMutation.js.map","import { useBaseQuery } from \"./utils/useBaseQuery.js\";\nexport function useQuery(query, options) {\n    return useBaseQuery(query, options, false);\n}\n//# sourceMappingURL=useQuery.js.map","import { visit } from 'graphql/language/visitor';\nimport { invariant } from 'ts-invariant';\nexport function shouldInclude(_a, variables) {\n    var directives = _a.directives;\n    if (!directives || !directives.length) {\n        return true;\n    }\n    return getInclusionDirectives(directives).every(function (_a) {\n        var directive = _a.directive, ifArgument = _a.ifArgument;\n        var evaledValue = false;\n        if (ifArgument.value.kind === 'Variable') {\n            evaledValue = variables && variables[ifArgument.value.name.value];\n            process.env.NODE_ENV === \"production\" ? invariant(evaledValue !== void 0, 37) : invariant(evaledValue !== void 0, \"Invalid variable referenced in @\" + directive.name.value + \" directive.\");\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n    });\n}\nexport function getDirectiveNames(root) {\n    var names = [];\n    visit(root, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nexport function hasDirectives(names, root) {\n    return getDirectiveNames(root).some(function (name) { return names.indexOf(name) > -1; });\n}\nexport function hasClientExports(document) {\n    return (document &&\n        hasDirectives(['client'], document) &&\n        hasDirectives(['export'], document));\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === 'skip' || value === 'include';\n}\nexport function getInclusionDirectives(directives) {\n    var result = [];\n    if (directives && directives.length) {\n        directives.forEach(function (directive) {\n            if (!isInclusionDirective(directive))\n                return;\n            var directiveArguments = directive.arguments;\n            var directiveName = directive.name.value;\n            process.env.NODE_ENV === \"production\" ? invariant(directiveArguments && directiveArguments.length === 1, 38) : invariant(directiveArguments && directiveArguments.length === 1, \"Incorrect number of arguments for the @\" + directiveName + \" directive.\");\n            var ifArgument = directiveArguments[0];\n            process.env.NODE_ENV === \"production\" ? invariant(ifArgument.name && ifArgument.name.value === 'if', 39) : invariant(ifArgument.name && ifArgument.name.value === 'if', \"Invalid argument for the @\" + directiveName + \" directive.\");\n            var ifValue = ifArgument.value;\n            process.env.NODE_ENV === \"production\" ? invariant(ifValue &&\n                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), 40) : invariant(ifValue &&\n                (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'), \"Argument for the @\" + directiveName + \" directive must be a variable or a boolean value.\");\n            result.push({ directive: directive, ifArgument: ifArgument });\n        });\n    }\n    return result;\n}\n//# sourceMappingURL=directives.js.map","import { __assign, __spreadArrays } from \"tslib\";\nimport { invariant, InvariantError } from 'ts-invariant';\nexport function getFragmentQueryDocument(document, fragmentName) {\n    var actualFragmentName = fragmentName;\n    var fragments = [];\n    document.definitions.forEach(function (definition) {\n        if (definition.kind === 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(41) : new InvariantError(\"Found a \" + definition.operation + \" operation\" + (definition.name ? \" named '\" + definition.name.value + \"'\" : '') + \". \" +\n                'No operations are allowed when using a fragment as a query. Only fragments are allowed.');\n        }\n        if (definition.kind === 'FragmentDefinition') {\n            fragments.push(definition);\n        }\n    });\n    if (typeof actualFragmentName === 'undefined') {\n        process.env.NODE_ENV === \"production\" ? invariant(fragments.length === 1, 42) : invariant(fragments.length === 1, \"Found \" + fragments.length + \" fragments. `fragmentName` must be provided when there is not exactly 1 fragment.\");\n        actualFragmentName = fragments[0].name.value;\n    }\n    var query = __assign(__assign({}, document), { definitions: __spreadArrays([\n            {\n                kind: 'OperationDefinition',\n                operation: 'query',\n                selectionSet: {\n                    kind: 'SelectionSet',\n                    selections: [\n                        {\n                            kind: 'FragmentSpread',\n                            name: {\n                                kind: 'Name',\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions) });\n    return query;\n}\nexport function createFragmentMap(fragments) {\n    if (fragments === void 0) { fragments = []; }\n    var symTable = {};\n    fragments.forEach(function (fragment) {\n        symTable[fragment.name.value] = fragment;\n    });\n    return symTable;\n}\nexport function getFragmentFromSelection(selection, fragmentMap) {\n    switch (selection.kind) {\n        case 'InlineFragment':\n            return selection;\n        case 'FragmentSpread': {\n            var fragment = fragmentMap && fragmentMap[selection.name.value];\n            process.env.NODE_ENV === \"production\" ? invariant(fragment, 43) : invariant(fragment, \"No fragment named \" + selection.name.value + \".\");\n            return fragment;\n        }\n        default:\n            return null;\n    }\n}\n//# sourceMappingURL=fragments.js.map","import stringify from 'fast-json-stable-stringify';\nimport { InvariantError } from 'ts-invariant';\nimport { getFragmentFromSelection } from \"./fragments.js\";\nexport function makeReference(id) {\n    return { __ref: String(id) };\n}\nexport function isReference(obj) {\n    return Boolean(obj && typeof obj === 'object' && typeof obj.__ref === 'string');\n}\nfunction isStringValue(value) {\n    return value.kind === 'StringValue';\n}\nfunction isBooleanValue(value) {\n    return value.kind === 'BooleanValue';\n}\nfunction isIntValue(value) {\n    return value.kind === 'IntValue';\n}\nfunction isFloatValue(value) {\n    return value.kind === 'FloatValue';\n}\nfunction isVariable(value) {\n    return value.kind === 'Variable';\n}\nfunction isObjectValue(value) {\n    return value.kind === 'ObjectValue';\n}\nfunction isListValue(value) {\n    return value.kind === 'ListValue';\n}\nfunction isEnumValue(value) {\n    return value.kind === 'EnumValue';\n}\nfunction isNullValue(value) {\n    return value.kind === 'NullValue';\n}\nexport function valueToObjectRepresentation(argObj, name, value, variables) {\n    if (isIntValue(value) || isFloatValue(value)) {\n        argObj[name.value] = Number(value.value);\n    }\n    else if (isBooleanValue(value) || isStringValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isObjectValue(value)) {\n        var nestedArgObj_1 = {};\n        value.fields.map(function (obj) {\n            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n        });\n        argObj[name.value] = nestedArgObj_1;\n    }\n    else if (isVariable(value)) {\n        var variableValue = (variables || {})[value.name.value];\n        argObj[name.value] = variableValue;\n    }\n    else if (isListValue(value)) {\n        argObj[name.value] = value.values.map(function (listValue) {\n            var nestedArgArrayObj = {};\n            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n            return nestedArgArrayObj[name.value];\n        });\n    }\n    else if (isEnumValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isNullValue(value)) {\n        argObj[name.value] = null;\n    }\n    else {\n        throw process.env.NODE_ENV === \"production\" ? new InvariantError(52) : new InvariantError(\"The inline argument \\\"\" + name.value + \"\\\" of kind \\\"\" + value.kind + \"\\\"\" +\n            'is not supported. Use variables instead of inline arguments to ' +\n            'overcome this limitation.');\n    }\n}\nexport function storeKeyNameFromField(field, variables) {\n    var directivesObj = null;\n    if (field.directives) {\n        directivesObj = {};\n        field.directives.forEach(function (directive) {\n            directivesObj[directive.name.value] = {};\n            if (directive.arguments) {\n                directive.arguments.forEach(function (_a) {\n                    var name = _a.name, value = _a.value;\n                    return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n                });\n            }\n        });\n    }\n    var argObj = null;\n    if (field.arguments && field.arguments.length) {\n        argObj = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj, name, value, variables);\n        });\n    }\n    return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\nvar KNOWN_DIRECTIVES = [\n    'connection',\n    'include',\n    'skip',\n    'client',\n    'rest',\n    'export',\n];\nexport function getStoreKeyName(fieldName, args, directives) {\n    if (args &&\n        directives &&\n        directives['connection'] &&\n        directives['connection']['key']) {\n        if (directives['connection']['filter'] &&\n            directives['connection']['filter'].length > 0) {\n            var filterKeys = directives['connection']['filter']\n                ? directives['connection']['filter']\n                : [];\n            filterKeys.sort();\n            var filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = args[key];\n            });\n            return directives['connection']['key'] + \"(\" + JSON.stringify(filteredArgs_1) + \")\";\n        }\n        else {\n            return directives['connection']['key'];\n        }\n    }\n    var completeFieldName = fieldName;\n    if (args) {\n        var stringifiedArgs = stringify(args);\n        completeFieldName += \"(\" + stringifiedArgs + \")\";\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\" + key + \"(\" + JSON.stringify(directives[key]) + \")\";\n            }\n            else {\n                completeFieldName += \"@\" + key;\n            }\n        });\n    }\n    return completeFieldName;\n}\nexport function argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        var argObj_1 = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj_1, name, value, variables);\n        });\n        return argObj_1;\n    }\n    return null;\n}\nexport function resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nexport function getTypenameFromResult(result, selectionSet, fragmentMap) {\n    if (typeof result.__typename === 'string') {\n        return result.__typename;\n    }\n    for (var _i = 0, _a = selectionSet.selections; _i < _a.length; _i++) {\n        var selection = _a[_i];\n        if (isField(selection)) {\n            if (selection.name.value === '__typename') {\n                return result[resultKeyNameFromField(selection)];\n            }\n        }\n        else {\n            var typename = getTypenameFromResult(result, getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);\n            if (typeof typename === 'string') {\n                return typename;\n            }\n        }\n    }\n}\nexport function isField(selection) {\n    return selection.kind === 'Field';\n}\nexport function isInlineFragment(selection) {\n    return selection.kind === 'InlineFragment';\n}\n//# sourceMappingURL=storeUtils.js.map","import { invariant, InvariantError } from 'ts-invariant';\nimport { valueToObjectRepresentation } from \"./storeUtils.js\";\nexport function checkDocument(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc && doc.kind === 'Document', 44) : invariant(doc && doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== 'FragmentDefinition'; })\n        .map(function (definition) {\n        if (definition.kind !== 'OperationDefinition') {\n            throw process.env.NODE_ENV === \"production\" ? new InvariantError(45) : new InvariantError(\"Schema type definitions not allowed in queries. Found: \\\"\" + definition.kind + \"\\\"\");\n        }\n        return definition;\n    });\n    process.env.NODE_ENV === \"production\" ? invariant(operations.length <= 1, 46) : invariant(operations.length <= 1, \"Ambiguous GraphQL document: contains \" + operations.length + \" operations\");\n    return doc;\n}\nexport function getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) { return definition.kind === 'OperationDefinition'; })[0];\n}\nexport function getOperationName(doc) {\n    return (doc.definitions\n        .filter(function (definition) {\n        return definition.kind === 'OperationDefinition' && definition.name;\n    })\n        .map(function (x) { return x.name.value; })[0] || null);\n}\nexport function getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) { return definition.kind === 'FragmentDefinition'; });\n}\nexport function getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    process.env.NODE_ENV === \"production\" ? invariant(queryDef && queryDef.operation === 'query', 47) : invariant(queryDef && queryDef.operation === 'query', 'Must contain a query definition.');\n    return queryDef;\n}\nexport function getFragmentDefinition(doc) {\n    process.env.NODE_ENV === \"production\" ? invariant(doc.kind === 'Document', 48) : invariant(doc.kind === 'Document', \"Expecting a parsed GraphQL document. Perhaps you need to wrap the query string in a \\\"gql\\\" tag? http://docs.apollostack.com/apollo-client/core.html#gql\");\n    process.env.NODE_ENV === \"production\" ? invariant(doc.definitions.length <= 1, 49) : invariant(doc.definitions.length <= 1, 'Fragment must have exactly one definition.');\n    var fragmentDef = doc.definitions[0];\n    process.env.NODE_ENV === \"production\" ? invariant(fragmentDef.kind === 'FragmentDefinition', 50) : invariant(fragmentDef.kind === 'FragmentDefinition', 'Must be a fragment definition.');\n    return fragmentDef;\n}\nexport function getMainDefinition(queryDoc) {\n    checkDocument(queryDoc);\n    var fragmentDefinition;\n    for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n        var definition = _a[_i];\n        if (definition.kind === 'OperationDefinition') {\n            var operation = definition.operation;\n            if (operation === 'query' ||\n                operation === 'mutation' ||\n                operation === 'subscription') {\n                return definition;\n            }\n        }\n        if (definition.kind === 'FragmentDefinition' && !fragmentDefinition) {\n            fragmentDefinition = definition;\n        }\n    }\n    if (fragmentDefinition) {\n        return fragmentDefinition;\n    }\n    throw process.env.NODE_ENV === \"production\" ? new InvariantError(51) : new InvariantError('Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.');\n}\nexport function getDefaultValues(definition) {\n    var defaultValues = Object.create(null);\n    var defs = definition && definition.variableDefinitions;\n    if (defs && defs.length) {\n        defs.forEach(function (def) {\n            if (def.defaultValue) {\n                valueToObjectRepresentation(defaultValues, def.variable.name, def.defaultValue);\n            }\n        });\n    }\n    return defaultValues;\n}\n//# sourceMappingURL=getFromAST.js.map","export function filterInPlace(array, test, context) {\n    var target = 0;\n    array.forEach(function (elem, i) {\n        if (test.call(this, elem, i, array)) {\n            array[target++] = elem;\n        }\n    }, context);\n    array.length = target;\n    return array;\n}\n//# sourceMappingURL=filterInPlace.js.map","import { __assign, __spreadArrays } from \"tslib\";\nimport { visit } from 'graphql/language/visitor';\nimport { invariant } from 'ts-invariant';\nimport { checkDocument, getOperationDefinition, getFragmentDefinition, getFragmentDefinitions, getMainDefinition, } from \"./getFromAST.js\";\nimport { filterInPlace } from \"../common/filterInPlace.js\";\nimport { isField, isInlineFragment } from \"./storeUtils.js\";\nimport { createFragmentMap, } from \"./fragments.js\";\nvar TYPENAME_FIELD = {\n    kind: 'Field',\n    name: {\n        kind: 'Name',\n        value: '__typename',\n    },\n};\nfunction isEmpty(op, fragments) {\n    return op.selectionSet.selections.every(function (selection) {\n        return selection.kind === 'FragmentSpread' &&\n            isEmpty(fragments[selection.name.value], fragments);\n    });\n}\nfunction nullIfDocIsEmpty(doc) {\n    return isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))\n        ? null\n        : doc;\n}\nfunction getDirectiveMatcher(directives) {\n    return function directiveMatcher(directive) {\n        return directives.some(function (dir) {\n            return (dir.name && dir.name === directive.name.value) ||\n                (dir.test && dir.test(directive));\n        });\n    };\n}\nexport function removeDirectivesFromDocument(directives, doc) {\n    var variablesInUse = Object.create(null);\n    var variablesToRemove = [];\n    var fragmentSpreadsInUse = Object.create(null);\n    var fragmentSpreadsToRemove = [];\n    var modifiedDoc = nullIfDocIsEmpty(visit(doc, {\n        Variable: {\n            enter: function (node, _key, parent) {\n                if (parent.kind !== 'VariableDefinition') {\n                    variablesInUse[node.name.value] = true;\n                }\n            },\n        },\n        Field: {\n            enter: function (node) {\n                if (directives && node.directives) {\n                    var shouldRemoveField = directives.some(function (directive) { return directive.remove; });\n                    if (shouldRemoveField &&\n                        node.directives &&\n                        node.directives.some(getDirectiveMatcher(directives))) {\n                        if (node.arguments) {\n                            node.arguments.forEach(function (arg) {\n                                if (arg.value.kind === 'Variable') {\n                                    variablesToRemove.push({\n                                        name: arg.value.name.value,\n                                    });\n                                }\n                            });\n                        }\n                        if (node.selectionSet) {\n                            getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(function (frag) {\n                                fragmentSpreadsToRemove.push({\n                                    name: frag.name.value,\n                                });\n                            });\n                        }\n                        return null;\n                    }\n                }\n            },\n        },\n        FragmentSpread: {\n            enter: function (node) {\n                fragmentSpreadsInUse[node.name.value] = true;\n            },\n        },\n        Directive: {\n            enter: function (node) {\n                if (getDirectiveMatcher(directives)(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n    if (modifiedDoc &&\n        filterInPlace(variablesToRemove, function (v) { return !!v.name && !variablesInUse[v.name]; }).length) {\n        modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n    }\n    if (modifiedDoc &&\n        filterInPlace(fragmentSpreadsToRemove, function (fs) { return !!fs.name && !fragmentSpreadsInUse[fs.name]; })\n            .length) {\n        modifiedDoc = removeFragmentSpreadFromDocument(fragmentSpreadsToRemove, modifiedDoc);\n    }\n    return modifiedDoc;\n}\nexport function addTypenameToDocument(doc) {\n    return visit(checkDocument(doc), {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                if (parent &&\n                    parent.kind === 'OperationDefinition') {\n                    return;\n                }\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                var skip = selections.some(function (selection) {\n                    return (isField(selection) &&\n                        (selection.name.value === '__typename' ||\n                            selection.name.value.lastIndexOf('__', 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                var field = parent;\n                if (isField(field) &&\n                    field.directives &&\n                    field.directives.some(function (d) { return d.name.value === 'export'; })) {\n                    return;\n                }\n                return __assign(__assign({}, node), { selections: __spreadArrays(selections, [TYPENAME_FIELD]) });\n            },\n        },\n    });\n}\naddTypenameToDocument.added = function (field) {\n    return field === TYPENAME_FIELD;\n};\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === 'connection';\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === 'key'; })) {\n                process.env.NODE_ENV === \"production\" || invariant.warn('Removing an @connection directive even though it does not have a key. ' +\n                    'You may want to use the key parameter to specify a store key.');\n            }\n        }\n        return willRemove;\n    },\n};\nexport function removeConnectionDirectiveFromDocument(doc) {\n    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\nfunction hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    return (!!selectionSet &&\n        selectionSet.selections &&\n        selectionSet.selections.some(function (selection) {\n            return hasDirectivesInSelection(directives, selection, nestedCheck);\n        }));\n}\nfunction hasDirectivesInSelection(directives, selection, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    if (!isField(selection)) {\n        return true;\n    }\n    if (!selection.directives) {\n        return false;\n    }\n    return (selection.directives.some(getDirectiveMatcher(directives)) ||\n        (nestedCheck &&\n            hasDirectivesInSelectionSet(directives, selection.selectionSet, nestedCheck)));\n}\nfunction getArgumentMatcher(config) {\n    return function argumentMatcher(argument) {\n        return config.some(function (aConfig) {\n            return argument.value &&\n                argument.value.kind === 'Variable' &&\n                argument.value.name &&\n                (aConfig.name === argument.value.name.value ||\n                    (aConfig.test && aConfig.test(argument)));\n        });\n    };\n}\nexport function removeArgumentsFromDocument(config, doc) {\n    var argMatcher = getArgumentMatcher(config);\n    return nullIfDocIsEmpty(visit(doc, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions ? node.variableDefinitions.filter(function (varDef) {\n                        return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });\n                    }) : [] });\n            },\n        },\n        Field: {\n            enter: function (node) {\n                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });\n                if (shouldRemoveField) {\n                    var argMatchCount_1 = 0;\n                    if (node.arguments) {\n                        node.arguments.forEach(function (arg) {\n                            if (argMatcher(arg)) {\n                                argMatchCount_1 += 1;\n                            }\n                        });\n                    }\n                    if (argMatchCount_1 === 1) {\n                        return null;\n                    }\n                }\n            },\n        },\n        Argument: {\n            enter: function (node) {\n                if (argMatcher(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n}\nexport function removeFragmentSpreadFromDocument(config, doc) {\n    function enter(node) {\n        if (config.some(function (def) { return def.name === node.name.value; })) {\n            return null;\n        }\n    }\n    return nullIfDocIsEmpty(visit(doc, {\n        FragmentSpread: { enter: enter },\n        FragmentDefinition: { enter: enter },\n    }));\n}\nfunction getAllFragmentSpreadsFromSelectionSet(selectionSet) {\n    var allFragments = [];\n    selectionSet.selections.forEach(function (selection) {\n        if ((isField(selection) || isInlineFragment(selection)) &&\n            selection.selectionSet) {\n            getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(function (frag) { return allFragments.push(frag); });\n        }\n        else if (selection.kind === 'FragmentSpread') {\n            allFragments.push(selection);\n        }\n    });\n    return allFragments;\n}\nexport function buildQueryFromSelectionSet(document) {\n    var definition = getMainDefinition(document);\n    var definitionOperation = definition.operation;\n    if (definitionOperation === 'query') {\n        return document;\n    }\n    var modifiedDoc = visit(document, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { operation: 'query' });\n            },\n        },\n    });\n    return modifiedDoc;\n}\nexport function removeClientSetsFromDocument(document) {\n    checkDocument(document);\n    var modifiedDoc = removeDirectivesFromDocument([\n        {\n            test: function (directive) { return directive.name.value === 'client'; },\n            remove: true,\n        },\n    ], document);\n    if (modifiedDoc) {\n        modifiedDoc = visit(modifiedDoc, {\n            FragmentDefinition: {\n                enter: function (node) {\n                    if (node.selectionSet) {\n                        var isTypenameOnly = node.selectionSet.selections.every(function (selection) {\n                            return isField(selection) && selection.name.value === '__typename';\n                        });\n                        if (isTypenameOnly) {\n                            return null;\n                        }\n                    }\n                },\n            },\n        });\n    }\n    return modifiedDoc;\n}\n//# sourceMappingURL=transform.js.map","import Observable from 'zen-observable';\nimport 'symbol-observable';\nObservable.prototype['@@observable'] = function () { return this; };\nexport { Observable };\n//# sourceMappingURL=Observable.js.map","import { __assign, __spreadArrays } from \"tslib\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\nexport function mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var merger = new DeepMerger();\n        for (var i = 1; i < count; ++i) {\n            target = merger.merge(target, sources[i]);\n        }\n    }\n    return target;\n}\nfunction isObject(obj) {\n    return obj !== null && typeof obj === 'object';\n}\nvar defaultReconciler = function (target, source, property) {\n    return this.merge(target[property], source[property]);\n};\nvar DeepMerger = (function () {\n    function DeepMerger(reconciler) {\n        if (reconciler === void 0) { reconciler = defaultReconciler; }\n        this.reconciler = reconciler;\n        this.isObject = isObject;\n        this.pastCopies = new Set();\n    }\n    DeepMerger.prototype.merge = function (target, source) {\n        var _this = this;\n        var context = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            context[_i - 2] = arguments[_i];\n        }\n        if (isObject(source) && isObject(target)) {\n            Object.keys(source).forEach(function (sourceKey) {\n                if (hasOwnProperty.call(target, sourceKey)) {\n                    var targetValue = target[sourceKey];\n                    if (source[sourceKey] !== targetValue) {\n                        var result = _this.reconciler.apply(_this, __spreadArrays([target, source, sourceKey], context));\n                        if (result !== targetValue) {\n                            target = _this.shallowCopyForMerge(target);\n                            target[sourceKey] = result;\n                        }\n                    }\n                }\n                else {\n                    target = _this.shallowCopyForMerge(target);\n                    target[sourceKey] = source[sourceKey];\n                }\n            });\n            return target;\n        }\n        return source;\n    };\n    DeepMerger.prototype.shallowCopyForMerge = function (value) {\n        if (isObject(value) && !this.pastCopies.has(value)) {\n            if (Array.isArray(value)) {\n                value = value.slice(0);\n            }\n            else {\n                value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n            }\n            this.pastCopies.add(value);\n        }\n        return value;\n    };\n    return DeepMerger;\n}());\nexport { DeepMerger };\n//# sourceMappingURL=mergeDeep.js.map","var toString = Object.prototype.toString;\nexport function cloneDeep(value) {\n    return cloneDeepHelper(value);\n}\nfunction cloneDeepHelper(val, seen) {\n    switch (toString.call(val)) {\n        case \"[object Array]\": {\n            seen = seen || new Map;\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_1 = val.slice(0);\n            seen.set(val, copy_1);\n            copy_1.forEach(function (child, i) {\n                copy_1[i] = cloneDeepHelper(child, seen);\n            });\n            return copy_1;\n        }\n        case \"[object Object]\": {\n            seen = seen || new Map;\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_2 = Object.create(Object.getPrototypeOf(val));\n            seen.set(val, copy_2);\n            Object.keys(val).forEach(function (key) {\n                copy_2[key] = cloneDeepHelper(val[key], seen);\n            });\n            return copy_2;\n        }\n        default:\n            return val;\n    }\n}\n//# sourceMappingURL=cloneDeep.js.map","import { isDevelopment, isTest } from \"./environment.js\";\nfunction isObject(value) {\n    return value !== null && typeof value === \"object\";\n}\nfunction deepFreeze(value) {\n    var workSet = new Set([value]);\n    workSet.forEach(function (obj) {\n        if (isObject(obj)) {\n            if (!Object.isFrozen(obj))\n                Object.freeze(obj);\n            Object.getOwnPropertyNames(obj).forEach(function (name) {\n                if (isObject(obj[name]))\n                    workSet.add(obj[name]);\n            });\n        }\n    });\n    return value;\n}\nexport function maybeDeepFreeze(obj) {\n    if (process.env.NODE_ENV !== \"production\" && (isDevelopment() || isTest())) {\n        deepFreeze(obj);\n    }\n    return obj;\n}\n//# sourceMappingURL=maybeDeepFreeze.js.map","export function iterateObserversSafely(observers, method, argument) {\n    var observersWithMethod = [];\n    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });\n    observersWithMethod.forEach(function (obs) { return obs[method](argument); });\n}\n//# sourceMappingURL=iteration.js.map","import { Observable } from \"./Observable.js\";\nexport function asyncMap(observable, mapFn, catchFn) {\n    return new Observable(function (observer) {\n        var next = observer.next, error = observer.error, complete = observer.complete;\n        var activeCallbackCount = 0;\n        var completed = false;\n        function makeCallback(examiner, delegate) {\n            if (examiner) {\n                return function (arg) {\n                    ++activeCallbackCount;\n                    new Promise(function (resolve) { return resolve(examiner(arg)); }).then(function (result) {\n                        --activeCallbackCount;\n                        next && next.call(observer, result);\n                        if (completed) {\n                            handler.complete();\n                        }\n                    }, function (e) {\n                        --activeCallbackCount;\n                        error && error.call(observer, e);\n                    });\n                };\n            }\n            else {\n                return function (arg) { return delegate && delegate.call(observer, arg); };\n            }\n        }\n        var handler = {\n            next: makeCallback(mapFn, next),\n            error: makeCallback(catchFn, error),\n            complete: function () {\n                completed = true;\n                if (!activeCallbackCount) {\n                    complete && complete.call(observer);\n                }\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n//# sourceMappingURL=asyncMap.js.map","import { __extends } from \"tslib\";\nimport { Observable } from \"./Observable.js\";\nimport { iterateObserversSafely } from \"./iteration.js\";\nfunction isPromiseLike(value) {\n    return value && typeof value.then === \"function\";\n}\nvar Concast = (function (_super) {\n    __extends(Concast, _super);\n    function Concast(sources) {\n        var _this = _super.call(this, function (observer) {\n            _this.addObserver(observer);\n            return function () { return _this.removeObserver(observer); };\n        }) || this;\n        _this.observers = new Set();\n        _this.promise = new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        });\n        _this.handlers = {\n            next: function (result) {\n                if (_this.sub !== null) {\n                    _this.latest = [\"next\", result];\n                    iterateObserversSafely(_this.observers, \"next\", result);\n                }\n            },\n            error: function (error) {\n                if (_this.sub !== null) {\n                    if (_this.sub)\n                        _this.sub.unsubscribe();\n                    _this.sub = null;\n                    _this.latest = [\"error\", error];\n                    _this.reject(error);\n                    iterateObserversSafely(_this.observers, \"error\", error);\n                }\n            },\n            complete: function () {\n                if (_this.sub !== null) {\n                    var value = _this.sources.shift();\n                    if (!value) {\n                        _this.sub = null;\n                        if (_this.latest &&\n                            _this.latest[0] === \"next\") {\n                            _this.resolve(_this.latest[1]);\n                        }\n                        else {\n                            _this.resolve();\n                        }\n                        iterateObserversSafely(_this.observers, \"complete\");\n                    }\n                    else if (isPromiseLike(value)) {\n                        value.then(function (obs) { return _this.sub = obs.subscribe(_this.handlers); });\n                    }\n                    else {\n                        _this.sub = value.subscribe(_this.handlers);\n                    }\n                }\n            },\n        };\n        _this.cancel = function (reason) {\n            _this.reject(reason);\n            _this.sources = [];\n            _this.handlers.complete();\n        };\n        _this.promise.catch(function (_) { });\n        if (isPromiseLike(sources)) {\n            sources.then(function (iterable) { return _this.start(iterable); }, _this.handlers.error);\n        }\n        else {\n            _this.start(sources);\n        }\n        return _this;\n    }\n    Concast.prototype.start = function (sources) {\n        if (this.sub !== void 0)\n            return;\n        this.sources = Array.from(sources);\n        this.handlers.complete();\n    };\n    Concast.prototype.addObserver = function (observer) {\n        if (!this.observers.has(observer)) {\n            if (this.latest) {\n                var nextOrError = this.latest[0];\n                var method = observer[nextOrError];\n                if (method) {\n                    method.call(observer, this.latest[1]);\n                }\n                if (this.sub === null &&\n                    nextOrError === \"next\" &&\n                    observer.complete) {\n                    observer.complete();\n                }\n            }\n            this.observers.add(observer);\n        }\n    };\n    Concast.prototype.removeObserver = function (observer, quietly) {\n        if (this.observers.delete(observer) &&\n            this.observers.size < 1) {\n            if (quietly)\n                return;\n            if (this.sub) {\n                this.sub.unsubscribe();\n                this.reject(new Error(\"Observable cancelled prematurely\"));\n            }\n            this.sub = null;\n        }\n    };\n    Concast.prototype.cleanup = function (callback) {\n        var _this = this;\n        var called = false;\n        var once = function () {\n            if (!called) {\n                called = true;\n                _this.observers.delete(observer);\n                callback();\n            }\n        };\n        var observer = {\n            next: once,\n            error: once,\n            complete: once,\n        };\n        this.addObserver(observer);\n    };\n    return Concast;\n}(Observable));\nexport { Concast };\nif (typeof Symbol === \"function\" && Symbol.species) {\n    Object.defineProperty(Concast, Symbol.species, {\n        value: Observable,\n    });\n}\n//# sourceMappingURL=Concast.js.map","export function isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n//# sourceMappingURL=arrays.js.map","export function graphQLResultHasError(result) {\n    return (result.errors && result.errors.length > 0) || false;\n}\n//# sourceMappingURL=errorHandling.js.map","export var canUseWeakMap = typeof WeakMap === 'function' && !(typeof navigator === 'object' &&\n    navigator.product === 'ReactNative');\n//# sourceMappingURL=canUse.js.map","export function compact() {\n    var objects = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        objects[_i] = arguments[_i];\n    }\n    var result = Object.create(null);\n    objects.forEach(function (obj) {\n        if (!obj)\n            return;\n        Object.keys(obj).forEach(function (key) {\n            var value = obj[key];\n            if (value !== void 0) {\n                result[key] = value;\n            }\n        });\n    });\n    return result;\n}\n//# sourceMappingURL=compact.js.map","var Log = (function () {\n    function Log(options) {\n        var _a = options.debug, debug = _a === void 0 ? false : _a;\n        this.debug = debug;\n        this.lines = [];\n    }\n    Log.prototype.emit = function (level, message) {\n        if (level in console) {\n            var prefix = Log.prefix;\n            console[level].apply(console, [prefix].concat(message));\n        }\n    };\n    Log.prototype.tailLogs = function () {\n        var _this = this;\n        this.lines.forEach(function (_a) {\n            var level = _a[0], message = _a[1];\n            return _this.emit(level, message);\n        });\n    };\n    Log.prototype.getLogs = function () {\n        return this.lines;\n    };\n    Log.prototype.write = function (level, message) {\n        var buffer = Log.buffer;\n        this.lines = this.lines.slice(1 - buffer).concat([[level, message]]);\n        if (this.debug || level !== 'log') {\n            this.emit(level, message);\n        }\n    };\n    Log.prototype.info = function () {\n        var message = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            message[_i] = arguments[_i];\n        }\n        this.write('log', message);\n    };\n    Log.prototype.warn = function () {\n        var message = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            message[_i] = arguments[_i];\n        }\n        this.write('warn', message);\n    };\n    Log.prototype.error = function () {\n        var message = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            message[_i] = arguments[_i];\n        }\n        this.write('error', message);\n    };\n    Log.buffer = 30;\n    Log.prefix = '[apollo-cache-persist]';\n    return Log;\n}());\nexport default Log;\n//# sourceMappingURL=Log.js.map","var Cache = (function () {\n    function Cache(options) {\n        var cache = options.cache, _a = options.serialize, serialize = _a === void 0 ? true : _a;\n        this.cache = cache;\n        this.serialize = serialize;\n    }\n    Cache.prototype.extract = function () {\n        var data = this.cache.extract();\n        if (this.serialize) {\n            data = JSON.stringify(data);\n        }\n        return data;\n    };\n    Cache.prototype.restore = function (data) {\n        if (this.serialize && typeof data === 'string') {\n            data = JSON.parse(data);\n        }\n        if (data != null) {\n            this.cache.restore(data);\n        }\n    };\n    return Cache;\n}());\nexport default Cache;\n//# sourceMappingURL=Cache.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [0, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar Storage = (function () {\n    function Storage(options) {\n        var storage = options.storage, _a = options.key, key = _a === void 0 ? 'apollo-cache-persist' : _a;\n        this.storage = storage;\n        this.key = key;\n    }\n    Storage.prototype.read = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                return [2, this.storage.getItem(this.key)];\n            });\n        });\n    };\n    Storage.prototype.write = function (data) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4, this.storage.setItem(this.key, data)];\n                    case 1:\n                        _a.sent();\n                        return [2];\n                }\n            });\n        });\n    };\n    Storage.prototype.purge = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4, this.storage.removeItem(this.key)];\n                    case 1:\n                        _a.sent();\n                        return [2];\n                }\n            });\n        });\n    };\n    Storage.prototype.getSize = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            var data;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4, this.storage.getItem(this.key)];\n                    case 1:\n                        data = _a.sent();\n                        if (data == null) {\n                            return [2, 0];\n                        }\n                        else {\n                            return [2, typeof data === 'string' ? data.length : null];\n                        }\n                        return [2];\n                }\n            });\n        });\n    };\n    return Storage;\n}());\nexport default Storage;\n//# sourceMappingURL=Storage.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = y[op[0] & 2 ? \"return\" : op[0] ? \"throw\" : \"next\"]) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [0, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar Persistor = (function () {\n    function Persistor(_a, options) {\n        var log = _a.log, cache = _a.cache, storage = _a.storage;\n        var _b = options.maxSize, maxSize = _b === void 0 ? 1024 * 1024 : _b;\n        this.log = log;\n        this.cache = cache;\n        this.storage = storage;\n        this.paused = false;\n        if (maxSize) {\n            this.maxSize = maxSize;\n        }\n    }\n    Persistor.prototype.persist = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            var data, error_1;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        _a.trys.push([0, 4, , 5]);\n                        data = this.cache.extract();\n                        if (!(this.maxSize != null &&\n                            typeof data === 'string' &&\n                            data.length > this.maxSize &&\n                            !this.paused)) return [3, 2];\n                        return [4, this.purge()];\n                    case 1:\n                        _a.sent();\n                        this.paused = true;\n                        return [2];\n                    case 2:\n                        if (this.paused) {\n                            this.paused = false;\n                        }\n                        return [4, this.storage.write(data)];\n                    case 3:\n                        _a.sent();\n                        this.log.info(typeof data === 'string'\n                            ? \"Persisted cache of size \" + data.length\n                            : 'Persisted cache');\n                        return [3, 5];\n                    case 4:\n                        error_1 = _a.sent();\n                        this.log.error('Error persisting cache', error_1);\n                        throw error_1;\n                    case 5: return [2];\n                }\n            });\n        });\n    };\n    Persistor.prototype.restore = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            var data, error_2;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        _a.trys.push([0, 5, , 6]);\n                        return [4, this.storage.read()];\n                    case 1:\n                        data = _a.sent();\n                        if (!(data != null)) return [3, 3];\n                        return [4, this.cache.restore(data)];\n                    case 2:\n                        _a.sent();\n                        this.log.info(typeof data === 'string'\n                            ? \"Restored cache of size \" + data.length\n                            : 'Restored cache');\n                        return [3, 4];\n                    case 3:\n                        this.log.info('No stored cache to restore');\n                        _a.label = 4;\n                    case 4: return [3, 6];\n                    case 5:\n                        error_2 = _a.sent();\n                        this.log.error('Error restoring cache', error_2);\n                        throw error_2;\n                    case 6: return [2];\n                }\n            });\n        });\n    };\n    Persistor.prototype.purge = function () {\n        return __awaiter(this, void 0, void 0, function () {\n            var error_3;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        _a.trys.push([0, 2, , 3]);\n                        return [4, this.storage.purge()];\n                    case 1:\n                        _a.sent();\n                        this.log.info('Purged cache storage');\n                        return [3, 3];\n                    case 2:\n                        error_3 = _a.sent();\n                        this.log.error('Error purging cache storage', error_3);\n                        throw error_3;\n                    case 3: return [2];\n                }\n            });\n        });\n    };\n    return Persistor;\n}());\nexport default Persistor;\n//# sourceMappingURL=Persistor.js.map","export default function (_a) {\n    var cache = _a.cache;\n    return function (persist) {\n        var write = cache.write;\n        cache.write = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            write.apply(cache, args);\n            persist();\n        };\n        return function () {\n            cache.write = write;\n        };\n    };\n};\n//# sourceMappingURL=onCacheWrite.js.map","import onCacheWrite from './onCacheWrite';\nimport onAppBackground from './onAppBackground';\nvar Trigger = (function () {\n    function Trigger(_a, options) {\n        var log = _a.log, persistor = _a.persistor;\n        var _this = this;\n        this.fire = function () {\n            if (!_this.debounce) {\n                _this.persist();\n                return;\n            }\n            if (_this.timeout != null) {\n                clearTimeout(_this.timeout);\n            }\n            _this.timeout = setTimeout(_this.persist, _this.debounce);\n        };\n        this.persist = function () {\n            if (_this.paused) {\n                return;\n            }\n            _this.persistor.persist();\n        };\n        var defaultDebounce = Trigger.defaultDebounce;\n        var cache = options.cache, debounce = options.debounce, _b = options.trigger, trigger = _b === void 0 ? 'write' : _b;\n        if (!trigger) {\n            return;\n        }\n        this.debounce = debounce != null ? debounce : defaultDebounce;\n        this.persistor = persistor;\n        this.paused = false;\n        switch (trigger) {\n            case 'write':\n                this.uninstall = onCacheWrite({ cache: cache })(this.fire);\n                break;\n            case 'background':\n                if (debounce) {\n                    log.warn('Debounce is not recommended with `background` trigger');\n                }\n                this.debounce = debounce;\n                this.uninstall = onAppBackground({ cache: cache, log: log })(this.fire);\n                break;\n            default:\n                if (typeof trigger === 'function') {\n                    this.uninstall = trigger(this.fire);\n                }\n                else {\n                    throw Error(\"Unrecognized trigger option: \" + trigger);\n                }\n        }\n    }\n    Trigger.prototype.pause = function () {\n        this.paused = true;\n    };\n    Trigger.prototype.resume = function () {\n        this.paused = false;\n    };\n    Trigger.prototype.remove = function () {\n        if (this.uninstall) {\n            this.uninstall();\n            this.uninstall = null;\n            this.paused = true;\n        }\n    };\n    Trigger.defaultDebounce = 1000;\n    return Trigger;\n}());\nexport default Trigger;\n//# sourceMappingURL=Trigger.js.map","import onCacheWrite from './onCacheWrite';\nexport default function (_a) {\n    var log = _a.log, cache = _a.cache;\n    return function (persist) {\n        log.warn('Trigger option `background` not available on web; using `write` trigger');\n        return onCacheWrite({ cache: cache })(persist);\n    };\n};\n//# sourceMappingURL=onAppBackground.js.map","import Log from './Log';\nimport Cache from './Cache';\nimport Storage from './Storage';\nimport Persistor from './Persistor';\nimport Trigger from './Trigger';\nvar CachePersistor = (function () {\n    function CachePersistor(options) {\n        if (!options.cache) {\n            throw new Error('In order to persist your Apollo Cache, you need to pass in a cache. ' +\n                'Please see https://www.apollographql.com/docs/react/basics/caching.html for our default InMemoryCache.');\n        }\n        if (!options.storage) {\n            throw new Error('In order to persist your Apollo Cache, you need to pass in an underlying storage provider. ' +\n                'Please see https://github.com/apollographql/apollo-cache-persist#storage-providers');\n        }\n        var log = new Log(options);\n        var cache = new Cache(options);\n        var storage = new Storage(options);\n        var persistor = new Persistor({ log: log, cache: cache, storage: storage }, options);\n        var trigger = new Trigger({ log: log, persistor: persistor }, options);\n        this.log = log;\n        this.cache = cache;\n        this.storage = storage;\n        this.persistor = persistor;\n        this.trigger = trigger;\n    }\n    CachePersistor.prototype.persist = function () {\n        return this.persistor.persist();\n    };\n    CachePersistor.prototype.restore = function () {\n        return this.persistor.restore();\n    };\n    CachePersistor.prototype.purge = function () {\n        return this.persistor.purge();\n    };\n    CachePersistor.prototype.pause = function () {\n        this.trigger.pause();\n    };\n    CachePersistor.prototype.resume = function () {\n        this.trigger.resume();\n    };\n    CachePersistor.prototype.remove = function () {\n        this.trigger.remove();\n    };\n    CachePersistor.prototype.getLogs = function (print) {\n        if (print === void 0) { print = false; }\n        if (print) {\n            this.log.tailLogs();\n        }\n        else {\n            return this.log.getLogs();\n        }\n    };\n    CachePersistor.prototype.getSize = function () {\n        return this.storage.getSize();\n    };\n    return CachePersistor;\n}());\nexport default CachePersistor;\n//# sourceMappingURL=CachePersistor.js.map","import React, { useContext, useRef, useState, useEffect, useLayoutEffect, useMemo, Component } from 'react';\nimport { EventEmitter } from 'events';\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _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\n  return obj;\n}\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) _setPrototypeOf(subClass, superClass);\n}\n\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return _assertThisInitialized(self);\n}\n\nfunction _createSuper(Derived) {\n  var hasNativeReflectConstruct = _isNativeReflectConstruct();\n\n  return function _createSuperInternal() {\n    var Super = _getPrototypeOf(Derived),\n        result;\n\n    if (hasNativeReflectConstruct) {\n      var NewTarget = _getPrototypeOf(this).constructor;\n\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n\n    return _possibleConstructorReturn(this, result);\n  };\n}\n\nfunction _slicedToArray(arr, i) {\n  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();\n}\n\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return _arrayLikeToArray(arr);\n}\n\nfunction _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nfunction _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nfunction _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\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}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n  return arr2;\n}\n\nfunction _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}\n\nfunction _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) {\n  var it;\n\n  if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) {\n    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n\n      var F = function () {};\n\n      return {\n        s: F,\n        n: function () {\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) {\n          throw e;\n        },\n        f: F\n      };\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\n  var normalCompletion = true,\n      didErr = false,\n      err;\n  return {\n    s: function () {\n      it = o[Symbol.iterator]();\n    },\n    n: function () {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function (e) {\n      didErr = true;\n      err = e;\n    },\n    f: function () {\n      try {\n        if (!normalCompletion && it.return != null) it.return();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}\n\nfunction createCommonjsModule(fn, module) {\n\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n}\n\nvar debug = createCommonjsModule(function (module) {\n/**\n * \n * I stole most of this code from the debug lib\n * https://github.com/visionmedia/debug\n * \n * Just wanted it to be easy to debug without relying on the dependency!\n */\n\n/**\n\t* Selects a color for a debug namespace\n  * @param {String} namespace The namespace string for the for the debug instance to be colored\n  * @param {String} colors color pallette to choose from\n\t* @return {Number|String} An ANSI color code for the given namespace\n\t* @api private\n\t*/\nfunction selectColor(namespace, colors) {\n  var hash = 0;\n\n  for (var i = 0; i < namespace.length; i++) {\n    hash = (hash << 5) - hash + namespace.charCodeAt(i);\n    hash |= 0; // Convert to 32bit integer\n  }\n\n  return colors[Math.abs(hash) % colors.length];\n}\n/**\n * Adds ANSI color escape codes if enabled.\n *\n * @api public\n */\n\n\nfunction formatNodeArgs(args, config) {\n  var name = config.namespace;\n\n  if (config.useColors) {\n    var c = config.color;\n    var colorCode = \"\\x1B[3\" + (c < 8 ? c : '8;5;' + c);\n    var prefix = \"  \".concat(colorCode, \";1m\").concat(name, \" \\x1B[0m\");\n    args[0] = prefix + args[0].split('\\n').join('\\n' + prefix);\n  } else {\n    args[0] = name + ' ' + args[0];\n  }\n}\n/**\n * Colorize log arguments if enabled.\n *\n */\n\n\nfunction formatBrowserArgs(args, config) {\n  args[0] = (config.useColors ? '%c' : '') + config.namespace;\n\n  if (!config.useColors) {\n    return;\n  }\n\n  var c = 'color: ' + config.color; // The final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-zA-Z%]/g, function (match) {\n    if (match === '%%') {\n      return;\n    }\n\n    index++;\n\n    if (match === '%c') {\n      // We only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n  args.splice(lastC, 0, c);\n}\n\nvar browserColors = ['#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'];\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the debug modes\n * @api private\n */\n\nfunction loadBrowser() {\n  var namespaces;\n\n  try {\n    namespaces = localStorage.getItem('debug');\n  } catch (error) {// Swallow\n    // XXX (@Qix-) should we be logging these?\n  } // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\n\n  if (!namespaces && typeof process !== 'undefined' && 'env' in process) {\n    namespaces = process.env.DEBUG;\n  }\n\n  return {\n    namespaces: namespaces || '',\n    colors: browserColors,\n    useColors: true,\n    formatArgs: formatBrowserArgs\n  };\n}\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the debug modes\n * @api private\n */\n\n\nfunction loadNode() {\n  return {\n    namespaces: process.env.DEBUG || '',\n    colors: [6, 2, 3, 4, 5, 1],\n    useColors: true,\n    formatArgs: formatNodeArgs\n  };\n}\n\nfunction createLogger() {\n  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n  var config = arguments.length > 1 ? arguments[1] : undefined;\n  return function () {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    if (prefix) {\n      args.unshift(prefix);\n    } // Create a namespace regex for each namespace\n\n\n    var matches = config.namespaces.split(',').map(function (namespace) {\n      // Remove wildcard and add to regex if wildcard\n      if (namespace[namespace.length - 1] === '*') {\n        return new RegExp('^' + namespace.slice(0, namespace.length - 1) + '.*' + '$');\n      }\n\n      return new RegExp('^' + namespace + '$');\n    }); // Does the prefix match a namespace\n\n    var match = matches.some(function (regex) {\n      return regex.test(prefix);\n    });\n    var conf = {\n      color: selectColor(prefix, config.colors),\n      namespace: prefix,\n      useColors: config.useColors\n    };\n\n    if (process.env.NODE_ENV !== 'production' && match) {\n      var _console;\n\n      config.formatArgs(args, conf);\n\n      (_console = console).log.apply(_console, args);\n    }\n  };\n}\n\nfunction nodeLogger(prefix) {\n  return createLogger(prefix, loadNode());\n}\n\nfunction browserLogger(prefix) {\n  return createLogger(prefix, loadBrowser());\n}\n/**\n * Detect Electron renderer / nwjs process, which is node, but we should\n * treat as a browser.\n */\n\n\nif (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {\n  module.exports = browserLogger;\n} else {\n  module.exports = nodeLogger;\n}\n});\n\nvar debug$1 = debug('informed:ObjMap' + '\\t');\n/* -------------------- toPath -------------------- */\n\nvar ldtoPath = function ldtoPath() {\n  var path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n  return String.prototype.replace.call(path, /\\['(.+?)'\\]/g, '.$1').split(/[,[\\].]+?/).filter(Boolean);\n};\n/* --------------------- get --------------------- */\n\n\nvar ldget = function ldget(obj) {\n  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n  var defaultValue = arguments.length > 2 ? arguments[2] : undefined;\n  var result = String.prototype.replace.call(path, /\\['(.+?)'\\]/g, '.$1').split(/[,[\\].]+?/).filter(Boolean).reduce(function (res, key) {\n    return res !== null && res !== undefined ? res[key] : res;\n  }, obj);\n  return result === undefined || result === obj ? defaultValue : result;\n};\n/* --------------------- has --------------------- */\n// foo -->\n// foo.bar --> foo\n// foo.bar[3] --> foo.bar\n// foo.bar.baz[2].raz.taz[5].laz --> foo.bar.baz[2].raz.taz[5]\n\n\nvar parentPath = function parentPath(path) {\n  return \".\".concat(path).replace(/(.*)[.[].*/, '$1').replace(/\\./, '');\n}; // foo --> foo\n// foo.bar --> bar\n// foo.bar[3] --> [3]\n// foo.bar.baz[2].raz.taz[5].laz --> laz\n\n\nvar pathKey = function pathKey(path) {\n  return path.replace(parentPath(path), '').replace(/\\./, '');\n};\n\nvar ldhas = function ldhas(obj, path) {\n  var pPath = parentPath(path);\n  var key = pathKey(path); // If we have parent path then get the object at that location\n  // .. otherwise its the root object\n\n  var parentObj = pPath ? get(obj, pPath) : obj; // If its [3] turn key into 3\n\n  return !!(parentObj && Object.hasOwnProperty.call(parentObj, key.replace(/\\[(.*)\\]/, '$1')));\n};\n/* --------------------- set --------------------- */\n\n\nvar ldset = function ldset(obj) {\n  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n  var val = arguments.length > 2 ? arguments[2] : undefined;\n  String.prototype.replace.call(path, /\\['(.+?)'\\]/g, '.$1').split(/[,[\\].]+?/).filter(Boolean).reduce(function (res, key, i, arr) {\n    //console.log('RES', res, 'Key', key, 'I', i, 'Arr', arr, 'OBJ', obj);\n    // At the leaf set the value\n    if (i === arr.length - 1) {\n      res[key] = val;\n      return res[key];\n    } // Initialize to new array or object if needed\n\n\n    if (res[key] === undefined) {\n      if (Number.isInteger(+arr[i + 1])) {\n        res[key] = [];\n      } else {\n        res[key] = {};\n      }\n\n      return res[key];\n    } // Exception for if the value is changeing to an array\n\n\n    if (Number.isInteger(+arr[i + 1]) && !Array.isArray(res[key])) {\n      res[key] = [];\n    } //TODO exception for if object ??\n    // Otherwise keep whats there\n\n\n    return res[key];\n  }, obj);\n};\n/* --------------------- unset --------------------- */\n\n\nvar ldunset = function ldunset(obj) {\n  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n  var found = false;\n  String.prototype.replace.call(path, /\\['(.+?)'\\]/g, '.$1').split(/[,[\\].]+?/).filter(Boolean).reduce(function (res, key, i, arr) {\n    // Base case res is undefined\n    if (res === undefined) {\n      return res;\n    } // At the leaf delete the value\n\n\n    if (i === arr.length - 1) {\n      delete res[key];\n      found = true;\n      return res[key];\n    } // Otherwise keep going\n\n\n    return res[key];\n  }, obj);\n  return found;\n};\n/* --------------------- pullAt --------------------- */\n\n\nvar ldpullAt = function ldpullAt(obj) {\n  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n  var pulled;\n  String.prototype.replace.call(path, /\\['(.+?)'\\]/g, '.$1').split(/[,[\\].]+?/).filter(Boolean).reduce(function (res, key, i, arr) {\n    // Base case res is undefined\n    if (res === undefined) {\n      return res;\n    } // At the leaf delete the value\n\n\n    if (i === arr.length - 1 && Array.isArray(res)) {\n      // Pull out one value at index ( key )\n      pulled = res.splice(key, 1);\n      return res[key];\n    } // Otherwise keep going\n\n\n    return res[key];\n  }, obj);\n  return pulled;\n};\n/* --------------------- values --------------------- */\n\n\nvar ldvalues = function ldvalues() {\n  var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var props = Object.keys(obj);\n  return props.map(function (key) {\n    return obj[key];\n  });\n};\n\nvar pathToArrayElem = function pathToArrayElem(path) {\n  var pathArray = ldtoPath(path);\n  return Number.isInteger(+pathArray[pathArray.length - 1]);\n};\n\nvar ObjectMap = /*#__PURE__*/function () {\n  function ObjectMap() {\n    _classCallCheck(this, ObjectMap);\n  }\n\n  _createClass(ObjectMap, null, [{\n    key: \"empty\",\n    value: function empty(object) {\n      return ldvalues(object).length === 0;\n    }\n  }, {\n    key: \"get\",\n    value: function get(object, path) {\n      var val = ldget(object, path); //debug('GOT', path, val);\n\n      return val;\n    }\n  }, {\n    key: \"has\",\n    value: function has(object, path) {\n      return ldhas(object, path);\n    }\n  }, {\n    key: \"set\",\n    value: function set(object, path, value) {\n      if (value !== undefined) {\n        debug$1('SETTING', path, value);\n        ldset(object, path, value);\n      } else {\n        // Setting things to undefined in informed is special!\n        // so in this else statement we deal with that\n        // If the path is to an array leaf then we want to set to undefined\n        // Example:\n        // path = 'foo.bar[2]'\n        // foo.bar = [ 'baz', 'raz', 'taz' ]\n        // setting taz to undefined   ^^^\n        if (pathToArrayElem(path) && ObjectMap.get(object, path) !== undefined) {\n          debug$1('Special case SETTING', path, 'to undefined');\n          ldset(object, path, undefined);\n          var pathArray = ldtoPath(path);\n          pathArray = pathArray.slice(0, pathArray.length - 1);\n          cleanup(object, pathArray);\n        } // Only delete the field if it needs to be deleted and its not a path to an array ( array leaf )\n        // Example:\n        // path = 'foo.bar'\n        // foo.bar = 'baz'\n        // removing foo.bar from the object completley\n        else if (!pathToArrayElem(path) && ObjectMap.get(object, path) !== undefined) {\n            debug$1('Special case REMOVING', path, 'from object completley');\n            ObjectMap[\"delete\"](object, path);\n          }\n      }\n    }\n  }, {\n    key: \"delete\",\n    value: function _delete(object, path) {\n      debug$1('DELETE', path); // Special case for arrays\n\n      if (pathToArrayElem(path)) {\n        debug$1('ARRAY', path); //ldunset(object, path);\n\n        this.pullOut(object, path);\n      } else {\n        ldunset(object, path);\n      }\n\n      var pathArray = ldtoPath(path);\n      pathArray = pathArray.slice(0, pathArray.length - 1);\n      cleanup(object, pathArray);\n    } // Very important ;)\n\n  }, {\n    key: \"pullOut\",\n    value: function pullOut(object, path) {\n      // Get the path to the array\n      var pathArray = ldtoPath(path); // debug('PathArray1', pathArray);\n\n      var index = pathArray[pathArray.length - 1];\n      pathArray = pathArray.slice(0, pathArray.length - 1);\n      debug$1('Pulling out:', pathArray, 'index', index); // Get the array\n\n      var arr = ldget(object, pathArray);\n      debug$1('Array', arr); // Pull out of array\n\n      if (Array.isArray(arr)) {\n        ldpullAt(arr, index);\n      }\n\n      cleanup(object, pathArray);\n    }\n  }]);\n\n  return ObjectMap;\n}();\n\nfunction cleanup(obj, path) {\n\n  // Base case no path left\n  if (path.length === 0) {\n    return;\n  }\n\n  var object = ldget(obj, path); // Clean up undefined from array\n  // if (Array.isArray(object) && pull) {\n  //   ldpull(object, undefined);\n  // }\n  // Delete object if its empty\n\n  if (Array.isArray(object) ? object.every(function (e) {\n    return e == null;\n  }) : JSON.stringify(object) === '{}') {\n    ldunset(obj, path);\n  } // Recur\n\n\n  cleanup(obj, path.slice(0, path.length - 1));\n}\n\nvar FormRegisterContext = /*#__PURE__*/React.createContext({\n  register: function register() {},\n  deregister: function deregister() {},\n  setValue: function setValue() {},\n  setTouched: function setTouched() {},\n  setError: function setError() {},\n  update: function update() {},\n  getField: function getField() {},\n  expectRemoval: function expectRemoval() {},\n  getInitialValue: function getInitialValue() {}\n});\nvar FormStateContext = /*#__PURE__*/React.createContext({});\nvar FormApiContext = /*#__PURE__*/React.createContext({\n  getFullField: function getFullField() {},\n  getValues: function getValues() {},\n  getOptions: function getOptions() {\n    return {};\n  },\n  setInitialValue: function setInitialValue() {},\n  getInitialValue: function getInitialValue() {},\n  getDerrivedValue: function getDerrivedValue() {},\n  getSavedValue: function getSavedValue() {},\n  removeSavedState: function removeSavedState() {}\n});\nvar GroupContext = /*#__PURE__*/React.createContext();\nvar ArrayFieldStateContext = /*#__PURE__*/React.createContext();\nvar ArrayFieldApiContext = /*#__PURE__*/React.createContext();\nvar ArrayFieldItemApiContext = /*#__PURE__*/React.createContext();\nvar ArrayFieldItemStateContext = /*#__PURE__*/React.createContext();\nvar MultistepStateContext = /*#__PURE__*/React.createContext();\nvar MultistepApiContext = /*#__PURE__*/React.createContext();\nvar MultistepStepContext = /*#__PURE__*/React.createContext();\n\nfunction useFormApi() {\n  var formApi = useContext(FormApiContext);\n  return formApi;\n}\n\n// https://github.com/facebook/react/issues/14543\n\nfunction useStateWithGetter(initial) {\n  var ref = useRef();\n  var mounted = useRef(true);\n\n  var _useState = useState(initial),\n      _useState2 = _slicedToArray(_useState, 2),\n      state = _useState2[0],\n      setState = _useState2[1];\n\n  ref.current = state;\n\n  var set = function set(value) {\n    ref.current = value;\n    if (mounted.current) setState(value);\n  };\n\n  var get = function get() {\n    return ref.current;\n  };\n\n  useEffect(function () {\n    return function () {\n      mounted.current = false;\n    };\n  }, []);\n  return [state, set, get];\n}\n\nvar getChildDisplayName = function getChildDisplayName(WrappedComponent) {\n  // fix for \"memo\" components\n  if (WrappedComponent.type && WrappedComponent.type.name) {\n    return WrappedComponent.type.name;\n  }\n\n  return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n};\nvar yupToFormErrors = function yupToFormErrors(yupError) {\n  var errors = {};\n\n  if (yupError.inner) {\n    if (yupError.inner.length === 0) {\n      // console.log(yupError.path);\n      ObjectMap.set(errors, yupError.path, yupError.message);\n      return;\n    }\n\n    var _iterator = _createForOfIteratorHelper(yupError.inner),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var err = _step.value;\n\n        if (!ObjectMap.get(errors, err.path)) {\n          // console.log(errors, err.path, err.message);\n          ObjectMap.set(errors, err.path, err.message);\n        }\n      }\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n  }\n\n  return errors;\n};\nvar validateYupSchema = function validateYupSchema(schema, values) {\n  try {\n    schema.validateSync(values, {\n      abortEarly: false\n    });\n  } catch (e) {\n    var formErrors = yupToFormErrors(e);\n    return formErrors;\n  }\n};\nvar yupToFormError = function yupToFormError(yupError) {\n  if (yupError.inner) {\n    if (yupError.inner.length === 0) {\n      return;\n    }\n\n    var err = yupError.inner[0];\n    return err.message;\n  }\n};\nvar validateYupField = function validateYupField(schema, value) {\n  try {\n    schema.validateSync(value, {\n      abortEarly: false\n    });\n  } catch (e) {\n    return yupToFormError(e);\n  }\n};\nvar validateAjvSchema = function validateAjvSchema(validate, data) {\n  validate(data);\n  var errors = {};\n\n  if (validate.errors) {\n    validate.errors.forEach(function (_ref) {\n      var message = _ref.message,\n          dataPath = _ref.dataPath,\n          keyword = _ref.keyword,\n          params = _ref.params;\n      var path = dataPath; // Special case for required\n\n      if (keyword === 'required') {\n        path = \"\".concat(path, \".\").concat(params.missingProperty);\n      } // Get rid of leading dot\n\n\n      path = path.replace('.', ''); // console.log('PATH', path, message);\n      // TODO get message from informed if present\n\n      ObjectMap.set(errors, path, message);\n    });\n  }\n\n  return errors;\n}; // https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript\n\nvar uuidv4 = function uuidv4() {\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n    var r = Math.random() * 16 | 0,\n        v = c == 'x' ? r : r & 0x3 | 0x8;\n    return v.toString(16);\n  });\n};\nvar computeFieldFromProperty = function computeFieldFromProperty(propertyName, property, prefix) {\n  var uiControl = property['ui:control'],\n      informedProps = property['informed:props'],\n      inputProps = property['input:props'],\n      uiBefore = property['ui:before'],\n      uiAfter = property['ui:after'],\n      oneOf = property.oneOf,\n      items = property.items,\n      schemaEnum = property[\"enum\"],\n      label = property.title,\n      min = property.minimum,\n      max = property.maximum,\n      minLength = property.minLength,\n      maxLength = property.maxLength,\n      pattern = property.pattern,\n      type = property.type,\n      subProperties = property.properties; // Set Id if not passed\n\n  var id = uuidv4();\n\n  if (inputProps && inputProps.id) {\n    id = inputProps.id;\n  }\n\n  var field = {\n    componentType: uiControl,\n    field: prefix ? \"\".concat(prefix, \".\").concat(propertyName) : propertyName,\n    type: type,\n    uiBefore: uiBefore,\n    uiAfter: uiAfter,\n    properties: type === 'object' ? subProperties : undefined,\n    items: type === 'array' ? items : undefined,\n    props: _objectSpread2(_objectSpread2({\n      label: label,\n      id: id,\n      min: min,\n      max: max,\n      minLength: minLength,\n      maxLength: maxLength,\n      pattern: pattern\n    }, informedProps), inputProps)\n  };\n\n  if (oneOf) {\n    var options = property.oneOf.map(function (option) {\n      var _option$inputProps = option['input:props'],\n          inputProps = _option$inputProps === void 0 ? {} : _option$inputProps;\n      return _objectSpread2({\n        value: option[\"const\"],\n        label: option.title\n      }, inputProps);\n    });\n    field.props.options = options;\n  }\n\n  if (schemaEnum) {\n    var _options = property[\"enum\"].map(function (val) {\n      return {\n        value: val,\n        label: val\n      };\n    });\n\n    field.props.options = _options;\n  }\n\n  if (items && items.oneOf) {\n    var _options2 = items.oneOf.map(function (option) {\n      var _option$inputProps2 = option['input:props'],\n          inputProps = _option$inputProps2 === void 0 ? {} : _option$inputProps2;\n      return _objectSpread2({\n        value: option[\"const\"],\n        label: option.title\n      }, inputProps);\n    });\n\n    field.props.options = _options2;\n  }\n\n  return field;\n};\nvar computeFieldsFromSchema = function computeFieldsFromSchema(schema, onlyValidateSchema, prefix) {\n  if (!schema || onlyValidateSchema) {\n    return [];\n  } // Grab properties and items off of schema\n\n\n  var _schema$properties = schema.properties,\n      properties = _schema$properties === void 0 ? {} : _schema$properties,\n      allOf = schema.allOf,\n      _schema$propertyOrder = schema.propertyOrder,\n      propertyOrder = _schema$propertyOrder === void 0 ? [] : _schema$propertyOrder;\n\n  if (Object.keys(properties).length > 0) {\n    // Attempt to generate fields from properties\n    var fields = Object.keys(properties).sort(function (a, b) {\n      var aIndex = propertyOrder.indexOf(a);\n      var bIndex = propertyOrder.indexOf(b);\n      return (aIndex > -1 ? aIndex : propertyOrder.length + 1) - (bIndex > -1 ? bIndex : propertyOrder.length + 1);\n    }).map(function (propertyName) {\n      var property = properties[propertyName];\n      var field = computeFieldFromProperty(propertyName, property, prefix);\n      return field;\n    }); // Check for all of ( we have conditionals )\n\n    if (allOf) {\n      fields.push({\n        componentType: 'conditionals',\n        // Each element of the \"allOf\" array is a conditional\n        allOf: allOf\n      });\n    }\n\n    return fields;\n  }\n\n  return [];\n}; // Examples\n// field = \"name\" ---> properties.name\n// field = \"brother.name\" ---> properties.brother.properties.name\n// field = \"brother.siblings[1].friend.name\" ---> properties.brother.properties.siblings.items[1].properties.friend.properties.name\n\nvar getSchemaPathFromJsonPath = function getSchemaPathFromJsonPath(jsonPath) {\n  // Convert\n  var schemaPath = jsonPath.replace(/\\./g, '.properties.').replace(/\\[/g, '.itmes['); // Add first properties\n\n  schemaPath = \"properties.\".concat(schemaPath);\n  return schemaPath;\n};\n/* -------------------------- Formatter ----------------------------- */\n\nvar getFormatter = function getFormatter(formatter, value) {\n  // If mask is a string turn it into an array;\n  if (typeof formatter === 'string') {\n    return formatter.split('').map(function (_char) {\n      if (_char === '#') {\n        return /\\d/;\n      }\n\n      if (_char === '*') {\n        return /[\\w]/;\n      }\n\n      return _char;\n    });\n  } // If mask is a function use it to genreate current mask\n\n\n  if (typeof formatter === 'function') {\n    return formatter(value);\n  }\n\n  if (Array.isArray(formatter)) {\n    return formatter;\n  } // Should never make it here throw\n\n\n  throw new Error('Formatter must be string, array, or function');\n};\n\nvar matchingIndex = function matchingIndex(a, b) {\n  var i = 0;\n  var mi = -1;\n  var matching = true; // a = \"+1 \"\n  // b = \"+12\"\n\n  while (matching && i < a.length) {\n    if (a[i] == b[i]) {\n      mi = i;\n    } else {\n      matching = false;\n    }\n\n    i = i + 1;\n  }\n\n  return mi;\n};\n\nvar informedFormat = function informedFormat(value, frmtr) {\n  // console.log('Formatting', value);\n  // Null check\n  if (!value) {\n    return {\n      value: value,\n      offset: 0\n    };\n  } // Generate formatter array\n\n\n  var formatter = getFormatter(frmtr, value); // Start to fill in the array\n  // Example: phone formatter\n  // formatter =['+', '1', ' ', /\\d/, /\\d/, /\\d/, '-', /\\d/, /\\d/, /\\d/, '-', /\\d/, /\\d/, /\\d/, /\\d/]\n  // value examples:\n  // \"1231231234 ----> +1 123-123-1234\n  // \"+\" \t\t\t\t ----> +\n  // \"+1\" \t\t\t ----> +1\n  // \"+2\"\t\t\t\t ----> +1 2\n  // \"1\"\t\t\t\t ----> +1 1\n  // \"1234\"\t\t\t ----> +1 123-4\n  // \"123a\"      ----> +1 123\n  // Determine prefix length and suffix start\n\n  var prefixLength = formatter.findIndex(function (v) {\n    return typeof v != 'string';\n  });\n\n  var suffixStart = formatter.length - _toConsumableArray(formatter).reverse().findIndex(function (v) {\n    return typeof v != 'string';\n  }); // Formatted value\n\n\n  var formatted = []; // The characters from the current value\n\n  var chars = value.split(''); // To track the value index during itteration\n\n  var vIndex = 0;\n  var start = 0; // If the value matches part of the prefix take it out\n  // Example prefix = \"+1 \" value = [\"+1 123-123-1234\", \"+12\", \"+2\"]\n\n  var matchIndex = matchingIndex(formatter.slice(0, prefixLength), chars.slice(0, prefixLength)); // console.log('Matching index', matchIndex);\n\n  if (matchIndex > -1) {\n    //vIndex = prefixLength;\n    vIndex = matchIndex + 1;\n    formatted = formatted.concat(formatter.slice(0, matchIndex + 1));\n    start = matchIndex + 1;\n  } // Example prefix = \"+1 \" value=[\"1\", \"1234\"]\n\n\n  if (matchIndex < 0) {\n    // Start past the prefix\n    formatted = formatted.concat(formatter.slice(0, prefixLength));\n    start = prefixLength;\n  } // console.log('start', start, formatted);\n\n  for (var i = start; i < formatter.length; i++) {\n    // Get current formatter location matcher\n    var matcher = formatter[i]; // We get past the prefix if matcher is not a string\n\n\n    if (vIndex != chars.length) {\n      // Get the current value character\n      var curChar = chars[vIndex]; // If type is string normal compare otherwise regex compare\n\n      var match = typeof matcher === 'string' ? matcher === curChar : matcher.test(curChar); // If the current character of the value matches and matcher is a string\n      // \"1\" === \"1\"\n\n      if (match && typeof matcher === 'string') {\n        formatted.push(matcher); //if( pastPrefix ){\n\n        vIndex = vIndex + 1; //}\n      } // If the current character does not match and matcher is a stirng\n      // \"1\" != \"+\"\n      else if (!match && typeof matcher === 'string') {\n          // Special check for 123a ---> dont want \"+1 123-\"\n          // Special check for 1234 ---> DO want \"+1 123-4\"\n          if (vIndex != chars.length) formatted.push(matcher);\n        } // If the current character matches and the matcher is not a string\n        // /\\d/.test(\"2\")\n        else if (match && typeof matcher != 'string') {\n            formatted.push(curChar);\n            vIndex = vIndex + 1;\n          } // If the current character does NOT match and the matecer is regex\n          // /\\d/.test(\"a\")\n          else if (!match && typeof matcher != 'string') {\n              // Throw out this value\n              vIndex = vIndex + 1;\n              i = i - 1;\n            }\n    } else {\n      // If mattcher is a string and we are at suffix keep going\n      if (typeof matcher === 'string' && i >= suffixStart) {\n        formatted.push(matcher);\n      } else {\n        // Otherwise we want to break out\n        break;\n      }\n    }\n  }\n\n  return {\n    value: formatted.join(''),\n    offset: value ? formatted.length - value.length : 0\n  };\n};\n\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser.\n// @see https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85\n\nvar useIsomorphicLayoutEffect = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined' ? useLayoutEffect : useEffect;\n\nvar logger = debug('informed:useField' + '\\t'); // localStorage.debug = 'informed:.*' << HOW to enable debuging\n\nvar initializeValue = function initializeValue(value, mask, formatter, parser) {\n  if (value != null) {\n    // Call mask if it was passed\n    if (mask) {\n      return mask(value);\n    }\n\n    if (formatter && !parser) {\n      var res = informedFormat(value, formatter);\n      return res.value;\n    }\n\n    return value;\n  } // Not needed but called out specifically\n\n\n  return undefined;\n};\n\nvar initializeMask = function initializeMask(value, format, parse, formatter) {\n  // Call format and parse if they were passed\n  if (format && parse) {\n    return format(value);\n  } // Call formatter\n\n\n  if (formatter) {\n    var res = informedFormat(value, formatter);\n    return res.value;\n  }\n\n  return value;\n};\n\nvar generateValidationFunction = function generateValidationFunction(validationFunc, validationSchema, _ref) {\n  var required = _ref.required;\n\n  // We dont want a validation function if there was nothing passed\n  if (validationFunc || validationSchema) {\n    return function (val, values) {\n      if (validationSchema) {\n        return validateYupField(validationSchema, val);\n      }\n\n      if (validationFunc) {\n        return validationFunc(val, values);\n      }\n    };\n  }\n\n  if (required) {\n    return function (val) {\n      return validateRequired(val, required);\n    };\n  }\n};\n\nvar generateOnChange = function generateOnChange(_ref2) {\n  var fieldType = _ref2.fieldType,\n      setValue = _ref2.setValue,\n      onChange = _ref2.onChange,\n      multiple = _ref2.multiple,\n      ref = _ref2.ref;\n\n  var setter = function setter(val) {\n    return setValue(val);\n  };\n\n  if (fieldType === 'text' || fieldType === 'textArea' || fieldType === 'number') {\n    setter = function setter(e) {\n      return setValue(e.target.value, e);\n    };\n  }\n\n  if (fieldType === 'select') {\n    setter = function setter() {\n      var selected = Array.from(ref.current).filter(function (option) {\n        return option.selected;\n      }).map(function (option) {\n        return option.value;\n      });\n      setValue(multiple ? selected : selected[0] || '');\n    };\n  }\n\n  if (fieldType === 'checkbox') {\n    setter = function setter(e) {\n      setValue(e.target.checked);\n\n      if (onChange) {\n        onChange(e);\n      }\n    };\n  }\n\n  return function (val) {\n    setter(val);\n\n    if (onChange) {\n      onChange(val);\n    }\n  };\n};\n\nvar generateOnBlur = function generateOnBlur(_ref3) {\n  var setTouched = _ref3.setTouched,\n      onBlur = _ref3.onBlur;\n  return function (e) {\n    setTouched(true);\n\n    if (onBlur) {\n      onBlur(e);\n    }\n  };\n};\n\nvar generateValue = function generateValue(_ref4) {\n  var fieldType = _ref4.fieldType,\n      maskedValue = _ref4.maskedValue,\n      multiple = _ref4.multiple,\n      value = _ref4.value;\n\n  switch (fieldType) {\n    case 'text':\n    case 'number':\n      return !maskedValue && maskedValue !== 0 ? '' : maskedValue;\n\n    case 'textArea':\n      return !maskedValue ? '' : maskedValue;\n\n    case 'select':\n      return value || (multiple ? [] : '');\n\n    case 'checkbox':\n      return !!value;\n\n    default:\n      return value;\n  }\n};\n\nvar generateFieldType = function generateFieldType(fieldType) {\n  switch (fieldType) {\n    case 'text':\n      return fieldType;\n\n    case 'number':\n      return fieldType;\n\n    case 'checkbox':\n      return fieldType;\n\n    default:\n      return;\n  }\n};\n\nvar validateRequired = function validateRequired(value, required) {\n  if (required && (value == null || value === '')) {\n    return typeof required === 'string' ? required : 'This field is required';\n  }\n};\n\nfunction useField() {\n  var fieldProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var userRef = arguments.length > 1 ? arguments[1] : undefined;\n\n  // Pull props off of field props\n  var field = fieldProps.field,\n      validationFunc = fieldProps.validate,\n      asyncValidate = fieldProps.asyncValidate,\n      validationSchema = fieldProps.validationSchema,\n      mask = fieldProps.mask,\n      maskWithCursorOffset = fieldProps.maskWithCursorOffset,\n      format = fieldProps.format,\n      parse = fieldProps.parse,\n      formatter = fieldProps.formatter,\n      parser = fieldProps.parser,\n      initialValue = fieldProps.initialValue,\n      validateOnChange = fieldProps.validateOnChange,\n      validateOnBlur = fieldProps.validateOnBlur,\n      validateOnMount = fieldProps.validateOnMount,\n      asyncValidateOnBlur = fieldProps.asyncValidateOnBlur,\n      maskOnBlur = fieldProps.maskOnBlur,\n      allowEmptyString = fieldProps.allowEmptyString,\n      onValueChange = fieldProps.onValueChange,\n      notify = fieldProps.notify,\n      keepState = fieldProps.keepState,\n      maintainCursor = fieldProps.maintainCursor,\n      debug = fieldProps.debug,\n      shadow = fieldProps.shadow,\n      step = fieldProps.step,\n      fieldType = fieldProps.fieldType,\n      multiple = fieldProps.multiple,\n      onChange = fieldProps.onChange,\n      onBlur = fieldProps.onBlur,\n      formController = fieldProps.formController,\n      userRelevant = fieldProps.relevant,\n      required = fieldProps.required,\n      keepStateIfRelevant = fieldProps.keepStateIfRelevant,\n      userProps = _objectWithoutProperties(fieldProps, [\"field\", \"validate\", \"asyncValidate\", \"validationSchema\", \"mask\", \"maskWithCursorOffset\", \"format\", \"parse\", \"formatter\", \"parser\", \"initialValue\", \"validateOnChange\", \"validateOnBlur\", \"validateOnMount\", \"asyncValidateOnBlur\", \"maskOnBlur\", \"allowEmptyString\", \"onValueChange\", \"notify\", \"keepState\", \"maintainCursor\", \"debug\", \"shadow\", \"step\", \"fieldType\", \"multiple\", \"onChange\", \"onBlur\", \"formController\", \"relevant\", \"required\", \"keepStateIfRelevant\"]); // Create ref to a field id\n\n\n  var _useState = useState(uuidv4()),\n      _useState2 = _slicedToArray(_useState, 1),\n      fieldId = _useState2[0]; // Grab the form register context\n\n\n  var updater = useContext(FormRegisterContext); // Grab multistepContext\n\n  var multistepContext = useContext(MultistepStepContext);\n  var inMultistep = multistepContext || keepStateIfRelevant; // Grab the form api\n\n  var formApi = useFormApi(); // Create ref to fieldApi\n\n  var fieldApiRef = useRef(); // Create initial render ref\n\n  var initialRenerRef = useRef(true); // Create ref to fieldObject\n\n  var fieldObjectRef = useRef(); // If the form Controller was passed in then use that instead\n\n  if (formController) {\n    updater = formController.updater;\n    formApi = formController.getFormApi();\n  } // Generate validation function\n\n\n  var validate = generateValidationFunction(validationFunc, validationSchema, {\n    required: required\n  }); // Grab possible initial value from form\n\n  var _useState3 = useState(function () {\n    return updater.getInitialValue(field);\n  }),\n      _useState4 = _slicedToArray(_useState3, 1),\n      formInitialValue = _useState4[0]; // We might have keep state so check for it!\n\n\n  var savedState = formApi.getSavedValue(field); // Create Initial Values\n\n  var initVal;\n  var initTouched; // We do these checks because initial value could be false or zero!!\n\n  if ((keepState || inMultistep) && savedState) {\n    logger(\"Setting field \".concat(name, \"'s kept state\"), savedState);\n    initVal = savedState.value;\n    initTouched = savedState.touched; // Remove the saved state\n\n    formApi.removeSavedState(name);\n  } else if (initialValue != undefined) {\n    initVal = initialValue;\n  } else {\n    initVal = formInitialValue;\n  } // Initialize state\n\n\n  var _useStateWithGetter = useStateWithGetter(initializeValue(initVal, mask, formatter, parser)),\n      _useStateWithGetter2 = _slicedToArray(_useStateWithGetter, 3),\n      value = _useStateWithGetter2[0],\n      setVal = _useStateWithGetter2[1],\n      getTheVal = _useStateWithGetter2[2];\n\n  var _useStateWithGetter3 = useStateWithGetter(validateOnMount ? validate(value) : undefined),\n      _useStateWithGetter4 = _slicedToArray(_useStateWithGetter3, 3),\n      error = _useStateWithGetter4[0],\n      setErr = _useStateWithGetter4[1],\n      getErr = _useStateWithGetter4[2];\n\n  var _useStateWithGetter5 = useStateWithGetter(initTouched),\n      _useStateWithGetter6 = _slicedToArray(_useStateWithGetter5, 3),\n      touched = _useStateWithGetter6[0],\n      setTouch = _useStateWithGetter6[1],\n      getTouch = _useStateWithGetter6[2];\n  /* eslint-disable no-unused-vars */\n\n\n  var _useStateWithGetter7 = useStateWithGetter(0),\n      _useStateWithGetter8 = _slicedToArray(_useStateWithGetter7, 3),\n      cursor = _useStateWithGetter8[0],\n      setCursor = _useStateWithGetter8[1],\n      getCursor = _useStateWithGetter8[2];\n\n  var _useStateWithGetter9 = useStateWithGetter(0),\n      _useStateWithGetter10 = _slicedToArray(_useStateWithGetter9, 3),\n      cursorOffset = _useStateWithGetter10[0],\n      setCursorOffset = _useStateWithGetter10[1],\n      getCursorOffset = _useStateWithGetter10[2];\n\n  var _useState5 = useState(function () {\n    return initializeMask(value, format, parse, formatter);\n  }),\n      _useState6 = _slicedToArray(_useState5, 2),\n      maskedValue = _useState6[0],\n      setMaskedValue = _useState6[1]; // Create then update refs to props\n\n\n  var initialValueRef = useRef(initialValue);\n  var fieldRef = useRef(field);\n  var prevFieldRef = useRef();\n  initialValueRef.current = initialValue;\n  fieldRef.current = field; // Default relevant function\n\n  var relevantFunc = function relevantFunc() {\n    return true;\n  };\n\n  var relevant = function relevant(params) {\n    var rel = userRelevant || relevantFunc;\n    var ff = formApi.getFullField(fieldRef.current) || fieldRef.current;\n    var args = {\n      path: ff,\n      parentPath: ff.replace(/(.*)[.[].*/, '$1'),\n      get: function get(values, path) {\n        return ObjectMap.get(values, path);\n      }\n    };\n\n    if (multistepContext && multistepContext.relevant) {\n      return rel(params, args) && multistepContext.relevant(params, args);\n    }\n\n    return rel(params, args);\n  };\n\n  var _useStateWithGetter11 = useStateWithGetter(relevant(formApi.getValues())),\n      _useStateWithGetter12 = _slicedToArray(_useStateWithGetter11, 3),\n      isRelevant = _useStateWithGetter12[0],\n      setIsRelevant = _useStateWithGetter12[1],\n      getIsRelevant = _useStateWithGetter12[2];\n\n  var multistepRelevant = function multistepRelevant(params) {\n    if (multistepContext && multistepContext.relevant) {\n      return multistepContext.relevant(params);\n    }\n\n    return true;\n  };\n\n  var checkRelevant = function checkRelevant() {\n    var newRel = relevant(formApi.getValues());\n    var curRel = getIsRelevant();\n\n    if (newRel != curRel) {\n      setIsRelevant(newRel);\n    }\n\n    return newRel;\n  };\n\n  useEffect(function () {\n    // Reset if we dont have keep state and relevance changed.\n    if (!isRelevant && !keepState) {\n      fieldApiRef.current.reset();\n    }\n  }, [isRelevant]); // Special getter to support shadow fields\n\n  var getVal = function getVal() {\n    return shadow ? formApi.getDerrivedValue(field) : getTheVal();\n  };\n  /* ---------------------- Setters ---------------------- */\n  // ---- Define set error ----\n\n\n  var setError = function setError(val) {\n    var _ref5 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n        preventUpdate = _ref5.preventUpdate;\n\n    // For multistep forms always set error to undefined when not at that step\n    if (step && formApi.getStep() < step) {\n      logger(\"Setting \".concat(field, \"'s error to undefined as we are not at that step\"));\n      setErr(undefined);\n      updater.setError(fieldId, undefined, !preventUpdate);\n    } else {\n      logger(\"Setting \".concat(field, \"'s error to \").concat(val));\n      setErr(val);\n      updater.setError(fieldId, val, !preventUpdate);\n    }\n  }; // ---- Define set value ----\n\n\n  var setValue = function setValue(val, e) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    logger(\"Setting \".concat(field, \" to \").concat(val)); // Get the most up to date options\n\n    var formOptions = formApi.getOptions(); // Initialize maked value\n\n    var maskedVal = val;\n\n    if (val === '' && !allowEmptyString && !options.allowEmptyString && !formOptions.allowEmptyStrings) {\n      val = undefined;\n    } // Turn string into number for number fields\n\n\n    if ((fieldProps.type === 'number' || fieldType === 'number') && val !== undefined) {\n      val = +val;\n    } // Remember Cursor position!\n\n\n    if (e && e.target && e.target.selectionStart) {\n      setCursor(e.target.selectionStart);\n    } // Call mask if it was passed\n\n\n    if (mask && !maskOnBlur) {\n      maskedVal = mask(val, getCursor());\n      val = mask(val, getCursor());\n    } // Call maskWithCursorOffset if it was passed\n\n\n    if (maskWithCursorOffset && !maskOnBlur) {\n      var res = maskWithCursorOffset(val, getCursor());\n      maskedVal = res.value;\n      val = res.value;\n      setCursorOffset(res.offset);\n    } // Call format and parse if they were passed\n\n\n    if (format && parse) {\n      // Masked value only differs from value when format and parse are used\n      val = parse(val);\n      maskedVal = format(val);\n    } // Call formatter and parser if passed\n\n\n    if (formatter) {\n      var _res = informedFormat(val, formatter);\n\n      setCursorOffset(_res.offset);\n      maskedVal = _res.value;\n      val = maskedVal;\n    } // // Only parse if parser was passed\n\n\n    if (parser) {\n      val = val != null ? parser(val) : val;\n    } // We only need to call validate if the user gave us one\n    // and they want us to validate on change && its not the initial validation\n\n\n    if (validate && validateOnChange && !options.initial) {\n      logger(\"Validating after change \".concat(field, \" \").concat(val));\n      setError(validate(val, formApi.getValues()));\n    } // Now we update the value\n\n\n    setVal(val);\n    setMaskedValue(maskedVal); // If the user passed in onValueChange then call it!\n\n    if (onValueChange) {\n      onValueChange(val);\n    } // Call the updater\n\n\n    updater.setValue(fieldId, val, !options.preventUpdate);\n  }; // ---- Define set touched ----\n\n\n  var setTouched = function setTouched(val, reset) {\n    var _ref6 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},\n        preventUpdate = _ref6.preventUpdate;\n\n    logger(\"Field \".concat(field, \" has been touched\")); // We only need to call validate if the user gave us one\n    // and they want us to validate on blur\n\n    if (validate && validateOnBlur && !reset && val) {\n      logger(\"Validating after blur \".concat(field, \" \").concat(getVal()));\n      setError(validate(getVal(), formApi.getValues()));\n    } // Same for async\n\n\n    if (asyncValidate && asyncValidateOnBlur && !reset && val) {\n      logger(\"Validating async after blur \".concat(field, \" \").concat(getVal()));\n      asyncValidate(getVal(), formApi.getValues());\n    } // Call mask if it was passed\n\n\n    if (mask && maskOnBlur) {\n      // Generate the masked value from the current value\n      var maskedVal = mask(getVal()); // Now we update the value\n\n      setVal(maskedVal);\n      setMaskedValue(maskedVal); // If the user passed in onValueChange then call it!\n\n      if (onValueChange) {\n        onValueChange(maskedVal);\n      } // Call the updater\n\n\n      updater.setValue(fieldId, maskedVal, !preventUpdate);\n    } // Call maskWithCursorOffset if it was passed\n\n\n    if (maskWithCursorOffset && maskOnBlur) {\n      // Generate the mask and offset\n      var res = maskWithCursorOffset(getVal()); // Set the offset\n\n      setCursorOffset(res.offset); // Now we update the value\n\n      setVal(res.value);\n      setMaskedValue(res.value); // If the user passed in onValueChange then call it!\n\n      if (onValueChange) {\n        onValueChange(res.value);\n      } // Call the updater\n\n\n      updater.setValue(fieldId, res.value, !preventUpdate);\n    } // Finally we set touched and call the updater\n\n\n    setTouch(val);\n    updater.setTouched(fieldId, val, !preventUpdate);\n  }; // ---- Define reset ----\n\n\n  var reset = function reset() {\n    var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        preventUpdate = _ref7.preventUpdate;\n\n    var initVal = initializeValue(initialValueRef.current || updater.getInitialValue(fieldRef.current), mask, formatter, parser); // TODO support numbers\n\n    setValue(initVal, null, {\n      initial: true,\n      preventUpdate: preventUpdate\n    }); // Setting somthing to undefined will remove it\n\n    setError(validateOnMount ? validate(initVal) : undefined, {\n      preventUpdate: preventUpdate\n    });\n    setTouched(undefined, true, {\n      preventUpdate: preventUpdate\n    });\n  }; // ---- Define validate ----\n  // Note: it takes values as an optimization for when\n  // the form controller calls it ( dont need to generate all values )\n  // over and over :)\n\n\n  var fieldValidate = function fieldValidate(values) {\n    if (validate) {\n      logger(\"Field validating \".concat(field, \" \").concat(getVal()));\n      setError(validate(getVal(), values || formApi.getValues()));\n    }\n  };\n\n  var fieldAsyncValidate = function fieldAsyncValidate(values) {\n    if (asyncValidate) {\n      logger(\"Field async validating \".concat(field, \" \").concat(getVal()));\n      asyncValidate(getVal(), values || formApi.getValues());\n    }\n  };\n  /* ----------------- Field Api && State ----------------- */\n  // Build the field api\n\n\n  var fieldApi = {\n    setValue: setValue,\n    setTouched: setTouched,\n    setError: setError,\n    reset: reset,\n    validate: fieldValidate,\n    asyncValidate: fieldAsyncValidate,\n    getValue: getVal,\n    getTouched: getTouch,\n    getError: getErr,\n    getIsRelevant: getIsRelevant,\n    getFieldState: function getFieldState() {\n      return {\n        value: getVal(),\n        touched: getTouch()\n      };\n    },\n    relevant: relevant,\n    multistepRelevant: multistepRelevant,\n    checkRelevant: checkRelevant\n  };\n  fieldApiRef.current = fieldApi; // Build the field state\n\n  var fieldState = {\n    value: value,\n    error: error,\n    touched: touched,\n    maskedValue: maskedValue,\n    isRelevant: isRelevant\n  }; // Create shadow state if this is a shadow field\n\n  if (shadow) {\n    fieldState = {\n      error: error,\n      touched: touched\n    };\n  }\n\n  logger('Render', formApi.getFullField(field), fieldState);\n  var internalRef = useRef(null);\n  var ref = React.useMemo(function () {\n    return userRef || internalRef;\n  }, []); // We want to register and deregister this field\n\n  useIsomorphicLayoutEffect(function () {\n    var fullField = formApi.getFullField(fieldRef.current);\n    logger('Register', fieldId, fieldRef.current);\n    fieldObjectRef.current = {\n      field: fullField,\n      fieldId: fieldId,\n      fieldApi: fieldApi,\n      fieldState: fieldState,\n      notify: notify,\n      keepState: keepState,\n      inMultistep: inMultistep,\n      shadow: shadow\n    };\n    updater.register(fieldId, fieldObjectRef.current);\n    return function () {\n      var fullField = formApi.getFullField(fieldRef.current);\n      logger('Deregister', fieldId, fullField);\n      updater.deregister(fieldId);\n    };\n  }, []); // We want to let the controller know of changes on this field when specific props change\n\n  useEffect(function () {\n    var fullField = formApi.getFullField(field);\n\n    if (initialRenerRef.current) {\n      initialRenerRef.current = false;\n    } else {\n      logger('Update', field, inMultistep);\n      fieldObjectRef.current.field = fullField;\n      updater.update(fieldId, fieldObjectRef.current, prevFieldRef.current);\n    }\n\n    return function () {\n      prevFieldRef.current = fullField;\n    };\n  }, [field]); // Maintain cursor position\n\n  useIsomorphicLayoutEffect(function () {\n    if (maintainCursor && ref.current != null && getCursor()) ref.current.selectionEnd = getCursor() + getCursorOffset();\n  }, [value]); // for debugging\n\n  useIsomorphicLayoutEffect(function () {\n    if (debug && ref) {\n      ref.current.style.border = '5px solid orange';\n      setTimeout(function () {\n        ref.current.style.borderWidth = '2px';\n        ref.current.style.borderStyle = 'inset';\n        ref.current.style.borderColor = 'initial';\n        ref.current.style.borderImage = 'initial';\n      }, 500);\n    }\n  }); // This is an awesome optimization!!\n\n  var shouldUpdate = [].concat(_toConsumableArray(Object.values(fieldState)), _toConsumableArray(Object.values(fieldProps)), _toConsumableArray(Object.values(userProps)));\n\n  var render = function render(children) {\n    return useMemo(function () {\n      return isRelevant ? children : null;\n    }, _toConsumableArray(shouldUpdate));\n  }; // Build some setub fields so users can easily intagrate without any hookup code\n\n\n  var name = field;\n  var changeHandler = generateOnChange({\n    fieldType: fieldType,\n    setValue: setValue,\n    onChange: onChange,\n    multiple: multiple,\n    ref: ref\n  });\n  var blurHandler = generateOnBlur({\n    setTouched: setTouched,\n    onBlur: onBlur\n  });\n  var hookedValue = generateValue({\n    fieldType: fieldType,\n    maskedValue: maskedValue,\n    multiple: multiple,\n    value: value\n  });\n  var type = generateFieldType(fieldType);\n  return {\n    fieldState: fieldState,\n    fieldApi: fieldApi,\n    render: render,\n    ref: ref,\n    userProps: _objectSpread2(_objectSpread2({}, userProps), {}, {\n      multiple: multiple,\n      // WE NEED TO PUT THESE BACK!!\n      onChange: onChange,\n      // WE NEED TO PUT THESE BACK!!\n      onBlur: onBlur,\n      // WE NEED TO PUT THESE BACK!!\n      // required // WE NEED TO PUT THESE BACK!!\n      id: userProps.id || fieldId // If user did not pass id we pass fields id\n\n    }),\n    informed: _objectSpread2({\n      name: name,\n      multiple: multiple,\n      onChange: changeHandler,\n      onBlur: blurHandler,\n      value: hookedValue,\n      ref: ref,\n      type: type,\n      id: userProps.id || fieldId\n    }, userProps)\n  };\n}\n\nvar asField = function asField(Component) {\n  var forwardRef = /*#__PURE__*/React.forwardRef(function (props, userRef) {\n    var _useField = useField(props, userRef),\n        fieldState = _useField.fieldState,\n        fieldApi = _useField.fieldApi,\n        render = _useField.render,\n        ref = _useField.ref,\n        userProps = _useField.userProps;\n\n    return render( /*#__PURE__*/React.createElement(Component, _extends({\n      fieldApi: fieldApi,\n      fieldState: fieldState,\n      field: props.field,\n      forwardedRef: ref,\n      debug: props.debug,\n      type: props.type\n    }, userProps)));\n  });\n  forwardRef.displayName = \"asField(\".concat(getChildDisplayName(Component), \")\");\n  return forwardRef;\n};\n\nvar logger$1 = debug('informed:Text' + '\\t');\n\nvar Text = function Text(_ref) {\n  var fieldApi = _ref.fieldApi,\n      fieldState = _ref.fieldState,\n      props = _objectWithoutProperties(_ref, [\"fieldApi\", \"fieldState\"]);\n\n  var maskedValue = fieldState.maskedValue;\n  var setValue = fieldApi.setValue,\n      setTouched = fieldApi.setTouched;\n\n  var _onChange = props.onChange,\n      _onBlur = props.onBlur,\n      field = props.field,\n      initialValue = props.initialValue,\n      forwardedRef = props.forwardedRef,\n      debug = props.debug,\n      label = props.label,\n      title = props.title,\n      id = props.id,\n      rest = _objectWithoutProperties(props, [\"onChange\", \"onBlur\", \"field\", \"initialValue\", \"forwardedRef\", \"debug\", \"label\", \"title\", \"id\"]);\n\n  logger$1('Render', field); // for debugging\n\n  useIsomorphicLayoutEffect(function () {\n    if (debug && forwardedRef) {\n      forwardedRef.current.style.background = 'red';\n      setTimeout(function () {\n        forwardedRef.current.style.background = 'white';\n      }, 500);\n    }\n  });\n  return /*#__PURE__*/React.createElement(React.Fragment, null, label ? /*#__PURE__*/React.createElement(\"label\", {\n    htmlFor: id\n  }, \" \", label, \" \") : null, /*#__PURE__*/React.createElement(\"input\", _extends({}, rest, {\n    id: id,\n    name: field,\n    ref: forwardedRef,\n    value: !maskedValue && maskedValue !== 0 ? '' : maskedValue,\n    onChange: function onChange(e) {\n      setValue(e.target.value, e);\n\n      if (_onChange) {\n        _onChange(e);\n      }\n    },\n    onBlur: function onBlur(e) {\n      setTouched(true);\n\n      if (_onBlur) {\n        _onBlur(e);\n      }\n    }\n  })));\n};\nvar Text$1 = asField(Text);\n\nvar TextArea = function TextArea(_ref) {\n  var fieldApi = _ref.fieldApi,\n      fieldState = _ref.fieldState,\n      props = _objectWithoutProperties(_ref, [\"fieldApi\", \"fieldState\"]);\n\n  var maskedValue = fieldState.maskedValue;\n  var setValue = fieldApi.setValue,\n      setTouched = fieldApi.setTouched;\n\n  var _onChange = props.onChange,\n      _onBlur = props.onBlur,\n      field = props.field,\n      initialValue = props.initialValue,\n      forwardedRef = props.forwardedRef,\n      debug = props.debug,\n      label = props.label,\n      id = props.id,\n      rest = _objectWithoutProperties(props, [\"onChange\", \"onBlur\", \"field\", \"initialValue\", \"forwardedRef\", \"debug\", \"label\", \"id\"]); // for debugging\n\n\n  useIsomorphicLayoutEffect(function () {\n    if (debug && forwardedRef) {\n      forwardedRef.current.style.background = 'red';\n      setTimeout(function () {\n        forwardedRef.current.style.background = 'white';\n      }, 500);\n    }\n  });\n  return /*#__PURE__*/React.createElement(React.Fragment, null, label ? /*#__PURE__*/React.createElement(\"label\", {\n    htmlFor: id\n  }, \" \", label, \" \") : null, /*#__PURE__*/React.createElement(\"textarea\", _extends({}, rest, {\n    id: id,\n    name: field,\n    ref: forwardedRef,\n    value: !maskedValue ? '' : maskedValue,\n    onChange: function onChange(e) {\n      setValue(e.target.value, e);\n\n      if (_onChange) {\n        _onChange(e);\n      }\n    },\n    onBlur: function onBlur(e) {\n      setTouched(true);\n\n      if (_onBlur) {\n        _onBlur(e);\n      }\n    }\n  })));\n};\nvar TextArea$1 = asField(TextArea);\n\nvar logger$2 = debug('informed:Select' + '\\t');\n\nvar Select = function Select(_ref) {\n  var fieldApi = _ref.fieldApi,\n      fieldState = _ref.fieldState,\n      props = _objectWithoutProperties(_ref, [\"fieldApi\", \"fieldState\"]);\n\n  var value = fieldState.value;\n  var setTouched = fieldApi.setTouched;\n\n  var onChange = props.onChange,\n      _onBlur = props.onBlur,\n      field = props.field,\n      initialValue = props.initialValue,\n      options = props.options,\n      children = props.children,\n      forwardedRef = props.forwardedRef,\n      debug = props.debug,\n      multiple = props.multiple,\n      label = props.label,\n      id = props.id,\n      rest = _objectWithoutProperties(props, [\"onChange\", \"onBlur\", \"field\", \"initialValue\", \"options\", \"children\", \"forwardedRef\", \"debug\", \"multiple\", \"label\", \"id\"]);\n\n  var selectRef = useRef();\n\n  var handleChange = function handleChange(e) {\n    var selected = Array.from((forwardedRef || selectRef).current).filter(function (option) {\n      return option.selected;\n    }).map(function (option) {\n      return option.value;\n    });\n    fieldApi.setValue(multiple ? selected : selected[0] || '');\n\n    if (onChange && e) {\n      onChange(e);\n    }\n  }; // for debugging\n\n\n  useIsomorphicLayoutEffect(function () {\n    if (debug && forwardedRef) {\n      forwardedRef.current.style.background = 'red';\n      setTimeout(function () {\n        forwardedRef.current.style.background = 'white';\n      }, 500);\n    }\n  });\n  logger$2('Render', field, value);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, label ? /*#__PURE__*/React.createElement(\"label\", {\n    htmlFor: id\n  }, \" \", label, \" \") : null, /*#__PURE__*/React.createElement(\"select\", _extends({}, rest, {\n    id: id,\n    multiple: multiple,\n    name: field,\n    ref: forwardedRef || selectRef,\n    value: value || (multiple ? [] : ''),\n    onChange: handleChange,\n    onBlur: function onBlur(e) {\n      setTouched(true);\n\n      if (_onBlur) {\n        _onBlur(e);\n      }\n    }\n  }), options ? options.map(function (option) {\n    return /*#__PURE__*/React.createElement(\"option\", {\n      key: option.value,\n      value: option.value,\n      disabled: option.disabled\n    }, option.label);\n  }) : children));\n};\nvar Select$1 = asField(Select);\n\nvar Checkbox = function Checkbox(_ref) {\n  var fieldApi = _ref.fieldApi,\n      fieldState = _ref.fieldState,\n      props = _objectWithoutProperties(_ref, [\"fieldApi\", \"fieldState\"]);\n\n  var value = fieldState.value;\n  var setValue = fieldApi.setValue,\n      setTouched = fieldApi.setTouched;\n\n  var _onChange = props.onChange,\n      _onBlur = props.onBlur,\n      field = props.field,\n      initialValue = props.initialValue,\n      debug = props.debug,\n      forwardedRef = props.forwardedRef,\n      id = props.id,\n      label = props.label,\n      rest = _objectWithoutProperties(props, [\"onChange\", \"onBlur\", \"field\", \"initialValue\", \"debug\", \"forwardedRef\", \"id\", \"label\"]);\n\n  return /*#__PURE__*/React.createElement(React.Fragment, null, label ? /*#__PURE__*/React.createElement(\"label\", {\n    htmlFor: id\n  }, \" \", label, \" \") : null, /*#__PURE__*/React.createElement(\"input\", _extends({}, rest, {\n    id: id,\n    name: field,\n    ref: forwardedRef,\n    checked: !!value,\n    onChange: function onChange(e) {\n      setValue(e.target.checked);\n\n      if (_onChange) {\n        _onChange(e);\n      }\n    },\n    onBlur: function onBlur(e) {\n      setTouched(true);\n\n      if (_onBlur) {\n        _onBlur(e);\n      }\n    },\n    type: \"checkbox\"\n  })));\n};\nvar Checkbox$1 = asField(Checkbox);\n\nvar withRadioGroup = function withRadioGroup(Component) {\n  return /*#__PURE__*/React.forwardRef(function (props, ref) {\n    return /*#__PURE__*/React.createElement(GroupContext.Consumer, null, function (_ref) {\n      var radioGroupApi = _ref.radioGroupApi,\n          radioGroupState = _ref.radioGroupState;\n      return /*#__PURE__*/React.createElement(Component, _extends({\n        radioGroupApi: radioGroupApi,\n        radioGroupState: radioGroupState,\n        ref: ref\n      }, props));\n    });\n  });\n};\n\nvar Radio = function Radio(_ref) {\n  var radioGroupApi = _ref.radioGroupApi,\n      radioGroupState = _ref.radioGroupState,\n      props = _objectWithoutProperties(_ref, [\"radioGroupApi\", \"radioGroupState\"]);\n\n  var groupValue = radioGroupState.value;\n  var setValue = radioGroupApi.setValue,\n      setTouched = radioGroupApi.setTouched,\n      groupOnChange = radioGroupApi.onChange,\n      groupOnBlur = radioGroupApi.onBlur;\n\n  var value = props.value,\n      _onChange = props.onChange,\n      _onBlur = props.onBlur,\n      field = props.field,\n      initialValue = props.initialValue,\n      forwardedRef = props.forwardedRef,\n      rest = _objectWithoutProperties(props, [\"value\", \"onChange\", \"onBlur\", \"field\", \"initialValue\", \"forwardedRef\"]);\n\n  return /*#__PURE__*/React.createElement(\"input\", _extends({}, rest, {\n    name: field,\n    ref: forwardedRef,\n    value: value,\n    checked: groupValue === value,\n    onChange: function onChange(e) {\n      if (!e.target.checked) {\n        return;\n      }\n\n      setValue(value);\n\n      if (_onChange) {\n        _onChange(e);\n      }\n\n      if (groupOnChange) {\n        groupOnChange(e);\n      }\n    },\n    onBlur: function onBlur(e) {\n      setTouched(true);\n\n      if (_onBlur) {\n        _onBlur(e);\n      }\n\n      if (groupOnBlur) {\n        groupOnBlur(e);\n      }\n    },\n    type: \"radio\"\n  }));\n};\nvar Radio$1 = withRadioGroup(Radio);\n\nvar RadioGroup = /*#__PURE__*/function (_Component) {\n  _inherits(RadioGroup, _Component);\n\n  var _super = _createSuper(RadioGroup);\n\n  function RadioGroup() {\n    _classCallCheck(this, RadioGroup);\n\n    return _super.apply(this, arguments);\n  }\n\n  _createClass(RadioGroup, [{\n    key: \"render\",\n    value: function render() {\n      var _this$props = this.props,\n          options = _this$props.options,\n          children = _this$props.children;\n      return /*#__PURE__*/React.createElement(GroupContext.Provider, {\n        value: this.groupContext\n      }, options ? options.map(function (option) {\n        return /*#__PURE__*/React.createElement(\"label\", {\n          key: option.value\n        }, option.label, \" \", /*#__PURE__*/React.createElement(Radio$1, {\n          value: option.value\n        }));\n      }) : children);\n    }\n  }, {\n    key: \"groupContext\",\n    get: function get() {\n      return {\n        radioGroupApi: _objectSpread2(_objectSpread2({}, this.props.fieldApi), {}, {\n          onChange: this.props.onChange,\n          onBlur: this.props.onBlur\n        }),\n        radioGroupState: this.props.fieldState\n      };\n    }\n  }]);\n\n  return RadioGroup;\n}(Component);\nvar RadioGroup$1 = asField(RadioGroup);\n\nfunction useArrayFieldApi() {\n  return useContext(ArrayFieldApiContext);\n}\n\nvar AddButton = function AddButton() {\n  var _useArrayFieldApi = useArrayFieldApi(),\n      add = _useArrayFieldApi.add;\n\n  return /*#__PURE__*/React.createElement(\"button\", {\n    onClick: function onClick() {\n      add();\n    },\n    type: \"button\"\n  }, \"Add\");\n};\n\nfunction useArrayFieldItemApi() {\n  return useContext(ArrayFieldItemApiContext);\n}\n\nvar AddButton$1 = function AddButton() {\n  var _useArrayFieldItemApi = useArrayFieldItemApi(),\n      remove = _useArrayFieldItemApi.remove;\n\n  return /*#__PURE__*/React.createElement(\"button\", {\n    onClick: function onClick() {\n      remove();\n    },\n    type: \"button\"\n  }, \"Remove\");\n};\n\nvar logger$3 = debug('informed:useArrayField' + '\\t');\n\nvar useArrayField = function useArrayField(_ref) {\n  var field = _ref.field,\n      initialValue = _ref.initialValue,\n      validate = _ref.validate,\n      arrayFieldApiRef = _ref.arrayFieldApiRef,\n      props = _objectWithoutProperties(_ref, [\"field\", \"initialValue\", \"validate\", \"arrayFieldApiRef\"]);\n\n  // Reference to the form Api\n  var formApi = useFormApi(); // Keep track of fields that belong to this array field\n\n  var _useState = useState(new Map()),\n      _useState2 = _slicedToArray(_useState, 1),\n      fieldsById = _useState2[0]; // Grab the form register context\n\n\n  var updater = useContext(FormRegisterContext); // May be scoped so get full field name!!\n\n  var fullField = formApi.getFullField(field);\n  var initialVals = updater.getInitialValue(field) || initialValue || []; // TODO throw error if initial value and its not array\n  // If keep state was passed into the child inputs we need to maintain the length of\n  // keys, in order to do so we grab the value from informeds api\n\n  var keptValues = formApi.getSavedValue(fullField) && formApi.getSavedValue(fullField).value;\n\n  var _useStateWithGetter = useStateWithGetter(keptValues || initialVals),\n      _useStateWithGetter2 = _slicedToArray(_useStateWithGetter, 3),\n      initialValues = _useStateWithGetter2[0],\n      setInitialValues = _useStateWithGetter2[1],\n      getInitialValues = _useStateWithGetter2[2];\n\n  var initialKeys = initialValues ? initialValues.map(function () {\n    return uuidv4();\n  }) : [];\n\n  var _useStateWithGetter3 = useStateWithGetter(initialKeys),\n      _useStateWithGetter4 = _slicedToArray(_useStateWithGetter3, 3),\n      keys = _useStateWithGetter4[0],\n      setKeys = _useStateWithGetter4[1],\n      getKeys = _useStateWithGetter4[2];\n\n  var validateWithLength = useMemo(function () {\n    return function (value, values) {\n      var length = getKeys() == null ? 0 : getKeys().length;\n      return validate ? validate(value, length, values) : undefined;\n    };\n  }); // Register shadow field\n\n  var _useField = useField(_objectSpread2({\n    field: field,\n    validate: validate ? validateWithLength : undefined,\n    shadow: true\n  }, props)),\n      fieldApi = _useField.fieldApi; // Register for events\n\n\n  useIsomorphicLayoutEffect(function () {\n    // Define event handler\n    var onChangeHandler = function onChangeHandler(fieldName) {\n      // Dont do anythign if we updated\n      if (fieldName === fullField) {\n        return;\n      }\n\n      logger$3(\"\".concat(fullField, \" changed\")); // determine if one of our array children triggered this change\n\n      if (RegExp(\"\".concat(fullField, \"\\\\[[0-9]+\\\\]\")).test(fieldName)) {\n        // If it was we need to call validate\n        fieldApi.validate();\n      }\n    }; // Register for events\n\n\n    formApi.emitter.on('value', onChangeHandler); // Unregister events\n\n    return function () {\n      formApi.emitter.removeListener('value', onChangeHandler);\n    };\n  }, [field]);\n\n  var _remove = function remove(i) {\n    // Notify form to expect removal on this field\n    logger$3('EXPECTING REMOVAL OF', \"\".concat(field, \"[\").concat(i, \"] and \").concat(field, \"[\").concat(keys.length - 1, \"]\"));\n    updater.expectRemoval(\"\".concat(field, \"[\").concat(i, \"]\"));\n    updater.expectRemoval(\"\".concat(field, \"[\").concat(keys.length - 1, \"]\")); // Remove the key\n\n    var newKeys = keys.slice(0, i).concat(keys.slice(i + 1, keys.length));\n    setKeys(newKeys); // Remove the initial value ( user wanted to get rid of that input )\n\n    var initVals = getInitialValues();\n    var newInitialValues = initVals.slice(0, i).concat(initVals.slice(i + 1, initVals.length));\n    setInitialValues(newInitialValues); //formApi.setInitialValue(field, newInitialValues);\n  };\n\n  var swap = function swap(a, b) {\n    logger$3('Swapping', \"\".concat(field, \"[\").concat(a, \"] and \").concat(field, \"[\").concat(b, \"]\")); // Swap the keys\n\n    var newKeys = _toConsumableArray(keys);\n\n    if (keys[a] && keys[b]) {\n      newKeys[a] = keys[b];\n      newKeys[b] = keys[a];\n    } else {\n      // eslint-disable-next-line no-console\n      console.warn(\"Attempted to swap \".concat(a, \" with \").concat(b, \" but one of them does not exist :(\"));\n    }\n\n    setKeys(newKeys);\n  };\n\n  var add = function add() {\n    keys.push(uuidv4());\n    setKeys(_toConsumableArray(keys));\n  };\n\n  var addWithInitialValue = function addWithInitialValue(initialValue) {\n    keys.push(uuidv4());\n    setKeys(_toConsumableArray(keys));\n\n    var newInitialValues = _toConsumableArray(getInitialValues());\n\n    newInitialValues[keys.length - 1] = initialValue;\n    setInitialValues(newInitialValues);\n  };\n\n  var reset = function reset() {\n    // When resetting we reset to the users initial value not the one tracked by this hook\n    var initVals = updater.getInitialValue(field) || initialValue || []; // Set our initial values back to what the user set at beginning\n\n    setInitialValues(initVals); // Build a new set of keys because everything is new !!!\n\n    var resetKeys = initVals ? initVals.map(function () {\n      return uuidv4();\n    }) : []; // Finally set that shit !\n\n    setKeys(resetKeys);\n  };\n\n  var fields = keys.map(function (key, i) {\n    var arrayFieldItemApi = {\n      remove: function remove() {\n        return _remove(i);\n      }\n    };\n    var arrayFieldItemState = {\n      initialValue: initialValues && initialValues[i],\n      key: key,\n      field: \"\".concat(field, \"[\").concat(i, \"]\"),\n      index: i\n    };\n    return _objectSpread2(_objectSpread2({\n      arrayFieldItemApi: arrayFieldItemApi,\n      arrayFieldItemState: arrayFieldItemState\n    }, arrayFieldItemApi), arrayFieldItemState);\n  });\n  var arrayFieldApi = {\n    add: add,\n    swap: swap,\n    addWithInitialValue: addWithInitialValue,\n    reset: reset\n  };\n\n  if (arrayFieldApiRef) {\n    arrayFieldApiRef.current = arrayFieldApi;\n  }\n\n  var arrayFieldState = {\n    fields: fields,\n    field: field\n  }; // Wrap the updater to update array fields references\n\n  var wrappedUpdator = _objectSpread2(_objectSpread2({}, updater), {}, {\n    register: function register(id, fld) {\n      fieldsById.set(id, fld);\n\n      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n        args[_key - 2] = arguments[_key];\n      }\n\n      updater.register.apply(updater, [id, fld].concat(args));\n    },\n    deregister: function deregister(id) {\n      fieldsById[\"delete\"](id);\n\n      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        args[_key2 - 1] = arguments[_key2];\n      }\n\n      updater.deregister.apply(updater, [id].concat(args));\n    },\n    getInitialValue: function getInitialValue(fieldName) {\n      // If we are getting initial value and its for this field return that\n      if (RegExp(\"\".concat(fullField, \"\\\\[[0-9]+\\\\]\")).test(fieldName)) {\n        var path = fieldName.replace(field, '');\n        var v = ObjectMap.get(getInitialValues(), path);\n        logger$3(\"Resetting \".concat(path, \" to \").concat(v));\n        return v;\n      }\n\n      return updater.getInitialValue(fieldName);\n    }\n  });\n\n  var render = function render(children) {\n    return /*#__PURE__*/React.createElement(FormRegisterContext.Provider, {\n      value: wrappedUpdator\n    }, /*#__PURE__*/React.createElement(ArrayFieldApiContext.Provider, {\n      value: arrayFieldApi\n    }, /*#__PURE__*/React.createElement(ArrayFieldStateContext.Provider, {\n      value: arrayFieldState\n    }, children)));\n  };\n\n  return {\n    render: render,\n    add: add,\n    swap: swap,\n    addWithInitialValue: addWithInitialValue,\n    fields: fields,\n    arrayFieldState: arrayFieldState,\n    arrayFieldApi: arrayFieldApi,\n    field: field\n  };\n};\n\nvar buildScopedFormApi = function buildScopedFormApi(scope, formApi) {\n  return _objectSpread2(_objectSpread2({}, formApi), {}, {\n    getValue: function getValue(field) {\n      return formApi.getValue(\"\".concat(scope, \".\").concat(field));\n    },\n    getTouched: function getTouched(field) {\n      return formApi.getTouched(\"\".concat(scope, \".\").concat(field));\n    },\n    getError: function getError(field) {\n      return formApi.getError(\"\".concat(scope, \".\").concat(field));\n    },\n    setValue: function setValue(field, value) {\n      return formApi.setValue(\"\".concat(scope, \".\").concat(field), value);\n    },\n    setTouched: function setTouched(field, value) {\n      return formApi.setTouched(\"\".concat(scope, \".\").concat(field), value);\n    },\n    setError: function setError(field, value) {\n      return formApi.setError(\"\".concat(scope, \".\").concat(field), value);\n    },\n    getInitialValue: function getInitialValue(field) {\n      return formApi.getInitialValue(\"\".concat(scope, \".\").concat(field));\n    },\n    getFullField: function getFullField(field) {\n      return \"\".concat(formApi.getFullField(scope), \".\").concat(field);\n    }\n  });\n};\n\nfunction useScopedApi(scope) {\n  var formApi = useFormApi(); // VERY important to memoize the builder!\n\n  var scopedFormApi = useMemo(function () {\n    return buildScopedFormApi(scope, formApi);\n  }, [scope]);\n  return scopedFormApi;\n}\n\nfunction useFormState() {\n  var formState = useContext(FormStateContext);\n  return formState;\n}\n\nvar Relevant = function Relevant(_ref) {\n  var when = _ref.when,\n      children = _ref.children;\n  var formState = useFormState();\n  var isRelevant = when(formState);\n\n  if (isRelevant) {\n    return children;\n  }\n\n  return null;\n};\n\nvar ArrayField = function ArrayField(_ref) {\n  var relevant = _ref.relevant,\n      field = _ref.field,\n      props = _objectWithoutProperties(_ref, [\"relevant\", \"field\"]);\n\n  // Need to get formApi to have consistant interface for relevant function\n  var formApi = useFormApi();\n\n  if (relevant) {\n    var ff = formApi.getFullField(field);\n    var args = {\n      path: ff,\n      parentPath: ff.replace(/(.*)[.[].*/, '$1'),\n      get: function get(values, path) {\n        return ObjectMap.get(values, path);\n      }\n    };\n\n    var when = function when(_ref2) {\n      var values = _ref2.values;\n      return relevant(values, args);\n    };\n\n    return /*#__PURE__*/React.createElement(Relevant, {\n      when: when\n    }, /*#__PURE__*/React.createElement(ArrayFieldWrapper, _extends({\n      field: field\n    }, props)));\n  } else {\n    return /*#__PURE__*/React.createElement(ArrayFieldWrapper, _extends({\n      field: field\n    }, props));\n  }\n};\n\nvar ArrayFieldWrapper = function ArrayFieldWrapper(_ref3) {\n  var children = _ref3.children,\n      props = _objectWithoutProperties(_ref3, [\"children\"]);\n\n  var _useArrayField = useArrayField(props),\n      render = _useArrayField.render,\n      arrayFieldState = _useArrayField.arrayFieldState,\n      arrayFieldApi = _useArrayField.arrayFieldApi,\n      field = _useArrayField.field;\n\n  if (typeof children === 'function') {\n    return render(children(_objectSpread2(_objectSpread2({\n      field: field,\n      arrayFieldApi: arrayFieldApi,\n      arrayFieldState: arrayFieldState\n    }, arrayFieldApi), arrayFieldState)));\n  }\n\n  return render(children);\n};\n\nvar ArrayFieldItem = function ArrayFieldItem(_ref4) {\n  var arrayFieldItemState = _ref4.arrayFieldItemState,\n      arrayFieldItemApi = _ref4.arrayFieldItemApi,\n      children = _ref4.children;\n  // Grab the form register context\n  var updater = useContext(FormRegisterContext); // Grab the form state\n\n  var formApi = useFormApi(); // A little trick I learned in nam to trigger rerender\n\n  var _useState = useState(0),\n      _useState2 = _slicedToArray(_useState, 2),\n      state = _useState2[0],\n      setState = _useState2[1]; // Keep track of fields that belong to this array field\n\n\n  var _useState3 = useState(new Map()),\n      _useState4 = _slicedToArray(_useState3, 1),\n      fieldsById = _useState4[0]; // Get this items field\n\n\n  var field = arrayFieldItemState.field; // Create scoped api\n\n  var scopedApi = useScopedApi(field); // State generation function\n\n  var getState = function getState() {\n    var _formApi$getState = formApi.getState(),\n        values = _formApi$getState.values,\n        errors = _formApi$getState.errors,\n        touched = _formApi$getState.touched; // Get this fields state\n\n\n    var itemState = {\n      values: ObjectMap.get(values, field),\n      errors: ObjectMap.get(errors, field),\n      touched: ObjectMap.get(touched, field)\n    };\n    return itemState;\n  }; // Register for events for rerenders!\n\n\n  useEffect(function () {\n    // Define event handler\n    var onChangeHandler = function onChangeHandler(fieldName) {\n      // Example foo.bar.baz[3].baz >>>> foo.bar.baz[3]\n      var magicValue = fieldName.slice(0, fieldName.lastIndexOf('[') != -1 ? fieldName.lastIndexOf(']') + 1 : fieldName.length); // This field updated so trigger rerender\n\n      if (magicValue === field) {\n        setState(Math.random());\n      }\n    }; // Register for events\n\n\n    formApi.emitter.on('value', onChangeHandler); // Unregister events\n\n    return function () {\n      formApi.emitter.removeListener('value', onChangeHandler);\n    };\n  }, [field]); // Resets all fields in this item\n\n  var reset = function reset() {\n    fieldsById.forEach(function (fld) {\n      fld.fieldApi.reset();\n    });\n  }; // Generate the item state\n\n\n  var itemState = getState(); // Wrap the updater to update array fields references\n\n  var wrappedUpdator = _objectSpread2(_objectSpread2({}, updater), {}, {\n    register: function register(id, fld, initialRender) {\n      fieldsById.set(id, fld);\n      updater.register(id, fld, initialRender);\n    },\n    deregister: function deregister(id) {\n      fieldsById[\"delete\"](id);\n\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      updater.deregister.apply(updater, [id].concat(args));\n    }\n  });\n\n  var arrayFieldItemApiValue = _objectSpread2(_objectSpread2(_objectSpread2({}, arrayFieldItemApi), scopedApi), {}, {\n    reset: reset\n  });\n\n  var arrayFieldItemStateValue = _objectSpread2(_objectSpread2({}, arrayFieldItemState), itemState);\n\n  if (typeof children === 'function') {\n    return /*#__PURE__*/React.createElement(FormRegisterContext.Provider, {\n      value: wrappedUpdator\n    }, /*#__PURE__*/React.createElement(ArrayFieldItemApiContext.Provider, {\n      value: arrayFieldItemApiValue\n    }, /*#__PURE__*/React.createElement(ArrayFieldItemStateContext.Provider, {\n      value: arrayFieldItemStateValue\n    }, children(_objectSpread2(_objectSpread2({\n      arrayFieldItemApi: arrayFieldItemApiValue,\n      arrayFieldItemState: arrayFieldItemStateValue\n    }, arrayFieldItemApiValue), arrayFieldItemStateValue)))));\n  }\n\n  return /*#__PURE__*/React.createElement(FormRegisterContext.Provider, {\n    value: wrappedUpdator\n  }, /*#__PURE__*/React.createElement(ArrayFieldItemApiContext.Provider, {\n    value: arrayFieldItemApiValue\n  }, /*#__PURE__*/React.createElement(ArrayFieldItemStateContext.Provider, {\n    value: arrayFieldItemStateValue\n  }, children)));\n};\n\nArrayField.Items = function (_ref5) {\n  var children = _ref5.children;\n\n  var _useContext = useContext(ArrayFieldStateContext),\n      fields = _useContext.fields;\n\n  return fields.map(function (_ref6) {\n    var arrayFieldItemState = _ref6.arrayFieldItemState,\n        arrayFieldItemApi = _ref6.arrayFieldItemApi;\n    var key = arrayFieldItemState.key;\n    return /*#__PURE__*/React.createElement(ArrayFieldItem, {\n      key: key,\n      arrayFieldItemApi: arrayFieldItemApi,\n      arrayFieldItemState: arrayFieldItemState\n    }, children);\n  });\n};\n\nvar FormComponents = function FormComponents(_ref) {\n  var components = _ref.components;\n\n  // Get the field map off the forms context\n  var _useContext = useContext(FormRegisterContext),\n      fieldMap = _useContext.fieldMap;\n\n  if (!components) return null;\n  return components.map(function (comp, i) {\n    var componentType = comp['ui:control'];\n    var Component = fieldMap[componentType];\n    return /*#__PURE__*/React.createElement(Component, {\n      key: \"ui-comp-\".concat(i)\n    });\n  });\n};\n\nvar logger$4 = debug('informed:FormFields' + '\\t');\n\nvar FormFields = function FormFields(_ref) {\n  var schema = _ref.schema,\n      prefix = _ref.prefix,\n      onlyValidateSchema = _ref.onlyValidateSchema;\n\n  // Get the field map off the forms context\n  var _useContext = useContext(FormRegisterContext),\n      fieldMap = _useContext.fieldMap; // Get fields from scheama\n\n\n  var fields = useMemo(function () {\n    var schemaFields = computeFieldsFromSchema(schema, onlyValidateSchema, prefix);\n    var mapedFields = schemaFields.map(function (schemaField, i) {\n      var field = schemaField.field,\n          props = schemaField.props,\n          type = schemaField.type,\n          properties = schemaField.properties,\n          items = schemaField.items,\n          componentType = schemaField.componentType,\n          uiBefore = schemaField.uiBefore,\n          uiAfter = schemaField.uiAfter,\n          allOf = schemaField.allOf;\n      var Component = fieldMap[componentType]; // console.log('WTF', schemaField);\n\n      logger$4('Rendering Field', field, schemaField); // Scope for nested\n\n      if (!Component && type === 'object' && properties) {\n        return /*#__PURE__*/React.createElement(FormFields, {\n          schema: schemaField,\n          prefix: field,\n          key: \"ScheamField-\".concat(i)\n        });\n      } // Array field for array ( if none was provided use our default )\n\n\n      if (!Component && type === 'array' && items) {\n        return /*#__PURE__*/React.createElement(ArrayField$1, _extends({\n          key: \"ScheamField-\".concat(i),\n          field: field,\n          items: items,\n          uiBefore: uiBefore,\n          uiAfter: uiAfter\n        }, props));\n      } // User created custom array field\n\n\n      if (Component && componentType === 'array' && items && type === 'array') {\n        return /*#__PURE__*/React.createElement(Component, _extends({\n          key: \"ScheamField-\".concat(i),\n          field: field,\n          items: items,\n          uiBefore: uiBefore,\n          uiAfter: uiAfter\n        }, props));\n      } // For conditionals\n\n\n      if (componentType === 'conditionals') {\n        return allOf.map(function (conditional) {\n          // Example then ( its a subschema )\n          // then: {\n          //   properties: {\n          //     spouse: {\n          //       type: 'string',\n          //       title: 'Spouse name',\n          //       'ui:control': 'input'\n          //     }\n          //   }\n          // }\n          var subSchema = conditional.then; // Turn the if into a when function for informed\n          // Example if condition\n          // if: {\n          //   properties: {\n          //     married: { const: 'yes' }\n          //   },\n          //   required: ['married']\n          // },\n\n          var conditions = conditional[\"if\"].properties;\n\n          var when = function when(_ref2) {\n            var values = _ref2.values;\n            // Example key \"married, Example condition: \"{ const: 'yes' }\"\n            return Object.keys(conditions).every(function (key) {\n              var condition = conditions[key]; // values.married === 'yes'\n\n              return values[key] === condition[\"const\"];\n            });\n          };\n\n          return /*#__PURE__*/React.createElement(Relevant, {\n            key: \"ScheamField-\".concat(i),\n            when: when\n          }, /*#__PURE__*/React.createElement(FormFields, {\n            schema: subSchema\n          }));\n        });\n      } // If no com ret null ( dont render )\n\n\n      if (!Component) {\n        return null;\n      }\n\n      return /*#__PURE__*/React.createElement(Component, _extends({\n        key: \"ScheamField-\".concat(i),\n        field: field\n      }, props));\n    });\n    return mapedFields;\n  }, [schema, prefix]);\n  return fields;\n};\n\nvar ArrayField$1 = function ArrayField$1(_ref) {\n  var field = _ref.field,\n      items = _ref.items,\n      uiBefore = _ref.uiBefore,\n      uiAfter = _ref.uiAfter,\n      props = _objectWithoutProperties(_ref, [\"field\", \"items\", \"uiBefore\", \"uiAfter\"]);\n\n  return /*#__PURE__*/React.createElement(ArrayField, _extends({\n    field: field\n  }, props), /*#__PURE__*/React.createElement(FormComponents, {\n    components: uiBefore\n  }), /*#__PURE__*/React.createElement(ArrayField.Items, null, function (_ref2) {\n    var field = _ref2.field;\n    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(FormComponents, {\n      components: items['ui:before']\n    }), /*#__PURE__*/React.createElement(FormFields, {\n      schema: items,\n      prefix: field\n    }), /*#__PURE__*/React.createElement(FormComponents, {\n      components: items['ui:after']\n    }));\n  }), /*#__PURE__*/React.createElement(FormComponents, {\n    components: uiAfter\n  }));\n};\n\nvar defaultFieldMap = {\n  select: Select$1,\n  input: Text$1,\n  textarea: TextArea$1,\n  checkbox: Checkbox$1,\n  radio: RadioGroup$1,\n  add: AddButton,\n  remove: AddButton$1,\n  array: ArrayField$1\n};\n\nvar debug$2 = debug('informed:Controller' + '\\t');\n\nvar isExpected = function isExpected(path, expectedRemovals) {\n  var includedKey = Object.keys(expectedRemovals).find(function (key) {\n    return path.includes(key);\n  });\n  if (!includedKey) return;\n  var start = path.slice(0, includedKey.length);\n  return start === includedKey;\n};\n\nvar noop = function noop() {};\n\nvar FormController = /*#__PURE__*/function (_EventEmitter) {\n  _inherits(FormController, _EventEmitter);\n\n  var _super = _createSuper(FormController);\n\n  function FormController() {\n    var _this;\n\n    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, FormController);\n\n    // Dont forget to call super! :)\n    _this = _super.call(this);\n    _this.options = options;\n    var ajv = options.ajv,\n        schema = options.schema,\n        fieldMap = options.fieldMap; // Debounced change\n    // const change = () => {\n    //   this.rebuildState();\n    //   this.emit('change');\n    // };\n    // this.change = debounce(change, 250);\n    // Create new ajv instance if passed\n\n    _this.ajv = ajv ? new ajv({\n      allErrors: true\n    }) : null;\n    _this.ajvValidate = ajv ? _this.ajv.compile(schema) : null; // Add field map ( defaults to our field map )\n\n    _this.fieldMap = fieldMap || defaultFieldMap; // Map will store all fields by id\n    // Key => uuid\n    // Val => fieldObj\n    // Why? so the form can control the fields!\n\n    _this.fieldsById = new Map(); // Map will store all fields by name\n    // Key => fieldName - example: \"foo.bar[3].baz\"\n    // Val => fieldObj\n    // Why? so the form can control the fields!\n\n    _this.fieldsByName = {\n      get: function get(name) {\n        var fieldByName; // TODO speed this up maybe\n\n        _this.fieldsById.forEach(function (value) {\n          if (value && value.field === name) {\n            fieldByName = value;\n          }\n        });\n\n        return fieldByName;\n      }\n    }; // Map to store whos on the screen\n\n    _this.onScreen = {}; // Map to store fields being removed\n\n    _this.expectedRemovals = {};\n    _this.pulledOut = {}; // Map of saved values\n\n    _this.savedValues = {}; // Initialize the controller state\n\n    _this.state = {\n      pristine: true,\n      dirty: false,\n      invalid: false,\n      submits: 0,\n      step: 0,\n      validating: 0,\n      submitting: false,\n      values: {},\n      errors: {},\n      touched: {}\n    }; // Initialize a dummy field ( see getField for example use )\n\n    _this.dummyField = {\n      fieldApi: {\n        setValue: noop,\n        setTouched: noop,\n        setError: noop,\n        reset: noop,\n        validate: noop,\n        getValue: noop,\n        getTouched: noop,\n        getError: noop,\n        getFieldState: noop,\n        checkRelevant: noop\n      }\n    }; // Bind functions that will be called externally\n\n    _this.deregister = _this.deregister.bind(_assertThisInitialized(_this));\n    _this.register = _this.register.bind(_assertThisInitialized(_this));\n    _this.getValue = _this.getValue.bind(_assertThisInitialized(_this));\n    _this.getTouched = _this.getTouched.bind(_assertThisInitialized(_this));\n    _this.getError = _this.getError.bind(_assertThisInitialized(_this));\n    _this.getErrors = _this.getErrors.bind(_assertThisInitialized(_this));\n    _this.setValue = _this.setValue.bind(_assertThisInitialized(_this));\n    _this.getValues = _this.getValues.bind(_assertThisInitialized(_this));\n    _this.getStep = _this.getStep.bind(_assertThisInitialized(_this));\n    _this.setStep = _this.setStep.bind(_assertThisInitialized(_this));\n    _this.back = _this.back.bind(_assertThisInitialized(_this));\n    _this.next = _this.next.bind(_assertThisInitialized(_this));\n    _this.setCurrent = _this.setCurrent.bind(_assertThisInitialized(_this));\n    _this.setTouched = _this.setTouched.bind(_assertThisInitialized(_this));\n    _this.setError = _this.setError.bind(_assertThisInitialized(_this));\n    _this.setFormError = _this.setFormError.bind(_assertThisInitialized(_this));\n    _this.submitForm = _this.submitForm.bind(_assertThisInitialized(_this));\n    _this.reset = _this.reset.bind(_assertThisInitialized(_this));\n    _this.update = _this.update.bind(_assertThisInitialized(_this));\n    _this.validate = _this.validate.bind(_assertThisInitialized(_this));\n    _this.screenValid = _this.screenValid.bind(_assertThisInitialized(_this));\n    _this.keyDown = _this.keyDown.bind(_assertThisInitialized(_this));\n    _this.getField = _this.getField.bind(_assertThisInitialized(_this));\n    _this.getInitialValue = _this.getInitialValue.bind(_assertThisInitialized(_this));\n    _this.setInitialValue = _this.setInitialValue.bind(_assertThisInitialized(_this));\n    _this.getOptions = _this.getOptions.bind(_assertThisInitialized(_this));\n    _this.getFormState = _this.getFormState.bind(_assertThisInitialized(_this));\n    _this.expectRemoval = _this.expectRemoval.bind(_assertThisInitialized(_this));\n    _this.getSavedValue = _this.getSavedValue.bind(_assertThisInitialized(_this));\n    _this.removeSavedState = _this.removeSavedState.bind(_assertThisInitialized(_this));\n    _this.getDerrivedValue = _this.getDerrivedValue.bind(_assertThisInitialized(_this));\n    _this.setValues = _this.setValues.bind(_assertThisInitialized(_this));\n    _this.resetField = _this.resetField.bind(_assertThisInitialized(_this));\n    _this.fieldExists = _this.fieldExists.bind(_assertThisInitialized(_this));\n    _this.validateField = _this.validateField.bind(_assertThisInitialized(_this));\n    _this.notify = _this.notify.bind(_assertThisInitialized(_this));\n    _this.validating = _this.validating.bind(_assertThisInitialized(_this));\n    _this.validated = _this.validated.bind(_assertThisInitialized(_this)); // this.change = this.change.bind(this);\n    // this.clear = this.clear.bind(this);\n    // Updater will be used by fields to update and register\n\n    _this.updater = {\n      register: _this.register,\n      deregister: _this.deregister,\n      getField: _this.getField,\n      update: _this.update,\n      // clear: this.clear,\n      fieldMap: _this.fieldMap,\n      setValue: function setValue(fieldId, value) {\n        var emit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n\n        var field = _this.fieldsById.get(fieldId);\n\n        if (!field.shadow) {\n          ObjectMap.set(_this.state.values, field.field, field.fieldApi.getValue());\n        }\n\n        if (!field.fieldApi.relevant(_this.state.values)) {\n          ObjectMap[\"delete\"](_this.state.values, field.field);\n        } // Cleanup phase to get rid of irrelevant fields\n        // Also evaluate relevance on all fields\n\n\n        _this.fieldsById.forEach(function (f) {\n          // If a fields within an irrelivant step then remove it\n          // Otherwise, check to see if its relevant and only remove if keep state is false\n          var newRel = f.fieldApi.checkRelevant();\n\n          if (!f.fieldApi.multistepRelevant(_this.state.values) || !newRel && !f.keepState) {\n            ObjectMap[\"delete\"](_this.state.values, f.field);\n            ObjectMap[\"delete\"](_this.state.touched, f.field);\n            ObjectMap[\"delete\"](_this.state.errors, f.field);\n          }\n        });\n\n        if (emit) {\n          _this.emit('change');\n\n          _this.emit('value', field.field, value);\n        }\n      },\n      setTouched: function setTouched(fieldId, touch) {\n        var emit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n\n        var field = _this.fieldsById.get(fieldId);\n\n        if (!field.shadow && field.fieldApi.getIsRelevant()) {\n          ObjectMap.set(_this.state.touched, field.field, field.fieldApi.getTouched());\n        } // Shadow values override unless undefined\n\n\n        if (field.shadow && field.fieldApi.getError() != undefined && field.fieldApi.relevant(_this.state.values)) {\n          ObjectMap.set(_this.state.touched, field.field, field.fieldApi.getTouched());\n        }\n\n        if (emit) {\n          _this.emit('change'); //this.emit('touch', field.field, touch);\n\n        }\n      },\n      setError: function setError(fieldId, error) {\n        var emit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;\n\n        var field = _this.fieldsById.get(fieldId);\n\n        if (!field.shadow && field.fieldApi.getIsRelevant()) {\n          ObjectMap.set(_this.state.errors, field.field, field.fieldApi.getError());\n        } // Shadow values override unless undefined\n\n\n        var currentError = ObjectMap.get(_this.state.errors, field.field);\n\n        if (field.shadow && field.fieldApi.getError() != undefined && field.fieldApi.relevant(_this.state.values)) {\n          ObjectMap.set(_this.state.errors, field.field, field.fieldApi.getError());\n        } // Special case for attempting to set shadow to undefiend\n        else if (field.shadow && field.fieldApi.getError() === undefined && field.fieldApi.relevant(_this.state.values) && // TODO maybe check if object or array\n          typeof currentError === 'string') {\n            ObjectMap.set(_this.state.errors, field.field, field.fieldApi.getError());\n          }\n\n        if (emit) {\n          _this.emit('change'); //this.emit('error', field.field, error);\n\n        }\n      },\n      expectRemoval: _this.expectRemoval,\n      getInitialValue: _this.getInitialValue\n    }; // Define the formApi\n\n    _this.formApi = {\n      setValue: _this.setValue,\n      setTouched: _this.setTouched,\n      setError: _this.setError,\n      setFormError: _this.setFormError,\n      setValues: _this.setValues,\n      setInitialValue: _this.setInitialValue,\n      getValue: _this.getValue,\n      getTouched: _this.getTouched,\n      getError: _this.getError,\n      reset: _this.reset,\n      submitForm: _this.submitForm,\n      getState: _this.getFormState,\n      getValues: _this.getValues,\n      getFullField: _this.getFullField,\n      fieldExists: _this.fieldExists,\n      getInitialValue: _this.getInitialValue,\n      validate: _this.validate,\n      validateField: _this.validateField,\n      screenValid: _this.screenValid,\n      resetField: _this.resetField,\n      getOptions: _this.getOptions,\n      emitter: _assertThisInitialized(_this),\n      getSavedValue: _this.getSavedValue,\n      removeSavedState: _this.removeSavedState,\n      getDerrivedValue: _this.getDerrivedValue,\n      getStep: _this.getStep,\n      setStep: _this.setStep,\n      next: _this.next,\n      back: _this.back,\n      setCurrent: _this.setCurrent,\n      validated: _this.validated,\n      validating: _this.validating\n    };\n\n    _this.on('value', function (field) {\n      // The forms values have changed so we want to clear form level error\n      delete _this.state.error;\n\n      _this.notify(field);\n    });\n\n    return _this;\n  }\n  /* ---------------------------------- Setters ---------------------------------- */\n\n\n  _createClass(FormController, [{\n    key: \"setOptions\",\n    value: function setOptions(options) {\n      this.options = options;\n    }\n  }, {\n    key: \"setValue\",\n    value: function setValue(name, value, options) {\n      this.getField(name).fieldApi.setValue(value, null, _objectSpread2({\n        allowEmptyString: this.options.allowEmptyStrings\n      }, options));\n    }\n  }, {\n    key: \"setTouched\",\n    value: function setTouched(name, value) {\n      this.getField(name).fieldApi.setTouched(value);\n    }\n  }, {\n    key: \"setError\",\n    value: function setError(name, value) {\n      this.getField(name).fieldApi.setError(value);\n    }\n  }, {\n    key: \"setFormError\",\n    value: function setFormError(value) {\n      this.state.error = value;\n      this.emit('change');\n    }\n  }, {\n    key: \"validating\",\n    value: function validating() {\n      this.state.validating = this.state.validating + 1;\n      this.emit('change');\n    }\n  }, {\n    key: \"validated\",\n    value: function validated(name, error) {\n      // Decrement the validating\n      this.state.validating = this.state.validating - 1; // Set the error if there is not already one ( sync error first )\n\n      if (!this.getError(name)) {\n        this.setError(name, error);\n      } // If we are not still validating, and we were submitting, then submit form\n      // If we are async validating then dont submit yet\n\n\n      if (this.state.validating > 0) {\n        this.emit('change');\n        return;\n      } // If we were submitting\n\n\n      if (this.state.submitting) {\n        // Check validity and perform submission if valid\n        if (this.valid()) {\n          debug$2('Submit', this.state);\n          this.emit('submit');\n        } else {\n          debug$2('Submit', this.state);\n          this.emit('failure');\n        }\n\n        this.state.submitting = false;\n      }\n\n      this.emit('change');\n    }\n  }, {\n    key: \"setStep\",\n    value: function setStep(value) {\n      this.state.step = value;\n      this.emit('change');\n    }\n  }, {\n    key: \"setCurrent\",\n    value: function setCurrent(component) {\n      this.state.Current = component;\n      this.emit('change');\n    }\n  }, {\n    key: \"back\",\n    value: function back(prevComponent) {\n      this.state.step = this.state.step - 1;\n      this.state.Current = prevComponent;\n      this.emit('change');\n    }\n  }, {\n    key: \"next\",\n    value: function next(nextComponent) {\n      // Validate the entire form\n      this.validate(); // If fields on the screen ( currently rendered ) are valid move on\n\n      if (this.screenValid()) {\n        this.state.step = this.state.step + 1;\n        this.state.Current = nextComponent;\n      } // State will have changed\n\n\n      this.emit('change');\n    }\n  }, {\n    key: \"setInitialValue\",\n    value: function setInitialValue(field, value) {\n      ObjectMap.set(this.options.initialValues, field, value);\n    }\n    /* ---------------------------------- Getters ---------------------------------- */\n\n    /**\n     * Generate the external form state that will be exposed to the users\n     *\n     * @returns Form State\n     */\n\n  }, {\n    key: \"getFormState\",\n    value: function getFormState() {\n      debug$2('Returning form state');\n      return _objectSpread2(_objectSpread2({}, this.state), {}, {\n        pristine: this.pristine(),\n        dirty: this.dirty(),\n        invalid: this.invalid()\n      });\n    } // rebuildState() {\n    //   debug('Generating form state');\n    //   // Rebuild values, errors, and touched\n    //   const values = {};\n    //   const errors = {};\n    //   const touched = {};\n    //   this.fieldsById.forEach(field => {\n    //     if (!field.shadow) {\n    //       // Get the values from the field\n    //       const value = field.fieldApi.getValue();\n    //       const error = field.fieldApi.getError();\n    //       const t = field.fieldApi.getTouched();\n    //       // Set the value\n    //       ObjectMap.set(values, field.field, value);\n    //       ObjectMap.set(errors, field.field, error);\n    //       ObjectMap.set(touched, field.field, t);\n    //       // console.log('SETTING', field.field);\n    //     }\n    //   });\n    //   this.state = {\n    //     ...this.state,\n    //     values,\n    //     errors,\n    //     touched,\n    //     pristine: this.pristine(),\n    //     dirty: this.dirty(),\n    //     invalid: this.invalid()\n    //   };\n    // }\n\n  }, {\n    key: \"getFormApi\",\n    value: function getFormApi() {\n      return this.formApi;\n    }\n  }, {\n    key: \"getDerrivedValue\",\n    value: function getDerrivedValue(name) {\n      var values = this.getValues();\n      return ObjectMap.get(values, name);\n    }\n  }, {\n    key: \"getValue\",\n    value: function getValue(name) {\n      var value = this.getField(name).fieldApi.getValue();\n      debug$2('Getting value for', name, value);\n      return value;\n    }\n  }, {\n    key: \"getTouched\",\n    value: function getTouched(field) {\n      var touched = this.getField(field).fieldApi.getTouched();\n      debug$2('Getting touched for', field, touched);\n      return touched;\n    }\n  }, {\n    key: \"getError\",\n    value: function getError(field) {\n      var error = this.getField(field).fieldApi.getError();\n      debug$2('Getting error for', field, error);\n      return error;\n    }\n  }, {\n    key: \"getValues\",\n    value: function getValues() {\n      debug$2('Gettings values');\n      return this.state.values;\n    }\n  }, {\n    key: \"getAllTouched\",\n    value: function getAllTouched() {\n      debug$2('Gettings touched');\n      return this.state.touched;\n    }\n  }, {\n    key: \"getErrors\",\n    value: function getErrors() {\n      debug$2('Gettings errors');\n      return this.state.errors;\n    }\n  }, {\n    key: \"getOptions\",\n    value: function getOptions() {\n      return this.options;\n    }\n  }, {\n    key: \"getStep\",\n    value: function getStep() {\n      return this.state.step;\n    }\n  }, {\n    key: \"getSavedValue\",\n    value: function getSavedValue(name) {\n      var field = this.fieldsByName.get(name);\n\n      if (field && field.shadow) {\n        return ObjectMap.get(this.savedValues, \"shadow-\".concat(name));\n      }\n\n      return ObjectMap.get(this.savedValues, name);\n    }\n  }, {\n    key: \"removeSavedState\",\n    value: function removeSavedState(name) {\n      var field = this.fieldsByName.get(name);\n\n      if (field && field.shadow) {\n        return ObjectMap[\"delete\"](this.savedValues, \"shadow-\".concat(name));\n      }\n\n      return ObjectMap[\"delete\"](this.savedValues, name);\n    }\n  }, {\n    key: \"getFullField\",\n    value: function getFullField(field) {\n      return field;\n    }\n  }, {\n    key: \"getInitialValue\",\n    value: function getInitialValue(field) {\n      return ObjectMap.get(this.options.initialValues, field);\n    }\n  }, {\n    key: \"getField\",\n    value: function getField(name) {\n      debug$2('Getting Field', name);\n      var field = this.fieldsByName.get(name);\n\n      if (!field) {\n        // eslint-disable-next-line no-console\n        console.warn(\"Attempting to get field \".concat(name, \" but it does not exist\")); // Prevent app from crashing\n\n        return this.dummyField;\n      }\n\n      return field;\n    } // Notify other fields\n\n  }, {\n    key: \"notify\",\n    value: function notify(field) {\n      var _this2 = this;\n\n      // Example field - siblings[0].married\n      // Get the notifier\n      var notifier = this.getField(field); // If we have a list we must notify each one\n\n      if (notifier && notifier.notify) {\n        // Example: ['spouse']\n        notifier.notify.forEach(function (fieldName) {\n          // Get the field toNotify\n          var JSPAN = \".\".concat(field);\n          var path = \"\".concat(JSPAN.replace(/(.*)[.[].*/, '$1'), \".\").concat(fieldName).slice(1); // console.log('PATH', path);\n          // Example path - siblings[0].spouse\n\n          var toNotify = _this2.getField(path);\n\n          if (toNotify) {\n            debug$2('Notifying', toNotify.field);\n            toNotify.fieldApi.validate();\n            toNotify.fieldApi.checkRelevant();\n          }\n        });\n      }\n    }\n  }, {\n    key: \"validateField\",\n    value: function validateField(field) {\n      this.getField(field).fieldApi.validate();\n    }\n  }, {\n    key: \"resetField\",\n    value: function resetField(field) {\n      this.getField(field).fieldApi.reset();\n    }\n  }, {\n    key: \"fieldExists\",\n    value: function fieldExists(field) {\n      return this.fieldsByName.get(field) != null;\n    }\n  }, {\n    key: \"valid\",\n    value: function valid() {\n      var errors = this.getErrors();\n      return !!(ObjectMap.empty(errors) && !this.state.error);\n    }\n  }, {\n    key: \"screenValid\",\n    value: function screenValid() {\n      // Return false if any of the fields on the screen are invalid\n      var error = Object.entries(this.onScreen).some(function (_ref) {\n        var _ref2 = _slicedToArray(_ref, 2),\n            field = _ref2[1];\n\n        return field.fieldApi.getError();\n      });\n      return !error;\n    }\n  }, {\n    key: \"invalid\",\n    value: function invalid() {\n      var errors = this.getErrors();\n      return !!(!ObjectMap.empty(errors) || this.state.error);\n    }\n  }, {\n    key: \"pristine\",\n    value: function pristine() {\n      var touched = this.getAllTouched();\n      var values = this.getValues();\n      return ObjectMap.empty(touched) && ObjectMap.empty(values);\n    }\n  }, {\n    key: \"dirty\",\n    value: function dirty() {\n      return !this.pristine();\n    }\n  }, {\n    key: \"reset\",\n    value: function reset() {\n      debug$2('Resetting'); // So because all fields controll themselves and, \"inform\", this controller\n      // of their changes, we need to literally itterate through all registered fields\n      // and reset them. Not a big deal but very important to remember that you cant simply\n      // reset this controllers state!\n\n      this.fieldsById.forEach(function (field) {\n        field.fieldApi.reset({\n          preventUpdate: true\n        });\n      });\n      this.emit('reset');\n      this.emit('change');\n    }\n  }, {\n    key: \"setValues\",\n    value: function setValues(values) {\n      debug$2('Setting values'); // So we because all fields controll themselves and, \"inform\", this controller\n      // of their changes, we need to literally itterate through all registered fields\n      // and set them. Not a big deal but very important to remember that you cant simply\n      // set this controllers state!\n\n      this.fieldsById.forEach(function (field) {\n        // Initialize the values if it needs to be\n        var value = ObjectMap.get(values, field.field);\n\n        if (value !== undefined) {\n          field.fieldApi.setValue(value, null, {\n            preventUpdate: true\n          });\n        }\n      });\n      this.emit('change');\n    }\n  }, {\n    key: \"validate\",\n    value: function validate() {\n      var _this3 = this;\n\n      debug$2('Validating all fields');\n      var values = this.getValues(); // Validate schema if needed\n\n      if (this.options.validationSchema) {\n        var errors = validateYupSchema(this.options.validationSchema, values); // So we because all fields controll themselves and, \"inform\", this controller\n        // of their changes, we need to literally itterate through all registered fields\n        // and set them. Not a big deal but very important to remember that you cant simply\n        // set this controllers state!\n\n        this.fieldsById.forEach(function (field) {\n          // Check to see if there is an error to set\n          // Note: we use has becuause value may be there but undefined\n          if (ObjectMap.has(errors, field.field)) {\n            var error = ObjectMap.get(errors, field.field); // If there is an error then set it\n\n            _this3.setError(field.field, error);\n          } else {\n            // If we are doing schema validation then we need to clear out any old errors\n            _this3.setError(field.field, undefined);\n          }\n        });\n      } // Validate AJV schema if needed\n\n\n      if (this.options.schema && this.options.ajv) {\n        var _errors = validateAjvSchema(this.ajvValidate, values); // So we because all fields controll themselves and, \"inform\", this controller\n        // of their changes, we need to literally itterate through all registered fields\n        // and set them. Not a big deal but very important to remember that you cant simply\n        // set this controllers state!\n\n\n        this.fieldsById.forEach(function (field) {\n          // Check to see if there is an error to set\n          // Note: we use has becuause value may be there but undefined\n          if (ObjectMap.has(_errors, field.field)) {\n            var error = ObjectMap.get(_errors, field.field); // If there is an error then set it\n\n            _this3.setError(field.field, error);\n          } else {\n            // If we are doing schema validation then we need to clear out any old errors\n            _this3.setError(field.field, undefined);\n          }\n        });\n      } // Itterate through and call validate on every field\n\n\n      this.fieldsById.forEach(function (field) {\n        field.fieldApi.validate(values); // Second param to prevent validation\n\n        field.fieldApi.setTouched(true, true);\n      }); // Call the form level validation if its present\n\n      if (this.options.validate) {\n        var res = this.options.validate(values);\n        this.setFormError(res);\n      } // Call the forms field level validation\n\n\n      if (this.options.validateFields) {\n        var _errors2 = this.options.validateFields(values); // So we because all fields controll themselves and, \"inform\", this controller\n        // of their changes, we need to literally itterate through all registered fields\n        // and set them. Not a big deal but very important to remember that you cant simply\n        // set this controllers state!\n\n\n        this.fieldsById.forEach(function (field) {\n          // Check to see if there is an error to set\n          // Note: we use has becuause value may be there but undefined\n          if (ObjectMap.has(_errors2, field.field)) {\n            var error = ObjectMap.get(_errors2, field.field); // If there is an error then set it\n\n            _this3.setError(field.field, error);\n          }\n        });\n      }\n    }\n  }, {\n    key: \"asyncValidate\",\n    value: function asyncValidate() {\n      debug$2('Async Validating all fields');\n      var values = this.getValues(); // Itterate through and call validate on every field\n\n      this.fieldsById.forEach(function (field) {\n        field.fieldApi.asyncValidate(values);\n      });\n    }\n  }, {\n    key: \"keyDown\",\n    value: function keyDown(e) {\n      // If preventEnter then return\n      if (e.keyCode == 13 && this.options.preventEnter) {\n        e.preventDefault(e);\n        return false;\n      }\n    }\n  }, {\n    key: \"submitForm\",\n    value: function submitForm(e) {\n      // Incriment number of submit attempts\n      this.state.submits = this.state.submits + 1;\n      this.state.submitting = true;\n\n      if (!this.options.dontPreventDefault && e) {\n        // Prevent default browser form submission\n        e.preventDefault(e);\n      } // Validate the form\n\n\n      this.validate(); // Emit a change\n\n      this.emit('change'); // Trigger all async validations\n\n      this.asyncValidate(); // If we are async validating then dont submit yet\n\n      if (this.state.validating > 0) {\n        return;\n      } // Check validity and perform submission if valid\n\n\n      if (this.valid()) {\n        debug$2('Submit', this.state);\n        this.emit('submit');\n      } else {\n        debug$2('Submit', this.state);\n        this.emit('failure');\n      }\n\n      this.state.submitting = false;\n      this.emit('change');\n    }\n    /* ---------------- Updater Functions (used by fields) ---------------- */\n    // ADDED initialRender parameter because of react 16.13.0 warning that does not like\n    // setting initial value during first render\n\n  }, {\n    key: \"register\",\n    value: function register(id, field, initialRender) {\n      var name = field.field,\n          state = field.state;\n      debug$2('Register ID:', id, 'Name:', name, state, 'Initial', initialRender); // Example foo.bar.baz[3].baz >>>> foo.bar.baz[3]\n\n      var magicValue = name.slice(0, name.lastIndexOf('[') != -1 ? name.lastIndexOf(']') + 1 : name.length); // Field might be coming back after render remove old field\n\n      var alreadyRegistered;\n      this.fieldsById.forEach(function (value, key) {\n        if (value && value.field === name) {\n          alreadyRegistered = key;\n        }\n      });\n\n      if ( //!this.expectedRemovals[magicValue] &&\n      alreadyRegistered && (field.keepState || field.inMultistep)) {\n        debug$2('Already Registered', name);\n        this.fieldsById[\"delete\"](alreadyRegistered);\n      } else if ( //!this.expectedRemovals[magicValue] &&\n      alreadyRegistered && (!field.keepState || !field.inMultistep)) {\n        // eslint-disable-next-line no-console\n        console.warn('Check to make sure you have not registered two fields with the fieldName', name);\n      }\n\n      debug$2('Fields Registered', this.fieldsById.size); // The field is on the screen\n\n      this.onScreen[id] = field; // Always register the field\n\n      this.fieldsById.set(id, field); // Always clear out expected removals when a reregistering array field comes in\n\n      debug$2('clearing expected removal', magicValue);\n      delete this.expectedRemovals[magicValue];\n      delete this.pulledOut[magicValue]; // The field is a shadow field ooo spooky so dont set anything\n\n      if (field.shadow) {\n        return;\n      } // Update the forms state right away\n\n\n      this.updater.setValue(id, field.fieldApi.getValue(), false);\n      this.updater.setError(id, field.fieldApi.getError(), false);\n      this.updater.setTouched(id, field.fieldApi.getTouched(), false); // We register field right away but dont want it to triger a rerender\n\n      if (!initialRender) {\n        this.emit('change');\n      }\n    }\n  }, {\n    key: \"deregister\",\n    value: function deregister(id) {\n      var field = this.fieldsById.get(id);\n      var name = field.field;\n      debug$2('Deregister', id, name); // The field is off the screen\n\n      delete this.onScreen[id]; // Example foo.bar.baz[3] --> foo.bar.baz[3].baz && foo.bar.baz[3].taz.raz[4].naz\n\n      var expectedRemoval = isExpected(name, this.expectedRemovals); // Example foo.bar.baz[3].baz >>>> foo.bar.baz[3]\n\n      var magicValue = name.slice(0, name.lastIndexOf('[') != -1 ? name.lastIndexOf(']') + 1 : name.length); // If the fields state is to be kept then save the value\n\n      if ( // We are in a multistep or want to keep the state\n      (field.keepState || field.inMultistep) && // We are NOT expected to be removed\n      !expectedRemoval) {\n        // TODO ?? Exception where the field is irrelivant AND keep state was not passed ??\n        debug$2(\"Saving field \".concat(name, \"'s value\"), field.fieldApi.getFieldState());\n\n        if (!field.shadow) {\n          ObjectMap.set(this.savedValues, name, field.fieldApi.getFieldState());\n        } else {\n          // We are shadow field and will store this value in the shadows\n          ObjectMap.set(this.savedValues, \"shadow-\".concat(name), field.fieldApi.getFieldState());\n        }\n      } // Remove if its an expected removal OR we dont have keep state\n\n\n      if ( // This field was expected to be removed\n      expectedRemoval || // This field does not have keepstate and is NOT within a multistep\n      !field.keepState && !field.inMultistep || // If field is in multistep then we would always keep due to field.inMultistep\n      // BUT.. we need to also check if the field is irrelivant\n      // because if it gets unmounted, even if its part of a multistep, we want to remove\n      // the field completley, unless keep state was passed.\n      !field.fieldApi.getIsRelevant() && !field.keepState) {\n        // Remove the field completley\n        debug$2('Removing field', name);\n        this.fieldsById[\"delete\"](id); // Clean up state only if its not expected removal, otherwise we will just pull it out\n\n        if (!expectedRemoval) {\n          ObjectMap[\"delete\"](this.state.values, name);\n          ObjectMap[\"delete\"](this.state.touched, name);\n          ObjectMap[\"delete\"](this.state.errors, name);\n\n          if (!field.shadow) {\n            ObjectMap[\"delete\"](this.savedValues, name);\n          } else {\n            ObjectMap[\"delete\"](this.savedValues, \"shadow-\".concat(name));\n          }\n        } // If we expected this removal then pullOut\n\n\n        if (expectedRemoval && this.pulledOut[magicValue]) {\n          debug$2('Pulling out', name, 'with magic value', magicValue);\n          ObjectMap.pullOut(this.state.values, magicValue);\n          ObjectMap.pullOut(this.state.touched, magicValue);\n          ObjectMap.pullOut(this.state.errors, magicValue);\n          ObjectMap.pullOut(this.savedValues, magicValue); // console.log('Pull1', this.state.values);\n          // console.log('Pull2', this.savedValues);\n\n          delete this.pulledOut[magicValue];\n        }\n      }\n\n      this.emit('change');\n    }\n  }, {\n    key: \"expectRemoval\",\n    value: function expectRemoval(name) {\n      debug$2('Expecting removal of', name);\n      this.expectedRemovals[name] = true;\n      this.pulledOut[name] = true;\n    }\n  }, {\n    key: \"update\",\n    value: function update(id, field, oldName) {\n      debug$2('Update', id, field.field, oldName, field.fieldState.value); // this.change();\n      // Update the error touched and values of this field\n\n      var value = field.fieldApi.getValue();\n      var error = field.fieldApi.getError();\n      var t = field.fieldApi.getTouched(); // Clear the old value out\n\n      var oldField = this.fieldsByName.get(oldName); // Only clear if we had an old name ( our name changed )\n      // %% the oldField is gone!\n\n      if (oldName && !oldField) {\n        // Setting nothing sets to undefined and does NOT pull out\n        ObjectMap.set(this.state.values, oldName);\n        ObjectMap.set(this.state.errors, oldName);\n        ObjectMap.set(this.state.touched, oldName);\n      } // Set the value\n\n\n      ObjectMap.set(this.state.values, field.field, value);\n      ObjectMap.set(this.state.errors, field.field, error);\n      ObjectMap.set(this.state.touched, field.field, t);\n      this.emit('change');\n    }\n  }]);\n\n  return FormController;\n}(EventEmitter);\n\nvar logger$5 = debug('informed:FormProvider' + '\\t\\t');\n\nvar FormProvider = function FormProvider(_ref) {\n  var children = _ref.children,\n      formApi = _ref.formApi,\n      formController = _ref.formController,\n      formState = _ref.formState,\n      rest = _objectWithoutProperties(_ref, [\"children\", \"formApi\", \"formController\", \"formState\"]);\n\n  logger$5('Render FormProvider');\n\n  if (formApi) {\n    logger$5('Render FormProvider with given values');\n    /* --- Create Provider with given values and render Content --- */\n\n    return /*#__PURE__*/React.createElement(FormRegisterContext.Provider, {\n      value: formController.updater\n    }, /*#__PURE__*/React.createElement(FormApiContext.Provider, {\n      value: formApi\n    }, /*#__PURE__*/React.createElement(FormStateContext.Provider, {\n      value: formState\n    }, children)));\n  }\n\n  logger$5('Render FormProvider with generated values');\n  /* --- User did not pass values so create them --- */\n\n  var value = useForm(rest);\n  return /*#__PURE__*/React.createElement(FormRegisterContext.Provider, {\n    value: value.formController.updater\n  }, /*#__PURE__*/React.createElement(FormApiContext.Provider, {\n    value: value.formApi\n  }, /*#__PURE__*/React.createElement(FormStateContext.Provider, {\n    value: value.formState\n  }, children)));\n};\n\nvar logger$6 = debug('informed:useForm' + '\\t\\t');\n\nvar useForm = function useForm(_ref) {\n  var dontPreventDefault = _ref.dontPreventDefault,\n      initialValues = _ref.initialValues,\n      validate = _ref.validate,\n      validateFields = _ref.validateFields,\n      allowEmptyStrings = _ref.allowEmptyStrings,\n      preventEnter = _ref.preventEnter,\n      getApi = _ref.getApi,\n      apiRef = _ref.apiRef,\n      onChange = _ref.onChange,\n      onReset = _ref.onReset,\n      onSubmit = _ref.onSubmit,\n      onValueChange = _ref.onValueChange,\n      onSubmitFailure = _ref.onSubmitFailure,\n      validationSchema = _ref.validationSchema,\n      schema = _ref.schema,\n      ajv = _ref.ajv,\n      fieldMap = _ref.fieldMap,\n      onlyValidateSchema = _ref.onlyValidateSchema,\n      userProps = _objectWithoutProperties(_ref, [\"dontPreventDefault\", \"initialValues\", \"validate\", \"validateFields\", \"allowEmptyStrings\", \"preventEnter\", \"getApi\", \"apiRef\", \"onChange\", \"onReset\", \"onSubmit\", \"onValueChange\", \"onSubmitFailure\", \"validationSchema\", \"schema\", \"ajv\", \"fieldMap\", \"onlyValidateSchema\"]);\n\n  logger$6('Render useForm'); // Generate form controller options\n\n  var formControllerOptions = useMemo(function () {\n    return {\n      dontPreventDefault: dontPreventDefault,\n      initialValues: initialValues,\n      validate: validate,\n      validateFields: validateFields,\n      allowEmptyStrings: allowEmptyStrings,\n      preventEnter: preventEnter,\n      validationSchema: validationSchema,\n      schema: schema,\n      ajv: ajv,\n      fieldMap: fieldMap\n    };\n  }, [dontPreventDefault, initialValues, validate, validateFields, allowEmptyStrings, preventEnter, validationSchema, schema, ajv, fieldMap]); // Create form controller\n\n  var _useState = useState(function () {\n    return new FormController(formControllerOptions);\n  }),\n      _useState2 = _slicedToArray(_useState, 1),\n      formController = _useState2[0]; // Update the options when they change\n\n\n  useEffect(function () {\n    formController.setOptions(formControllerOptions);\n  }, [formControllerOptions]); // Form state will be used to trigger rerenders\n\n  var _useState3 = useState(function () {\n    return formController.getFormState();\n  }),\n      _useState4 = _slicedToArray(_useState3, 2),\n      formState = _useState4[0],\n      setFormState = _useState4[1]; // Register for events\n\n\n  useIsomorphicLayoutEffect(function () {\n    var onChangeHandler = function onChangeHandler() {\n      return onChange && onChange(formController.getFormState());\n    };\n\n    var onResetHandler = function onResetHandler() {\n      return onReset && onReset();\n    };\n\n    var onSubmitHandler = function onSubmitHandler() {\n      return onSubmit && onSubmit(formController.getFormState().values);\n    };\n\n    var onValueHandler = function onValueHandler() {\n      return onValueChange && onValueChange(formController.getFormState().values);\n    };\n\n    var onFailureHandler = function onFailureHandler() {\n      return onSubmitFailure && onSubmitFailure(formController.getFormState().errors);\n    }; // Register for events\n\n\n    formController.on('change', onChangeHandler);\n    formController.on('reset', onResetHandler);\n    formController.on('submit', onSubmitHandler);\n    formController.on('value', onValueHandler);\n    formController.on('failure', onFailureHandler); // Unregister events\n\n    return function () {\n      formController.removeListener('change', onChangeHandler);\n      formController.removeListener('reset', onResetHandler);\n      formController.removeListener('submit', onSubmitHandler);\n      formController.removeListener('value', onValueHandler);\n      formController.removeListener('failure', onFailureHandler);\n    };\n  }, [onChange, onReset, onSubmit, onValueChange, onSubmitFailure]); // Initialize code like constructor but not muhahah\n\n  useState(function () {\n    // Update the form state to trigger rerender!\n    var onChangeHandlerRerender = function onChangeHandlerRerender() {\n      logger$6('Setting form state');\n      setFormState(formController.getFormState());\n    }; // const debounced = debounce(onChangeHandlerRerender, 250);\n\n\n    formController.on('change', onChangeHandlerRerender); // Give access to api outside\n\n    if (getApi) {\n      getApi(formController.getFormApi());\n    }\n\n    if (apiRef) {\n      apiRef.current = formController.getFormApi();\n    }\n  }); // We dont want this to happen on every render so thats why useState is used here\n\n  var _useState5 = useState(function () {\n    return formController.getFormApi();\n  }),\n      _useState6 = _slicedToArray(_useState5, 1),\n      formApi = _useState6[0]; // TODO technically speaking this can be unsafe as there is circular dependency\n  // between form provider and useForm.. Its ok because anyone that in theory\n  // Uses a form provider and a use form hook themselves will never call the render\n  // function created here... that being said I will look into fixing that warning\n  // at some point :)\n\n\n  var render = function render(children) {\n    return /*#__PURE__*/React.createElement(FormProvider, {\n      formApi: formApi,\n      formState: formState,\n      formController: formController\n    }, /*#__PURE__*/React.createElement(React.Fragment, null, !children ? /*#__PURE__*/React.createElement(FormFields, {\n      schema: schema,\n      onlyValidateSchema: onlyValidateSchema\n    }) : children));\n  };\n\n  return {\n    formApi: formApi,\n    formState: formState,\n    formController: formController,\n    render: render,\n    userProps: userProps\n  };\n};\n\nvar debug$3 = debug('informed:Form' + '\\t\\t');\n\nvar Form = function Form(_ref) {\n  var children = _ref.children,\n      renderProp = _ref.render,\n      component = _ref.component,\n      rest = _objectWithoutProperties(_ref, [\"children\", \"render\", \"component\"]);\n\n  debug$3('Render FORM');\n\n  var _useForm = useForm(rest),\n      formApi = _useForm.formApi,\n      formController = _useForm.formController,\n      formState = _useForm.formState,\n      render = _useForm.render,\n      userProps = _useForm.userProps;\n\n  var getContent = function getContent() {\n    var props = {\n      formState: formState,\n      formApi: formApi\n    };\n\n    if (component) {\n      return /*#__PURE__*/React.createElement(component, props, children);\n    }\n\n    if (renderProp) {\n      return renderProp(props);\n    }\n\n    if (typeof children === 'function') {\n      return children(props);\n    }\n\n    return children;\n  };\n  /* --- Render Content --- */\n\n\n  return render( /*#__PURE__*/React.createElement(\"form\", _extends({}, userProps, {\n    onReset: formController.reset,\n    onSubmit: formController.submitForm,\n    onKeyDown: formController.keyDown\n  }), getContent()));\n};\n\nvar buildScopedFormApi$1 = function buildScopedFormApi(scope, formApi) {\n  return _objectSpread2(_objectSpread2({}, formApi), {}, {\n    getValue: function getValue(field) {\n      return formApi.getValue(\"\".concat(scope, \".\").concat(field));\n    },\n    getTouched: function getTouched(field) {\n      return formApi.getTouched(\"\".concat(scope, \".\").concat(field));\n    },\n    getError: function getError(field) {\n      return formApi.getError(\"\".concat(scope, \".\").concat(field));\n    },\n    setValue: function setValue(field, value) {\n      return formApi.setValue(\"\".concat(scope, \".\").concat(field), value);\n    },\n    setTouched: function setTouched(field, value) {\n      return formApi.setTouched(\"\".concat(scope, \".\").concat(field), value);\n    },\n    setError: function setError(field, value) {\n      return formApi.setError(\"\".concat(scope, \".\").concat(field), value);\n    },\n    getInitialValue: function getInitialValue(field) {\n      return formApi.getInitialValue(\"\".concat(scope, \".\").concat(field));\n    },\n    getFullField: function getFullField(field) {\n      return \"\".concat(formApi.getFullField(scope), \".\").concat(field);\n    }\n  });\n};\n\nvar buildScopedRegister = function buildScopedRegister(scope, formRegister) {\n  var _register = formRegister.register,\n      _deregister = formRegister.deregister,\n      _setValue = formRegister.setValue,\n      _setTouched = formRegister.setTouched,\n      _setError = formRegister.setError,\n      _update = formRegister.update,\n      _getField = formRegister.getField,\n      _expectRemoval = formRegister.expectRemoval,\n      _getInitialValue = formRegister.getInitialValue,\n      fieldMap = formRegister.fieldMap;\n  return {\n    register: function register(field) {\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      return _register.apply(void 0, [\"\".concat(scope, \".\").concat(field)].concat(args));\n    },\n    deregister: function deregister(field) {\n      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        args[_key2 - 1] = arguments[_key2];\n      }\n\n      return _deregister.apply(void 0, [\"\".concat(scope, \".\").concat(field)].concat(args));\n    },\n    update: function update(field) {\n      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {\n        args[_key3 - 1] = arguments[_key3];\n      }\n\n      return _update.apply(void 0, [\"\".concat(scope, \".\").concat(field)].concat(args));\n    },\n    setValue: function setValue(field) {\n      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n        args[_key4 - 1] = arguments[_key4];\n      }\n\n      return _setValue.apply(void 0, [\"\".concat(scope, \".\").concat(field)].concat(args));\n    },\n    setTouched: function setTouched(field) {\n      for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {\n        args[_key5 - 1] = arguments[_key5];\n      }\n\n      return _setTouched.apply(void 0, [\"\".concat(scope, \".\").concat(field)].concat(args));\n    },\n    setError: function setError(field) {\n      for (var _len6 = arguments.length, args = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {\n        args[_key6 - 1] = arguments[_key6];\n      }\n\n      return _setError.apply(void 0, [\"\".concat(scope, \".\").concat(field)].concat(args));\n    },\n    getField: function getField(field) {\n      for (var _len7 = arguments.length, args = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {\n        args[_key7 - 1] = arguments[_key7];\n      }\n\n      return _getField.apply(void 0, [\"\".concat(scope, \".\").concat(field)].concat(args));\n    },\n    expectRemoval: function expectRemoval(field) {\n      for (var _len8 = arguments.length, args = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {\n        args[_key8 - 1] = arguments[_key8];\n      }\n\n      return _expectRemoval.apply(void 0, [\"\".concat(scope, \".\").concat(field)].concat(args));\n    },\n    getInitialValue: function getInitialValue(field) {\n      return _getInitialValue(\"\".concat(scope, \".\").concat(field));\n    },\n    fieldMap: fieldMap\n  };\n};\n\nvar Scope = function Scope(_ref) {\n  var scope = _ref.scope,\n      children = _ref.children;\n  var formRegister = useContext(FormRegisterContext);\n  var formApi = useFormApi();\n  var formState = useFormState(); // VERY important to memoize the builders!\n\n  var scopedFormApi = useMemo(function () {\n    return buildScopedFormApi$1(scope, formApi);\n  }, [scope]);\n  var scopedRegister = useMemo(function () {\n    return buildScopedRegister(scope, formRegister);\n  }, [scope]);\n  return /*#__PURE__*/React.createElement(FormRegisterContext.Provider, {\n    value: scopedRegister\n  }, /*#__PURE__*/React.createElement(FormApiContext.Provider, {\n    value: scopedFormApi\n  }, /*#__PURE__*/React.createElement(FormStateContext.Provider, {\n    value: formState\n  }, children)));\n};\n\nvar FormState = function FormState(props) {\n  var formState = useFormState();\n  var displayState = {};\n\n  if (Object.keys(props).length > 0) {\n    Object.keys(props).forEach(function (key) {\n      displayState[key] = formState[key];\n    });\n  } else {\n    displayState = formState;\n  }\n\n  var _displayState = displayState,\n      pristine = _displayState.pristine,\n      dirty = _displayState.dirty,\n      invalid = _displayState.invalid,\n      values = _displayState.values,\n      errors = _displayState.errors,\n      touched = _displayState.touched,\n      validating = _displayState.validating,\n      submitting = _displayState.submitting;\n  return /*#__PURE__*/React.createElement(\"pre\", null, /*#__PURE__*/React.createElement(\"code\", null, JSON.stringify({\n    pristine: pristine,\n    dirty: dirty,\n    invalid: invalid,\n    values: values,\n    errors: errors,\n    touched: touched,\n    validating: validating,\n    submitting: submitting\n  }, null, 2)));\n};\n\nvar useMultistep = function useMultistep(_ref) {\n  var initialStep = _ref.initialStep,\n      multistepApiRef = _ref.multistepApiRef;\n\n  // Get the formApi\n  var _useFormApi = useFormApi(),\n      getValues = _useFormApi.getValues,\n      validate = _useFormApi.validate,\n      screenValid = _useFormApi.screenValid; // Track our steps by name\n\n\n  var _useState = useState(new Map()),\n      _useState2 = _slicedToArray(_useState, 1),\n      stepsByName = _useState2[0]; // Define our state\n\n\n  var _useStateWithGetter = useStateWithGetter({\n    current: initialStep,\n    steps: []\n  }),\n      _useStateWithGetter2 = _slicedToArray(_useStateWithGetter, 3),\n      multistepState = _useStateWithGetter2[0],\n      setMultistepState = _useStateWithGetter2[1],\n      getMultistepState = _useStateWithGetter2[2]; // Define our api\n\n\n  var _useState3 = useState(function () {\n    var getCurrentStep = function getCurrentStep() {\n      // Get the current state\n      var _getMultistepState = getMultistepState(),\n          current = _getMultistepState.current; // Get the current step\n\n\n      var currentStep = stepsByName.get(current); // Return it\n\n      return currentStep;\n    };\n\n    var api = {\n      // Gets the whole state\n      getState: function getState() {\n        return getMultistepState();\n      },\n      // Gets just the current\n      getCurrentStep: getCurrentStep,\n      // Gets that step\n      getStep: function getStep(name) {\n        return stepsByName.get(name);\n      },\n      // Goes to next step\n      next: function next() {\n        // Validate the entire form\n        validate(); // If fields on the screen ( currently rendered ) are valid move on\n\n        if (screenValid()) {\n          // Get the current step\n          var _getCurrentStep = getCurrentStep(),\n              getNext = _getCurrentStep.getNext;\n\n          var next = getNext(); // Determine what the next step should be\n\n          var nextStep = typeof next === 'function' ? next(getValues()) : next; // Determine if it has a next\n\n          if (nextStep) {\n            setMultistepState(function (prev) {\n              return _objectSpread2(_objectSpread2({}, prev), {}, {\n                current: nextStep\n              });\n            });\n          }\n        }\n      },\n      // Goes to previous step\n      back: function back() {\n        // Get the current step\n        var _getCurrentStep2 = getCurrentStep(),\n            getPrevious = _getCurrentStep2.getPrevious;\n\n        var previous = getPrevious(); // Determine what the previous step should be\n\n        var previousStep = typeof previous === 'function' ? previous(getValues()) : previous; // Determine if it has a previous\n\n        if (previousStep) {\n          setMultistepState(function (prev) {\n            return _objectSpread2(_objectSpread2({}, prev), {}, {\n              current: previousStep\n            });\n          });\n        }\n      },\n      // Goes to specified step\n      setCurrent: function setCurrent(next) {\n        // Determine if it has a next\n        if (next) {\n          setMultistepState(function (prev) {\n            return _objectSpread2(_objectSpread2({}, prev), {}, {\n              current: next\n            });\n          });\n        }\n      },\n      // Registers the step\n      register: function register(name, step, initial) {\n        stepsByName.set(name, step);\n\n        if (!initial) {\n          setMultistepState(function (prev) {\n            return _objectSpread2(_objectSpread2({}, prev), {}, {\n              steps: Array.from(stepsByName.keys())\n            });\n          });\n        }\n      },\n      // Deregisters the step\n      deregister: function deregister(name) {\n        stepsByName[\"delete\"](name);\n        setMultistepState(function (prev) {\n          return _objectSpread2(_objectSpread2({}, prev), {}, {\n            steps: Array.from(stepsByName.keys())\n          });\n        });\n      }\n    };\n\n    if (multistepApiRef) {\n      multistepApiRef.current = api;\n    }\n\n    return api;\n  }),\n      _useState4 = _slicedToArray(_useState3, 1),\n      multistepApi = _useState4[0]; // Render funtion that will provide state and api\n\n\n  var render = function render(children) {\n    return /*#__PURE__*/React.createElement(MultistepApiContext.Provider, {\n      value: multistepApi\n    }, /*#__PURE__*/React.createElement(MultistepStateContext.Provider, {\n      value: multistepState\n    }, children));\n  };\n\n  return _objectSpread2(_objectSpread2(_objectSpread2({}, multistepApi), multistepState), {}, {\n    render: render\n  });\n};\n\nfunction useMultistepState() {\n  return useContext(MultistepStateContext);\n}\n\nfunction useMultistepApi() {\n  return useContext(MultistepApiContext);\n}\n\nvar useMultistepStep = function useMultistepStep(_ref) {\n  var step = _ref.step,\n      next = _ref.next,\n      previous = _ref.previous,\n      relevant = _ref.relevant;\n\n  var _useFormState = useFormState(),\n      values = _useFormState.values;\n\n  var _useMultistepState = useMultistepState(),\n      current = _useMultistepState.current;\n\n  var _useMultistepApi = useMultistepApi(),\n      register = _useMultistepApi.register,\n      deregister = _useMultistepApi.deregister;\n\n  var isCurrent = step === current;\n  var isRelevant = relevant ? relevant(values) : true;\n  var nextRef = useRef(next);\n  var prevRef = useRef(previous);\n  var relevantRef = useRef();\n  nextRef.current = next;\n  prevRef.current = previous;\n  relevantRef.current = relevant;\n  useState(function () {\n    register(step, {\n      name: step,\n      getNext: function getNext() {\n        return nextRef.current;\n      },\n      getPrevious: function getPrevious() {\n        return prevRef.current;\n      }\n    }, true);\n  });\n  useEffect(function () {\n    register(step, {\n      name: step,\n      getNext: function getNext() {\n        return nextRef.current;\n      },\n      getPrevious: function getPrevious() {\n        return prevRef.current;\n      }\n    });\n    return function () {\n      deregister(step);\n    };\n  }, [step]);\n\n  var render = function render(children) {\n    return /*#__PURE__*/React.createElement(MultistepStepContext.Provider, {\n      value: {\n        relevant: function relevant(params) {\n          return relevantRef.current ? relevantRef.current(params) : true;\n        },\n        multistep: true\n      }\n    }, isCurrent && isRelevant ? children : null);\n  };\n\n  return {\n    isCurrent: isCurrent,\n    isRelevant: isRelevant,\n    step: step,\n    render: render\n  };\n};\n\nfunction Multistep(_ref) {\n  var children = _ref.children,\n      props = _objectWithoutProperties(_ref, [\"children\"]);\n\n  var _useMultistep = useMultistep(props),\n      render = _useMultistep.render,\n      context = _objectWithoutProperties(_useMultistep, [\"render\"]);\n\n  if (typeof children === 'function') {\n    return render(children(context));\n  }\n\n  return render(children);\n}\n\nMultistep.Step = function MultistepStep(_ref2) {\n  var children = _ref2.children,\n      props = _objectWithoutProperties(_ref2, [\"children\"]);\n\n  var _useMultistepStep = useMultistepStep(props),\n      render = _useMultistepStep.render;\n\n  return render(children);\n};\n\nvar FormField = function FormField(_ref) {\n  var field = _ref.field;\n\n  // Get the field map off the forms context\n  var _useContext = useContext(FormRegisterContext),\n      fieldMap = _useContext.fieldMap; // Grab the form api ( we need it to get the actual field name because might be in scope )\n\n\n  var _useFormApi = useFormApi(),\n      getFullField = _useFormApi.getFullField,\n      getOptions = _useFormApi.getOptions; // Grab the full field\n\n\n  var fullField = getFullField(field); // Grap the schema\n\n  var _getOptions = getOptions(),\n      schema = _getOptions.schema; // First find property from the schema via the path to that field\n  // Examples\n  // field = \"name\" ---> properties.name\n  // field = \"brother.name\" ---> properties.brother.properties.name\n  // field = \"brother.siblings[1].friend.name\" ---> properties.brother.properties.siblings.items[1].properties.friend.properties.name\n\n\n  var path = getSchemaPathFromJsonPath(fullField);\n  var property = ObjectMap.get(schema, path); // If property was not found return null\n\n  if (!property) {\n    return null;\n  } // Next compute the field from property\n\n\n  var schemaField = computeFieldFromProperty(field, property);\n  var props = schemaField.props,\n      componentType = schemaField.componentType;\n  var Component = fieldMap[componentType];\n  return /*#__PURE__*/React.createElement(Component, _extends({\n    field: field\n  }, props));\n};\n\nvar SchemaFields = function SchemaFields() {\n  var _useFormApi = useFormApi(),\n      getOptions = _useFormApi.getOptions; // Grap the schema\n\n\n  var _getOptions = getOptions(),\n      schema = _getOptions.schema;\n\n  return /*#__PURE__*/React.createElement(FormFields, {\n    schema: schema\n  });\n};\n\nvar withFormApi = function withFormApi(Component) {\n  return /*#__PURE__*/React.forwardRef(function (props, ref) {\n    return /*#__PURE__*/React.createElement(FormApiContext.Consumer, null, function (formApi) {\n      return /*#__PURE__*/React.createElement(Component, _extends({\n        formApi: formApi,\n        ref: ref\n      }, props));\n    });\n  });\n};\n\nvar withFormState = function withFormState(Component) {\n  return /*#__PURE__*/React.forwardRef(function (props, ref) {\n    return /*#__PURE__*/React.createElement(FormStateContext.Consumer, null, function (formState) {\n      return /*#__PURE__*/React.createElement(Component, _extends({\n        formState: formState,\n        ref: ref\n      }, props));\n    });\n  });\n};\n\nvar buildFieldApi = function buildFieldApi(formApi, field) {\n  return {\n    // TODO refactor to use field api from updater.. need to make sure this \n    // will be stable\n    getValue: function getValue() {\n      return formApi.getValue(field);\n    },\n    setValue: function setValue(value) {\n      return formApi.setValue(field, value);\n    },\n    getTouched: function getTouched() {\n      return formApi.getTouched(field);\n    },\n    setTouched: function setTouched(value) {\n      return formApi.setTouched(field, value);\n    },\n    getError: function getError() {\n      return formApi.getError(field);\n    },\n    setError: function setError(value) {\n      return formApi.setError(field, value);\n    },\n    reset: function reset() {\n      return formApi.resetField(field);\n    },\n    validate: function validate() {\n      return formApi.validateField(field);\n    },\n    exists: function exists() {\n      return formApi.fieldExists(field);\n    }\n  };\n};\n\nfunction useFieldApi(field) {\n  var formApi = useFormApi();\n  var fieldApi = useMemo(function () {\n    return buildFieldApi(formApi, field);\n  }, [field]);\n  return fieldApi;\n}\n\nvar buildFieldState = function buildFieldState(fieldApi) {\n  return {\n    value: fieldApi.getValue(),\n    touched: fieldApi.getTouched(),\n    error: fieldApi.getError()\n  };\n};\n\nfunction useFieldState(field) {\n  var fieldApi = useFieldApi(field); // TODO find better way to get this to rerender\n\n  var formState = useFormState(); // The above is a temp hack\n\n  var fieldState = buildFieldState(fieldApi);\n  return fieldState;\n}\n\nvar withFieldState = function withFieldState(field) {\n  return function (Component) {\n    return function (props) {\n      var fieldState = useFieldState(field);\n      return /*#__PURE__*/React.createElement(Component, _extends({\n        fieldState: fieldState\n      }, props));\n    };\n  };\n};\n\nvar withFieldApi = function withFieldApi(field) {\n  return function (Component) {\n    return function (props) {\n      var fieldApi = useFieldApi(field);\n      return /*#__PURE__*/React.createElement(Component, _extends({\n        fieldApi: fieldApi\n      }, props));\n    };\n  };\n};\n\nvar Option = function Option(_ref) {\n  var value = _ref.value,\n      forwardedRef = _ref.forwardedRef,\n      children = _ref.children,\n      rest = _objectWithoutProperties(_ref, [\"value\", \"forwardedRef\", \"children\"]);\n\n  return /*#__PURE__*/React.createElement(\"option\", _extends({\n    ref: forwardedRef,\n    value: value,\n    key: value\n  }, rest), children);\n};\n\nvar Input = Text$1;\n\nexport { ArrayField, Checkbox as BasicCheckbox, Radio as BasicRadio, RadioGroup as BasicRadioGroup, Select as BasicSelect, Text as BasicText, TextArea as BasicTextArea, Checkbox$1 as Checkbox, Form, FormComponents, FormField, FormFields, FormProvider, FormState, Input, Multistep, Option, Radio$1 as Radio, RadioGroup$1 as RadioGroup, Relevant, SchemaFields, Scope, Select$1 as Select, Text$1 as Text, TextArea$1 as TextArea, asField, useArrayField, useArrayFieldApi, useArrayFieldItemApi, useField, useFieldApi, useFieldState, useForm, useFormApi, useFormState, useMultistepApi, useMultistepState, withFieldApi, withFieldState, withFormApi, withFormState, withRadioGroup };\n","export var DEFAULT_NAMESPACE = '/';\nexport var ACTION_TYPE_DELIMITER = '||';","export default (function (value) {\n  return Array.isArray(value);\n});","export default (function (value) {\n  return typeof value === 'string';\n});","export default (function (array) {\n  return array[array.length - 1];\n});","import camelCase from 'to-camel-case';\nvar namespacer = '/';\nexport default (function (type) {\n  return type.indexOf(namespacer) === -1 ? camelCase(type) : type.split(namespacer).map(camelCase).join(namespacer);\n});","export default (function (array, callback) {\n  return array.reduce(function (partialObject, element) {\n    return callback(partialObject, element);\n  }, {});\n});","import isPlainObject from './isPlainObject';\nimport flattenWhenNode from './flattenWhenNode';\nexport default flattenWhenNode(isPlainObject);","export default (function (value) {\n  return value.length === 0;\n});","import { DEFAULT_NAMESPACE } from '../constants';\nimport isEmpty from './isEmpty';\nimport camelCase from './camelCase';\nexport default function unflattenActionCreators(flatActionCreators, _temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n      _ref$namespace = _ref.namespace,\n      namespace = _ref$namespace === void 0 ? DEFAULT_NAMESPACE : _ref$namespace,\n      prefix = _ref.prefix;\n\n  function unflatten(flatActionType, partialNestedActionCreators, partialFlatActionTypePath) {\n    var nextNamespace = camelCase(partialFlatActionTypePath.shift());\n\n    if (isEmpty(partialFlatActionTypePath)) {\n      partialNestedActionCreators[nextNamespace] = flatActionCreators[flatActionType];\n    } else {\n      if (!partialNestedActionCreators[nextNamespace]) {\n        partialNestedActionCreators[nextNamespace] = {};\n      }\n\n      unflatten(flatActionType, partialNestedActionCreators[nextNamespace], partialFlatActionTypePath);\n    }\n  }\n\n  var nestedActionCreators = {};\n  Object.getOwnPropertyNames(flatActionCreators).forEach(function (type) {\n    var unprefixedType = prefix ? type.replace(\"\" + prefix + namespace, '') : type;\n    return unflatten(type, nestedActionCreators, unprefixedType.split(namespace));\n  });\n  return nestedActionCreators;\n}","export default (function (value) {\n  return value === null;\n});","import invariant from 'invariant';\nimport isFunction from './utils/isFunction';\nimport identity from './utils/identity';\nimport isNull from './utils/isNull';\nexport default function createAction(type, payloadCreator, metaCreator) {\n  if (payloadCreator === void 0) {\n    payloadCreator = identity;\n  }\n\n  invariant(isFunction(payloadCreator) || isNull(payloadCreator), 'Expected payloadCreator to be a function, undefined or null');\n  var finalPayloadCreator = isNull(payloadCreator) || payloadCreator === identity ? identity : function (head) {\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    return head instanceof Error ? head : payloadCreator.apply(void 0, [head].concat(args));\n  };\n  var hasMeta = isFunction(metaCreator);\n  var typeString = type.toString();\n\n  var actionCreator = function actionCreator() {\n    var payload = finalPayloadCreator.apply(void 0, arguments);\n    var action = {\n      type: type\n    };\n\n    if (payload instanceof Error) {\n      action.error = true;\n    }\n\n    if (payload !== undefined) {\n      action.payload = payload;\n    }\n\n    if (hasMeta) {\n      action.meta = metaCreator.apply(void 0, arguments);\n    }\n\n    return action;\n  };\n\n  actionCreator.toString = function () {\n    return typeString;\n  };\n\n  return actionCreator;\n}","function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport invariant from 'invariant';\nimport isPlainObject from './utils/isPlainObject';\nimport isFunction from './utils/isFunction';\nimport identity from './utils/identity';\nimport isArray from './utils/isArray';\nimport isString from './utils/isString';\nimport isNil from './utils/isNil';\nimport getLastElement from './utils/getLastElement';\nimport camelCase from './utils/camelCase';\nimport arrayToObject from './utils/arrayToObject';\nimport flattenActionMap from './utils/flattenActionMap';\nimport unflattenActionCreators from './utils/unflattenActionCreators';\nimport createAction from './createAction';\nimport { DEFAULT_NAMESPACE } from './constants';\nexport default function createActions(actionMap) {\n  for (var _len = arguments.length, identityActions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    identityActions[_key - 1] = arguments[_key];\n  }\n\n  var options = isPlainObject(getLastElement(identityActions)) ? identityActions.pop() : {};\n  invariant(identityActions.every(isString) && (isString(actionMap) || isPlainObject(actionMap)), 'Expected optional object followed by string action types');\n\n  if (isString(actionMap)) {\n    return actionCreatorsFromIdentityActions([actionMap].concat(identityActions), options);\n  }\n\n  return _objectSpread({}, actionCreatorsFromActionMap(actionMap, options), actionCreatorsFromIdentityActions(identityActions, options));\n}\n\nfunction actionCreatorsFromActionMap(actionMap, options) {\n  var flatActionMap = flattenActionMap(actionMap, options);\n  var flatActionCreators = actionMapToActionCreators(flatActionMap);\n  return unflattenActionCreators(flatActionCreators, options);\n}\n\nfunction actionMapToActionCreators(actionMap, _temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n      prefix = _ref.prefix,\n      _ref$namespace = _ref.namespace,\n      namespace = _ref$namespace === void 0 ? DEFAULT_NAMESPACE : _ref$namespace;\n\n  function isValidActionMapValue(actionMapValue) {\n    if (isFunction(actionMapValue) || isNil(actionMapValue)) {\n      return true;\n    }\n\n    if (isArray(actionMapValue)) {\n      var _actionMapValue$ = actionMapValue[0],\n          payload = _actionMapValue$ === void 0 ? identity : _actionMapValue$,\n          meta = actionMapValue[1];\n      return isFunction(payload) && isFunction(meta);\n    }\n\n    return false;\n  }\n\n  return arrayToObject(Object.keys(actionMap), function (partialActionCreators, type) {\n    var _objectSpread2;\n\n    var actionMapValue = actionMap[type];\n    invariant(isValidActionMapValue(actionMapValue), 'Expected function, undefined, null, or array with payload and meta ' + (\"functions for \" + type));\n    var prefixedType = prefix ? \"\" + prefix + namespace + type : type;\n    var actionCreator = isArray(actionMapValue) ? createAction.apply(void 0, [prefixedType].concat(actionMapValue)) : createAction(prefixedType, actionMapValue);\n    return _objectSpread({}, partialActionCreators, (_objectSpread2 = {}, _objectSpread2[type] = actionCreator, _objectSpread2));\n  });\n}\n\nfunction actionCreatorsFromIdentityActions(identityActions, options) {\n  var actionMap = arrayToObject(identityActions, function (partialActionMap, type) {\n    var _objectSpread3;\n\n    return _objectSpread({}, partialActionMap, (_objectSpread3 = {}, _objectSpread3[type] = identity, _objectSpread3));\n  });\n  var actionCreators = actionMapToActionCreators(actionMap, options);\n  return arrayToObject(Object.keys(actionCreators), function (partialActionCreators, type) {\n    var _objectSpread4;\n\n    return _objectSpread({}, partialActionCreators, (_objectSpread4 = {}, _objectSpread4[camelCase(type)] = actionCreators[type], _objectSpread4));\n  });\n}","import isPlainObject from './isPlainObject';\nimport isMap from './isMap';\nimport hasGeneratorInterface from './hasGeneratorInterface';\nimport flattenWhenNode from './flattenWhenNode';\nexport default flattenWhenNode(function (node) {\n  return (isPlainObject(node) || isMap(node)) && !hasGeneratorInterface(node);\n});","import ownKeys from './ownKeys';\nexport default function hasGeneratorInterface(handler) {\n  var keys = ownKeys(handler);\n  var hasOnlyInterfaceNames = keys.every(function (ownKey) {\n    return ownKey === 'next' || ownKey === 'throw';\n  });\n  return keys.length && keys.length <= 2 && hasOnlyInterfaceNames;\n}","export default (function (value) {\n  return value === undefined;\n});","export default (function (value) {\n  return value.toString();\n});","import reduceReducers from 'reduce-reducers';\nimport invariant from 'invariant';\nimport isPlainObject from './utils/isPlainObject';\nimport isMap from './utils/isMap';\nimport ownKeys from './utils/ownKeys';\nimport flattenReducerMap from './utils/flattenReducerMap';\nimport handleAction from './handleAction';\nimport get from './utils/get';\nexport default function handleActions(handlers, defaultState, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  invariant(isPlainObject(handlers) || isMap(handlers), 'Expected handlers to be a plain object.');\n  var flattenedReducerMap = flattenReducerMap(handlers, options);\n  var reducers = ownKeys(flattenedReducerMap).map(function (type) {\n    return handleAction(type, get(type, flattenedReducerMap), defaultState);\n  });\n  var reducer = reduceReducers.apply(void 0, reducers.concat([defaultState]));\n  return function (state, action) {\n    if (state === void 0) {\n      state = defaultState;\n    }\n\n    return reducer(state, action);\n  };\n}","import invariant from 'invariant';\nimport isFunction from './utils/isFunction';\nimport isPlainObject from './utils/isPlainObject';\nimport identity from './utils/identity';\nimport isNil from './utils/isNil';\nimport isUndefined from './utils/isUndefined';\nimport toString from './utils/toString';\nimport { ACTION_TYPE_DELIMITER } from './constants';\nexport default function handleAction(type, reducer, defaultState) {\n  if (reducer === void 0) {\n    reducer = identity;\n  }\n\n  var types = toString(type).split(ACTION_TYPE_DELIMITER);\n  invariant(!isUndefined(defaultState), \"defaultState for reducer handling \" + types.join(', ') + \" should be defined\");\n  invariant(isFunction(reducer) || isPlainObject(reducer), 'Expected reducer to be a function or object with next and throw reducers');\n\n  var _ref = isFunction(reducer) ? [reducer, reducer] : [reducer.next, reducer.throw].map(function (aReducer) {\n    return isNil(aReducer) ? identity : aReducer;\n  }),\n      nextReducer = _ref[0],\n      throwReducer = _ref[1];\n\n  return function (state, action) {\n    if (state === void 0) {\n      state = defaultState;\n    }\n\n    var actionType = action.type;\n\n    if (!actionType || types.indexOf(toString(actionType)) === -1) {\n      return state;\n    }\n\n    return (action.error === true ? throwReducer : nextReducer)(state, action);\n  };\n}","import { DEFAULT_NAMESPACE, ACTION_TYPE_DELIMITER } from '../constants';\nimport ownKeys from './ownKeys';\nimport get from './get';\nexport default (function (predicate) {\n  return function flatten(map, _temp, partialFlatMap, partialFlatActionType) {\n    var _ref = _temp === void 0 ? {} : _temp,\n        _ref$namespace = _ref.namespace,\n        namespace = _ref$namespace === void 0 ? DEFAULT_NAMESPACE : _ref$namespace,\n        prefix = _ref.prefix;\n\n    if (partialFlatMap === void 0) {\n      partialFlatMap = {};\n    }\n\n    if (partialFlatActionType === void 0) {\n      partialFlatActionType = '';\n    }\n\n    function connectNamespace(type) {\n      var _ref2;\n\n      if (!partialFlatActionType) return type;\n      var types = type.toString().split(ACTION_TYPE_DELIMITER);\n      var partials = partialFlatActionType.split(ACTION_TYPE_DELIMITER);\n      return (_ref2 = []).concat.apply(_ref2, partials.map(function (p) {\n        return types.map(function (t) {\n          return \"\" + p + namespace + t;\n        });\n      })).join(ACTION_TYPE_DELIMITER);\n    }\n\n    function connectPrefix(type) {\n      if (partialFlatActionType || !prefix || prefix && new RegExp(\"^\" + prefix + namespace).test(type)) {\n        return type;\n      }\n\n      return \"\" + prefix + namespace + type;\n    }\n\n    ownKeys(map).forEach(function (type) {\n      var nextNamespace = connectPrefix(connectNamespace(type));\n      var mapValue = get(type, map);\n\n      if (predicate(mapValue)) {\n        flatten(mapValue, {\n          namespace: namespace,\n          prefix: prefix\n        }, partialFlatMap, nextNamespace);\n      } else {\n        partialFlatMap[nextNamespace] = mapValue;\n      }\n    });\n    return partialFlatMap;\n  };\n});","import isMap from './isMap';\nexport default function get(key, x) {\n  return isMap(x) ? x.get(key) : x[key];\n}","export default (function (value) {\n  return value;\n});","export default (function (value) {\n  return typeof value === 'function';\n});","export default (function (value) {\n  return typeof Map !== 'undefined' && value instanceof Map;\n});","export default (function (value) {\n  return value === null || value === undefined;\n});","export default (function (value) {\n  if (typeof value !== 'object' || value === null) return false;\n  var proto = value;\n\n  while (Object.getPrototypeOf(proto) !== null) {\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return Object.getPrototypeOf(value) === proto;\n});","import isMap from './isMap';\nexport default function ownKeys(object) {\n  if (isMap(object)) {\n    // We are using loose transforms in babel. Here we are trying to convert an\n    // interable to an array. Loose mode expects everything to already be an\n    // array. The problem is that our eslint rules encourage us to prefer\n    // spread over Array.from.\n    //\n    // Instead of disabling loose mode we simply disable the warning.\n    // eslint-disable-next-line unicorn/prefer-spread\n    return Array.from(object.keys());\n  }\n\n  if (typeof Reflect !== 'undefined' && typeof Reflect.ownKeys === 'function') {\n    return Reflect.ownKeys(object);\n  }\n\n  var keys = Object.getOwnPropertyNames(object);\n\n  if (typeof Object.getOwnPropertySymbols === 'function') {\n    keys = keys.concat(Object.getOwnPropertySymbols(object));\n  }\n\n  return keys;\n}","function createThunkMiddleware(extraArgument) {\n  return function (_ref) {\n    var dispatch = _ref.dispatch,\n        getState = _ref.getState;\n    return function (next) {\n      return function (action) {\n        if (typeof action === 'function') {\n          return action(dispatch, getState, extraArgument);\n        }\n\n        return next(action);\n      };\n    };\n  };\n}\n\nvar thunk = createThunkMiddleware();\nthunk.withExtraArgument = createThunkMiddleware;\n\nexport default thunk;","import $$observable from 'symbol-observable';\n\n/**\n * These are private action types reserved by Redux.\n * For any unknown actions, you must return the current state.\n * If the current state is undefined, you must return the initial state.\n * Do not reference these action types directly in your code.\n */\nvar randomString = function randomString() {\n  return Math.random().toString(36).substring(7).split('').join('.');\n};\n\nvar ActionTypes = {\n  INIT: \"@@redux/INIT\" + randomString(),\n  REPLACE: \"@@redux/REPLACE\" + randomString(),\n  PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {\n    return \"@@redux/PROBE_UNKNOWN_ACTION\" + randomString();\n  }\n};\n\n/**\n * @param {any} obj The object to inspect.\n * @returns {boolean} True if the argument appears to be a plain object.\n */\nfunction isPlainObject(obj) {\n  if (typeof obj !== 'object' || obj === null) return false;\n  var proto = obj;\n\n  while (Object.getPrototypeOf(proto) !== null) {\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return Object.getPrototypeOf(obj) === proto;\n}\n\n/**\n * Creates a Redux store that holds the state tree.\n * The only way to change the data in the store is to call `dispatch()` on it.\n *\n * There should only be a single store in your app. To specify how different\n * parts of the state tree respond to actions, you may combine several reducers\n * into a single reducer function by using `combineReducers`.\n *\n * @param {Function} reducer A function that returns the next state tree, given\n * the current state tree and the action to handle.\n *\n * @param {any} [preloadedState] The initial state. You may optionally specify it\n * to hydrate the state from the server in universal apps, or to restore a\n * previously serialized user session.\n * If you use `combineReducers` to produce the root reducer function, this must be\n * an object with the same shape as `combineReducers` keys.\n *\n * @param {Function} [enhancer] The store enhancer. You may optionally specify it\n * to enhance the store with third-party capabilities such as middleware,\n * time travel, persistence, etc. The only store enhancer that ships with Redux\n * is `applyMiddleware()`.\n *\n * @returns {Store} A Redux store that lets you read the state, dispatch actions\n * and subscribe to changes.\n */\n\nfunction createStore(reducer, preloadedState, enhancer) {\n  var _ref2;\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {\n    throw new Error('It looks like you are passing several store enhancers to ' + 'createStore(). This is not supported. Instead, compose them ' + 'together to a single function.');\n  }\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {\n    enhancer = preloadedState;\n    preloadedState = undefined;\n  }\n\n  if (typeof enhancer !== 'undefined') {\n    if (typeof enhancer !== 'function') {\n      throw new Error('Expected the enhancer to be a function.');\n    }\n\n    return enhancer(createStore)(reducer, preloadedState);\n  }\n\n  if (typeof reducer !== 'function') {\n    throw new Error('Expected the reducer to be a function.');\n  }\n\n  var currentReducer = reducer;\n  var currentState = preloadedState;\n  var currentListeners = [];\n  var nextListeners = currentListeners;\n  var isDispatching = false;\n  /**\n   * This makes a shallow copy of currentListeners so we can use\n   * nextListeners as a temporary list while dispatching.\n   *\n   * This prevents any bugs around consumers calling\n   * subscribe/unsubscribe in the middle of a dispatch.\n   */\n\n  function ensureCanMutateNextListeners() {\n    if (nextListeners === currentListeners) {\n      nextListeners = currentListeners.slice();\n    }\n  }\n  /**\n   * Reads the state tree managed by the store.\n   *\n   * @returns {any} The current state tree of your application.\n   */\n\n\n  function getState() {\n    if (isDispatching) {\n      throw new Error('You may not call store.getState() while the reducer is executing. ' + 'The reducer has already received the state as an argument. ' + 'Pass it down from the top reducer instead of reading it from the store.');\n    }\n\n    return currentState;\n  }\n  /**\n   * Adds a change listener. It will be called any time an action is dispatched,\n   * and some part of the state tree may potentially have changed. You may then\n   * call `getState()` to read the current state tree inside the callback.\n   *\n   * You may call `dispatch()` from a change listener, with the following\n   * caveats:\n   *\n   * 1. The subscriptions are snapshotted just before every `dispatch()` call.\n   * If you subscribe or unsubscribe while the listeners are being invoked, this\n   * will not have any effect on the `dispatch()` that is currently in progress.\n   * However, the next `dispatch()` call, whether nested or not, will use a more\n   * recent snapshot of the subscription list.\n   *\n   * 2. The listener should not expect to see all state changes, as the state\n   * might have been updated multiple times during a nested `dispatch()` before\n   * the listener is called. It is, however, guaranteed that all subscribers\n   * registered before the `dispatch()` started will be called with the latest\n   * state by the time it exits.\n   *\n   * @param {Function} listener A callback to be invoked on every dispatch.\n   * @returns {Function} A function to remove this change listener.\n   */\n\n\n  function subscribe(listener) {\n    if (typeof listener !== 'function') {\n      throw new Error('Expected the listener to be a function.');\n    }\n\n    if (isDispatching) {\n      throw new Error('You may not call store.subscribe() while the reducer is executing. ' + 'If you would like to be notified after the store has been updated, subscribe from a ' + 'component and invoke store.getState() in the callback to access the latest state. ' + 'See https://redux.js.org/api-reference/store#subscribelistener for more details.');\n    }\n\n    var isSubscribed = true;\n    ensureCanMutateNextListeners();\n    nextListeners.push(listener);\n    return function unsubscribe() {\n      if (!isSubscribed) {\n        return;\n      }\n\n      if (isDispatching) {\n        throw new Error('You may not unsubscribe from a store listener while the reducer is executing. ' + 'See https://redux.js.org/api-reference/store#subscribelistener for more details.');\n      }\n\n      isSubscribed = false;\n      ensureCanMutateNextListeners();\n      var index = nextListeners.indexOf(listener);\n      nextListeners.splice(index, 1);\n      currentListeners = null;\n    };\n  }\n  /**\n   * Dispatches an action. It is the only way to trigger a state change.\n   *\n   * The `reducer` function, used to create the store, will be called with the\n   * current state tree and the given `action`. Its return value will\n   * be considered the **next** state of the tree, and the change listeners\n   * will be notified.\n   *\n   * The base implementation only supports plain object actions. If you want to\n   * dispatch a Promise, an Observable, a thunk, or something else, you need to\n   * wrap your store creating function into the corresponding middleware. For\n   * example, see the documentation for the `redux-thunk` package. Even the\n   * middleware will eventually dispatch plain object actions using this method.\n   *\n   * @param {Object} action A plain object representing “what changed”. It is\n   * a good idea to keep actions serializable so you can record and replay user\n   * sessions, or use the time travelling `redux-devtools`. An action must have\n   * a `type` property which may not be `undefined`. It is a good idea to use\n   * string constants for action types.\n   *\n   * @returns {Object} For convenience, the same action object you dispatched.\n   *\n   * Note that, if you use a custom middleware, it may wrap `dispatch()` to\n   * return something else (for example, a Promise you can await).\n   */\n\n\n  function dispatch(action) {\n    if (!isPlainObject(action)) {\n      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');\n    }\n\n    if (typeof action.type === 'undefined') {\n      throw new Error('Actions may not have an undefined \"type\" property. ' + 'Have you misspelled a constant?');\n    }\n\n    if (isDispatching) {\n      throw new Error('Reducers may not dispatch actions.');\n    }\n\n    try {\n      isDispatching = true;\n      currentState = currentReducer(currentState, action);\n    } finally {\n      isDispatching = false;\n    }\n\n    var listeners = currentListeners = nextListeners;\n\n    for (var i = 0; i < listeners.length; i++) {\n      var listener = listeners[i];\n      listener();\n    }\n\n    return action;\n  }\n  /**\n   * Replaces the reducer currently used by the store to calculate the state.\n   *\n   * You might need this if your app implements code splitting and you want to\n   * load some of the reducers dynamically. You might also need this if you\n   * implement a hot reloading mechanism for Redux.\n   *\n   * @param {Function} nextReducer The reducer for the store to use instead.\n   * @returns {void}\n   */\n\n\n  function replaceReducer(nextReducer) {\n    if (typeof nextReducer !== 'function') {\n      throw new Error('Expected the nextReducer to be a function.');\n    }\n\n    currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT.\n    // Any reducers that existed in both the new and old rootReducer\n    // will receive the previous state. This effectively populates\n    // the new state tree with any relevant data from the old one.\n\n    dispatch({\n      type: ActionTypes.REPLACE\n    });\n  }\n  /**\n   * Interoperability point for observable/reactive libraries.\n   * @returns {observable} A minimal observable of state changes.\n   * For more information, see the observable proposal:\n   * https://github.com/tc39/proposal-observable\n   */\n\n\n  function observable() {\n    var _ref;\n\n    var outerSubscribe = subscribe;\n    return _ref = {\n      /**\n       * The minimal observable subscription method.\n       * @param {Object} observer Any object that can be used as an observer.\n       * The observer object should have a `next` method.\n       * @returns {subscription} An object with an `unsubscribe` method that can\n       * be used to unsubscribe the observable from the store, and prevent further\n       * emission of values from the observable.\n       */\n      subscribe: function subscribe(observer) {\n        if (typeof observer !== 'object' || observer === null) {\n          throw new TypeError('Expected the observer to be an object.');\n        }\n\n        function observeState() {\n          if (observer.next) {\n            observer.next(getState());\n          }\n        }\n\n        observeState();\n        var unsubscribe = outerSubscribe(observeState);\n        return {\n          unsubscribe: unsubscribe\n        };\n      }\n    }, _ref[$$observable] = function () {\n      return this;\n    }, _ref;\n  } // When a store is created, an \"INIT\" action is dispatched so that every\n  // reducer returns their initial state. This effectively populates\n  // the initial state tree.\n\n\n  dispatch({\n    type: ActionTypes.INIT\n  });\n  return _ref2 = {\n    dispatch: dispatch,\n    subscribe: subscribe,\n    getState: getState,\n    replaceReducer: replaceReducer\n  }, _ref2[$$observable] = observable, _ref2;\n}\n\n/**\n * Prints a warning in the console if it exists.\n *\n * @param {String} message The warning message.\n * @returns {void}\n */\nfunction warning(message) {\n  /* eslint-disable no-console */\n  if (typeof console !== 'undefined' && typeof console.error === 'function') {\n    console.error(message);\n  }\n  /* eslint-enable no-console */\n\n\n  try {\n    // This error was thrown as a convenience so that if you enable\n    // \"break on all exceptions\" in your console,\n    // it would pause the execution at this line.\n    throw new Error(message);\n  } catch (e) {} // eslint-disable-line no-empty\n\n}\n\nfunction getUndefinedStateErrorMessage(key, action) {\n  var actionType = action && action.type;\n  var actionDescription = actionType && \"action \\\"\" + String(actionType) + \"\\\"\" || 'an action';\n  return \"Given \" + actionDescription + \", reducer \\\"\" + key + \"\\\" returned undefined. \" + \"To ignore an action, you must explicitly return the previous state. \" + \"If you want this reducer to hold no value, you can return null instead of undefined.\";\n}\n\nfunction getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {\n  var reducerKeys = Object.keys(reducers);\n  var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';\n\n  if (reducerKeys.length === 0) {\n    return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';\n  }\n\n  if (!isPlainObject(inputState)) {\n    return \"The \" + argumentName + \" has unexpected type of \\\"\" + {}.toString.call(inputState).match(/\\s([a-z|A-Z]+)/)[1] + \"\\\". Expected argument to be an object with the following \" + (\"keys: \\\"\" + reducerKeys.join('\", \"') + \"\\\"\");\n  }\n\n  var unexpectedKeys = Object.keys(inputState).filter(function (key) {\n    return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];\n  });\n  unexpectedKeys.forEach(function (key) {\n    unexpectedKeyCache[key] = true;\n  });\n  if (action && action.type === ActionTypes.REPLACE) return;\n\n  if (unexpectedKeys.length > 0) {\n    return \"Unexpected \" + (unexpectedKeys.length > 1 ? 'keys' : 'key') + \" \" + (\"\\\"\" + unexpectedKeys.join('\", \"') + \"\\\" found in \" + argumentName + \". \") + \"Expected to find one of the known reducer keys instead: \" + (\"\\\"\" + reducerKeys.join('\", \"') + \"\\\". Unexpected keys will be ignored.\");\n  }\n}\n\nfunction assertReducerShape(reducers) {\n  Object.keys(reducers).forEach(function (key) {\n    var reducer = reducers[key];\n    var initialState = reducer(undefined, {\n      type: ActionTypes.INIT\n    });\n\n    if (typeof initialState === 'undefined') {\n      throw new Error(\"Reducer \\\"\" + key + \"\\\" returned undefined during initialization. \" + \"If the state passed to the reducer is undefined, you must \" + \"explicitly return the initial state. The initial state may \" + \"not be undefined. If you don't want to set a value for this reducer, \" + \"you can use null instead of undefined.\");\n    }\n\n    if (typeof reducer(undefined, {\n      type: ActionTypes.PROBE_UNKNOWN_ACTION()\n    }) === 'undefined') {\n      throw new Error(\"Reducer \\\"\" + key + \"\\\" returned undefined when probed with a random type. \" + (\"Don't try to handle \" + ActionTypes.INIT + \" or other actions in \\\"redux/*\\\" \") + \"namespace. They are considered private. Instead, you must return the \" + \"current state for any unknown actions, unless it is undefined, \" + \"in which case you must return the initial state, regardless of the \" + \"action type. The initial state may not be undefined, but can be null.\");\n    }\n  });\n}\n/**\n * Turns an object whose values are different reducer functions, into a single\n * reducer function. It will call every child reducer, and gather their results\n * into a single state object, whose keys correspond to the keys of the passed\n * reducer functions.\n *\n * @param {Object} reducers An object whose values correspond to different\n * reducer functions that need to be combined into one. One handy way to obtain\n * it is to use ES6 `import * as reducers` syntax. The reducers may never return\n * undefined for any action. Instead, they should return their initial state\n * if the state passed to them was undefined, and the current state for any\n * unrecognized action.\n *\n * @returns {Function} A reducer function that invokes every reducer inside the\n * passed object, and builds a state object with the same shape.\n */\n\n\nfunction combineReducers(reducers) {\n  var reducerKeys = Object.keys(reducers);\n  var finalReducers = {};\n\n  for (var i = 0; i < reducerKeys.length; i++) {\n    var key = reducerKeys[i];\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof reducers[key] === 'undefined') {\n        warning(\"No reducer provided for key \\\"\" + key + \"\\\"\");\n      }\n    }\n\n    if (typeof reducers[key] === 'function') {\n      finalReducers[key] = reducers[key];\n    }\n  }\n\n  var finalReducerKeys = Object.keys(finalReducers); // This is used to make sure we don't warn about the same\n  // keys multiple times.\n\n  var unexpectedKeyCache;\n\n  if (process.env.NODE_ENV !== 'production') {\n    unexpectedKeyCache = {};\n  }\n\n  var shapeAssertionError;\n\n  try {\n    assertReducerShape(finalReducers);\n  } catch (e) {\n    shapeAssertionError = e;\n  }\n\n  return function combination(state, action) {\n    if (state === void 0) {\n      state = {};\n    }\n\n    if (shapeAssertionError) {\n      throw shapeAssertionError;\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);\n\n      if (warningMessage) {\n        warning(warningMessage);\n      }\n    }\n\n    var hasChanged = false;\n    var nextState = {};\n\n    for (var _i = 0; _i < finalReducerKeys.length; _i++) {\n      var _key = finalReducerKeys[_i];\n      var reducer = finalReducers[_key];\n      var previousStateForKey = state[_key];\n      var nextStateForKey = reducer(previousStateForKey, action);\n\n      if (typeof nextStateForKey === 'undefined') {\n        var errorMessage = getUndefinedStateErrorMessage(_key, action);\n        throw new Error(errorMessage);\n      }\n\n      nextState[_key] = nextStateForKey;\n      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;\n    }\n\n    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;\n    return hasChanged ? nextState : state;\n  };\n}\n\nfunction bindActionCreator(actionCreator, dispatch) {\n  return function () {\n    return dispatch(actionCreator.apply(this, arguments));\n  };\n}\n/**\n * Turns an object whose values are action creators, into an object with the\n * same keys, but with every function wrapped into a `dispatch` call so they\n * may be invoked directly. This is just a convenience method, as you can call\n * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.\n *\n * For convenience, you can also pass an action creator as the first argument,\n * and get a dispatch wrapped function in return.\n *\n * @param {Function|Object} actionCreators An object whose values are action\n * creator functions. One handy way to obtain it is to use ES6 `import * as`\n * syntax. You may also pass a single function.\n *\n * @param {Function} dispatch The `dispatch` function available on your Redux\n * store.\n *\n * @returns {Function|Object} The object mimicking the original object, but with\n * every action creator wrapped into the `dispatch` call. If you passed a\n * function as `actionCreators`, the return value will also be a single\n * function.\n */\n\n\nfunction bindActionCreators(actionCreators, dispatch) {\n  if (typeof actionCreators === 'function') {\n    return bindActionCreator(actionCreators, dispatch);\n  }\n\n  if (typeof actionCreators !== 'object' || actionCreators === null) {\n    throw new Error(\"bindActionCreators expected an object or a function, instead received \" + (actionCreators === null ? 'null' : typeof actionCreators) + \". \" + \"Did you write \\\"import ActionCreators from\\\" instead of \\\"import * as ActionCreators from\\\"?\");\n  }\n\n  var boundActionCreators = {};\n\n  for (var key in actionCreators) {\n    var actionCreator = actionCreators[key];\n\n    if (typeof actionCreator === 'function') {\n      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);\n    }\n  }\n\n  return boundActionCreators;\n}\n\nfunction _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\n  return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    keys.push.apply(keys, Object.getOwnPropertySymbols(object));\n  }\n\n  if (enumerableOnly) keys = keys.filter(function (sym) {\n    return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n  });\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(source, true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(source).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\n/**\n * Composes single-argument functions from right to left. The rightmost\n * function can take multiple arguments as it provides the signature for\n * the resulting composite function.\n *\n * @param {...Function} funcs The functions to compose.\n * @returns {Function} A function obtained by composing the argument functions\n * from right to left. For example, compose(f, g, h) is identical to doing\n * (...args) => f(g(h(...args))).\n */\nfunction compose() {\n  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {\n    funcs[_key] = arguments[_key];\n  }\n\n  if (funcs.length === 0) {\n    return function (arg) {\n      return arg;\n    };\n  }\n\n  if (funcs.length === 1) {\n    return funcs[0];\n  }\n\n  return funcs.reduce(function (a, b) {\n    return function () {\n      return a(b.apply(void 0, arguments));\n    };\n  });\n}\n\n/**\n * Creates a store enhancer that applies middleware to the dispatch method\n * of the Redux store. This is handy for a variety of tasks, such as expressing\n * asynchronous actions in a concise manner, or logging every action payload.\n *\n * See `redux-thunk` package as an example of the Redux middleware.\n *\n * Because middleware is potentially asynchronous, this should be the first\n * store enhancer in the composition chain.\n *\n * Note that each middleware will be given the `dispatch` and `getState` functions\n * as named arguments.\n *\n * @param {...Function} middlewares The middleware chain to be applied.\n * @returns {Function} A store enhancer applying the middleware.\n */\n\nfunction applyMiddleware() {\n  for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {\n    middlewares[_key] = arguments[_key];\n  }\n\n  return function (createStore) {\n    return function () {\n      var store = createStore.apply(void 0, arguments);\n\n      var _dispatch = function dispatch() {\n        throw new Error('Dispatching while constructing your middleware is not allowed. ' + 'Other middleware would not be applied to this dispatch.');\n      };\n\n      var middlewareAPI = {\n        getState: store.getState,\n        dispatch: function dispatch() {\n          return _dispatch.apply(void 0, arguments);\n        }\n      };\n      var chain = middlewares.map(function (middleware) {\n        return middleware(middlewareAPI);\n      });\n      _dispatch = compose.apply(void 0, chain)(store.dispatch);\n      return _objectSpread2({}, store, {\n        dispatch: _dispatch\n      });\n    };\n  };\n}\n\n/*\n * This is a dummy function to check if the function name has been altered by minification.\n * If the function has been minified and NODE_ENV !== 'production', warn the user.\n */\n\nfunction isCrushed() {}\n\nif (process.env.NODE_ENV !== 'production' && typeof isCrushed.name === 'string' && isCrushed.name !== 'isCrushed') {\n  warning('You are currently using minified code outside of NODE_ENV === \"production\". ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or setting mode to production in webpack (https://webpack.js.org/concepts/mode/) ' + 'to ensure you have the correct code for your production build.');\n}\n\nexport { ActionTypes as __DO_NOT_USE__ActionTypes, applyMiddleware, bindActionCreators, combineReducers, compose, createStore };\n"],"sourceRoot":""}