@oj-module/cli 0.2.64 → 0.2.66

package/shell-dist/assets/react-query.3rln45ow00.js

@@ -0,0 +1 @@
+var __defProp=Object.defineProperty;var __typeError=msg=>{throw TypeError(msg)};var __export=(target,all)=>{for(var name in all)__defProp(target,name,{get:all[name],enumerable:!0})};var __accessCheck=(obj,member,msg)=>member.has(obj)||__typeError("Cannot "+msg);var __privateGet=(obj,member,getter)=>(__accessCheck(obj,member,"read from private field"),getter?getter.call(obj):member.get(obj)),__privateAdd=(obj,member,value)=>member.has(obj)?__typeError("Cannot add the same private member more than once"):member instanceof WeakSet?member.add(obj):member.set(obj,value),__privateSet=(obj,member,value,setter)=>(__accessCheck(obj,member,"write to private field"),setter?setter.call(obj,value):member.set(obj,value),value),__privateMethod=(obj,member,method)=>(__accessCheck(obj,member,"access private method"),method);var __privateWrapper=(obj,member,setter,getter)=>({set _(value){__privateSet(obj,member,value,setter)},get _(){return __privateGet(obj,member,getter)}});var modern_exports={};__export(modern_exports,{CancelledError:()=>CancelledError,HydrationBoundary:()=>HydrationBoundary,InfiniteQueryObserver:()=>InfiniteQueryObserver,IsRestoringProvider:()=>IsRestoringProvider,Mutation:()=>Mutation,MutationCache:()=>MutationCache,MutationObserver:()=>MutationObserver,QueriesObserver:()=>QueriesObserver,Query:()=>Query,QueryCache:()=>QueryCache,QueryClient:()=>QueryClient,QueryClientContext:()=>QueryClientContext,QueryClientProvider:()=>QueryClientProvider,QueryErrorResetBoundary:()=>QueryErrorResetBoundary,QueryObserver:()=>QueryObserver,dataTagErrorSymbol:()=>dataTagErrorSymbol,dataTagSymbol:()=>dataTagSymbol,defaultScheduler:()=>defaultScheduler,defaultShouldDehydrateMutation:()=>defaultShouldDehydrateMutation,defaultShouldDehydrateQuery:()=>defaultShouldDehydrateQuery,dehydrate:()=>dehydrate,dehydrateQuery:()=>dehydrateQuery,environmentManager:()=>environmentManager,experimental_streamedQuery:()=>streamedQuery,focusManager:()=>focusManager,hashKey:()=>hashKey,hydrate:()=>hydrate,infiniteQueryOptions:()=>infiniteQueryOptions,isCancelledError:()=>isCancelledError,isServer:()=>isServer,keepPreviousData:()=>keepPreviousData,matchMutation:()=>matchMutation,matchQuery:()=>matchQuery,mutationOptions:()=>mutationOptions,noop:()=>noop,notifyManager:()=>notifyManager,onlineManager:()=>onlineManager,partialMatchKey:()=>partialMatchKey,queryOptions:()=>queryOptions,replaceEqualDeep:()=>replaceEqualDeep,shouldThrowError:()=>shouldThrowError,skipToken:()=>skipToken,timeoutManager:()=>timeoutManager,unsetMarker:()=>unsetMarker,useInfiniteQuery:()=>useInfiniteQuery,useIsFetching:()=>useIsFetching,useIsMutating:()=>useIsMutating,useIsRestoring:()=>useIsRestoring,useMutation:()=>useMutation,useMutationState:()=>useMutationState,usePrefetchInfiniteQuery:()=>usePrefetchInfiniteQuery,usePrefetchQuery:()=>usePrefetchQuery,useQueries:()=>useQueries,useQuery:()=>useQuery,useQueryClient:()=>useQueryClient,useQueryErrorResetBoundary:()=>useQueryErrorResetBoundary,useSuspenseInfiniteQuery:()=>useSuspenseInfiniteQuery,useSuspenseQueries:()=>useSuspenseQueries,useSuspenseQuery:()=>useSuspenseQuery});import*as React from"react";import{jsx}from"react/jsx-runtime";var QueryClientContext=React.createContext(void 0),useQueryClient=queryClient=>{let client=React.useContext(QueryClientContext);if(queryClient)return queryClient;if(!client)throw new Error("No QueryClient set, use QueryClientProvider to set one");return client},QueryClientProvider=({client,children})=>(React.useEffect(()=>(client.mount(),()=>{client.unmount()}),[client]),jsx(QueryClientContext.Provider,{value:client,children}));import*as React2 from"react";var defaultTimeoutProvider={setTimeout:(callback,delay)=>setTimeout(callback,delay),clearTimeout:timeoutId=>clearTimeout(timeoutId),setInterval:(callback,delay)=>setInterval(callback,delay),clearInterval:intervalId=>clearInterval(intervalId)},_provider,_providerCalled,_a,TimeoutManager=(_a=class{constructor(){__privateAdd(this,_provider,defaultTimeoutProvider);__privateAdd(this,_providerCalled,!1)}setTimeoutProvider(provider){__privateSet(this,_provider,provider)}setTimeout(callback,delay){return __privateGet(this,_provider).setTimeout(callback,delay)}clearTimeout(timeoutId){__privateGet(this,_provider).clearTimeout(timeoutId)}setInterval(callback,delay){return __privateGet(this,_provider).setInterval(callback,delay)}clearInterval(intervalId){__privateGet(this,_provider).clearInterval(intervalId)}},_provider=new WeakMap,_providerCalled=new WeakMap,_a),timeoutManager=new TimeoutManager;function systemSetTimeoutZero(callback){setTimeout(callback,0)}var isServer=typeof window>"u"||"Deno"in globalThis;function noop(){}function functionalUpdate(updater,input){return typeof updater=="function"?updater(input):updater}function isValidTimeout(value){return typeof value=="number"&&value>=0&&value!==1/0}function timeUntilStale(updatedAt,staleTime){return Math.max(updatedAt+(staleTime||0)-Date.now(),0)}function resolveQueryValue(value,query){return typeof value=="function"?value(query):value}function matchQuery(filters,query){let{type="all",exact,fetchStatus,predicate,queryKey,stale}=filters;if(queryKey){if(exact){if(query.queryHash!==hashQueryKeyByOptions(queryKey,query.options))return!1}else if(!partialMatchKey(query.queryKey,queryKey))return!1}if(type!=="all"){let isActive=query.isActive();if(type==="active"&&!isActive||type==="inactive"&&isActive)return!1}return!(typeof stale=="boolean"&&query.isStale()!==stale||fetchStatus&&fetchStatus!==query.state.fetchStatus||predicate&&!predicate(query))}function matchMutation(filters,mutation){let{exact,status,predicate,mutationKey}=filters;if(mutationKey){if(!mutation.options.mutationKey)return!1;if(exact){if(hashKey(mutation.options.mutationKey)!==hashKey(mutationKey))return!1}else if(!partialMatchKey(mutation.options.mutationKey,mutationKey))return!1}return!(status&&mutation.state.status!==status||predicate&&!predicate(mutation))}function hashQueryKeyByOptions(queryKey,options){return(options?.queryKeyHashFn||hashKey)(queryKey)}function hashKey(queryKey){return JSON.stringify(queryKey,(_,val)=>isPlainObject(val)?Object.keys(val).sort().reduce((result,key)=>(result[key]=val[key],result),{}):val)}function partialMatchKey(a,b){if(a===b)return!0;if(typeof a!=typeof b)return!1;if(a&&b&&typeof a=="object"&&typeof b=="object"){if(Array.isArray(a)&&Array.isArray(b)){for(let i=0;i<b.length;i++)if(!partialMatchKey(a[i],b[i]))return!1;return!0}let bKeys=Object.keys(b);for(let key of bKeys)if(!partialMatchKey(a[key],b[key]))return!1;return!0}return!1}var hasOwn=Object.prototype.hasOwnProperty;function replaceEqualDeep(a,b,depth=0){if(a===b)return a;if(depth>500)return b;let array=isPlainArray(a)&&isPlainArray(b);if(!array&&!(isPlainObject(a)&&isPlainObject(b)))return b;let aSize=(array?a:Object.keys(a)).length,bItems=array?b:Object.keys(b),bSize=bItems.length,copy=array?new Array(bSize):{},equalItems=0;for(let i=0;i<bSize;i++){let key=array?i:bItems[i],aItem=a[key],bItem=b[key];if(aItem===bItem){copy[key]=aItem,(array?i<aSize:hasOwn.call(a,key))&&equalItems++;continue}if(aItem===null||bItem===null||typeof aItem!="object"||typeof bItem!="object"){copy[key]=bItem;continue}let v=replaceEqualDeep(aItem,bItem,depth+1);copy[key]=v,v===aItem&&equalItems++}return aSize===bSize&&equalItems===aSize?a:copy}function shallowEqualObjects(a,b){if(!b||Object.keys(a).length!==Object.keys(b).length)return!1;for(let key in a)if(a[key]!==b[key])return!1;return!0}function isPlainArray(value){return Array.isArray(value)&&value.length===Object.keys(value).length}function isPlainObject(o){if(!hasObjectPrototype(o))return!1;let ctor=o.constructor;if(ctor===void 0)return!0;let prot=ctor.prototype;return!(!hasObjectPrototype(prot)||!prot.hasOwnProperty("isPrototypeOf")||Object.getPrototypeOf(o)!==Object.prototype)}function hasObjectPrototype(o){return Object.prototype.toString.call(o)==="[object Object]"}function sleep(timeout){return new Promise(resolve=>{timeoutManager.setTimeout(resolve,timeout)})}function replaceData(prevData,data,options){return typeof options.structuralSharing=="function"?options.structuralSharing(prevData,data):options.structuralSharing!==!1?replaceEqualDeep(prevData,data):data}function keepPreviousData(previousData){return previousData}function addToEnd(items,item,max=0){let newItems=[...items,item];return max&&newItems.length>max?newItems.slice(1):newItems}function addToStart(items,item,max=0){let newItems=[item,...items];return max&&newItems.length>max?newItems.slice(0,-1):newItems}var skipToken=Symbol();function ensureQueryFn(options,fetchOptions){return!options.queryFn&&fetchOptions?.initialPromise?()=>fetchOptions.initialPromise:!options.queryFn||options.queryFn===skipToken?()=>Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`)):options.queryFn}function shouldThrowError(throwOnError,params){return typeof throwOnError=="function"?throwOnError(...params):!!throwOnError}function addConsumeAwareSignal(object,getSignal,onCancelled){let consumed=!1,signal;return Object.defineProperty(object,"signal",{enumerable:!0,get:()=>(signal??(signal=getSignal()),consumed||(consumed=!0,signal.aborted?onCancelled():signal.addEventListener("abort",onCancelled,{once:!0})),signal)}),object}var isServerFn=()=>isServer,isServer2=()=>isServerFn(),environmentManager={isServer:isServer2,setIsServer(isServerValue){isServerFn=isServerValue}};var Subscribable=class{constructor(){this.listeners=new Set,this.subscribe=this.subscribe.bind(this)}subscribe(listener){return this.listeners.add(listener),this.onSubscribe(),()=>{this.listeners.delete(listener),this.onUnsubscribe()}}hasListeners(){return this.listeners.size>0}onSubscribe(){}onUnsubscribe(){}};var _focused,_cleanup,_setup,_a2,FocusManager=(_a2=class extends Subscribable{constructor(){super();__privateAdd(this,_focused);__privateAdd(this,_cleanup);__privateAdd(this,_setup);__privateSet(this,_setup,onFocus=>{if(typeof window<"u"&&window.addEventListener){let listener=()=>onFocus();return window.addEventListener("visibilitychange",listener,!1),()=>{window.removeEventListener("visibilitychange",listener)}}})}onSubscribe(){__privateGet(this,_cleanup)||this.setEventListener(__privateGet(this,_setup))}onUnsubscribe(){var _a13;this.hasListeners()||((_a13=__privateGet(this,_cleanup))==null||_a13.call(this),__privateSet(this,_cleanup,void 0))}setEventListener(setup){var _a13;__privateSet(this,_setup,setup),(_a13=__privateGet(this,_cleanup))==null||_a13.call(this),__privateSet(this,_cleanup,setup(focused=>{typeof focused=="boolean"?this.setFocused(focused):this.onFocus()}))}setFocused(focused){__privateGet(this,_focused)!==focused&&(__privateSet(this,_focused,focused),this.onFocus())}onFocus(){let isFocused=this.isFocused();this.listeners.forEach(listener=>{listener(isFocused)})}isFocused(){return typeof __privateGet(this,_focused)=="boolean"?__privateGet(this,_focused):globalThis.document?.visibilityState!=="hidden"}},_focused=new WeakMap,_cleanup=new WeakMap,_setup=new WeakMap,_a2),focusManager=new FocusManager;function tryResolveSync(promise){let data;if(promise.then(result=>(data=result,result),noop)?.catch?.(noop),data!==void 0)return{data}}function dehydrateMutation(mutation){return{mutationKey:mutation.options.mutationKey,state:mutation.state,...mutation.options.scope&&{scope:mutation.options.scope},...mutation.meta&&{meta:mutation.meta}}}function dehydratePromise(query,serializeData,shouldRedactErrors){let promise=query.promise?.then(serializeData).catch(error=>shouldRedactErrors?.(error)===!1?Promise.reject(error):Promise.reject(new Error("redacted")));return promise?.catch(noop),promise}function dehydrateQuery(query,serializeData,shouldRedactErrors){return{dehydratedAt:Date.now(),state:{...query.state,...query.state.data!==void 0&&{data:serializeData?serializeData(query.state.data):query.state.data}},queryKey:query.queryKey,queryHash:query.queryHash,...query.state.status==="pending"&&{promise:dehydratePromise(query,serializeData,shouldRedactErrors)},...query.meta&&{meta:query.meta},...query.queryType&&{queryType:query.queryType}}}function defaultShouldDehydrateMutation(mutation){return mutation.state.isPaused}function defaultShouldDehydrateQuery(query){return query.state.status==="success"}function dehydrate(client,options={}){let filterMutation=options.shouldDehydrateMutation??client.getDefaultOptions().dehydrate?.shouldDehydrateMutation??defaultShouldDehydrateMutation,mutations=client.getMutationCache().getAll().flatMap(mutation=>filterMutation(mutation)?[dehydrateMutation(mutation)]:[]),filterQuery=options.shouldDehydrateQuery??client.getDefaultOptions().dehydrate?.shouldDehydrateQuery??defaultShouldDehydrateQuery,shouldRedactErrors=options.shouldRedactErrors??client.getDefaultOptions().dehydrate?.shouldRedactErrors,serializeData=options.serializeData??client.getDefaultOptions().dehydrate?.serializeData;return{mutations,queries:client.getQueryCache().getAll().flatMap(query=>filterQuery(query)?[dehydrateQuery(query,serializeData,shouldRedactErrors)]:[])}}function hydrate(client,dehydratedState,options){let mutationCache=client.getMutationCache(),queryCache=client.getQueryCache(),deserializeData=options?.defaultOptions?.deserializeData??client.getDefaultOptions().hydrate?.deserializeData;dehydratedState.mutations?.forEach(({state,...mutationOptions2})=>{mutationCache.build(client,{...client.getDefaultOptions().hydrate?.mutations,...options?.defaultOptions?.mutations,...mutationOptions2},state)}),dehydratedState.queries?.forEach(({queryKey,state,queryHash,meta,promise,dehydratedAt,queryType})=>{let syncData=promise?tryResolveSync(promise):void 0,rawData=state.data===void 0?syncData?.data:state.data,data=rawData===void 0?rawData:deserializeData?deserializeData(rawData):rawData,query=queryCache.get(queryHash),existingQueryIsPending=query?.state.status==="pending",existingQueryIsFetching=query?.state.fetchStatus==="fetching";if(query){let hasNewerSyncData=syncData&&dehydratedAt!==void 0&&dehydratedAt>query.state.dataUpdatedAt;if(state.dataUpdatedAt>query.state.dataUpdatedAt||hasNewerSyncData){let{fetchStatus:_ignored,...serializedState}=state;query.setState({...serializedState,data,...state.status==="pending"&&data!==void 0&&{status:"success",dataUpdatedAt:dehydratedAt??Date.now(),...!existingQueryIsFetching&&{fetchStatus:"idle"}}})}}else query=queryCache.build(client,{...client.getDefaultOptions().hydrate?.queries,...options?.defaultOptions?.queries,queryKey,queryHash,meta,_type:queryType},{...state,data,fetchStatus:"idle",status:state.status==="pending"&&data!==void 0?"success":state.status,...state.status==="pending"&&data!==void 0&&{dataUpdatedAt:dehydratedAt??Date.now()}});promise&&!syncData&&!existingQueryIsPending&&!existingQueryIsFetching&&(dehydratedAt===void 0||dehydratedAt>query.state.dataUpdatedAt)&&query.fetch(void 0,{initialPromise:Promise.resolve(promise).then(deserializeData)}).catch(noop)})}var defaultScheduler=systemSetTimeoutZero;function createNotifyManager(){let queue=[],transactions=0,notifyFn=callback=>{callback()},batchNotifyFn=callback=>{callback()},scheduleFn=defaultScheduler,schedule=callback=>{transactions?queue.push(callback):scheduleFn(()=>{notifyFn(callback)})},flush=()=>{let originalQueue=queue;queue=[],originalQueue.length&&scheduleFn(()=>{batchNotifyFn(()=>{originalQueue.forEach(callback=>{notifyFn(callback)})})})};return{batch:callback=>{let result;transactions++;try{result=callback()}finally{transactions--,transactions||flush()}return result},batchCalls:callback=>(...args)=>{schedule(()=>{callback(...args)})},schedule,setNotifyFunction:fn=>{notifyFn=fn},setBatchNotifyFunction:fn=>{batchNotifyFn=fn},setScheduler:fn=>{scheduleFn=fn}}}var notifyManager=createNotifyManager();var _online,_cleanup2,_setup2,_a3,OnlineManager=(_a3=class extends Subscribable{constructor(){super();__privateAdd(this,_online,!0);__privateAdd(this,_cleanup2);__privateAdd(this,_setup2);__privateSet(this,_setup2,onOnline=>{if(typeof window<"u"&&window.addEventListener){let onlineListener=()=>onOnline(!0),offlineListener=()=>onOnline(!1);return window.addEventListener("online",onlineListener,!1),window.addEventListener("offline",offlineListener,!1),()=>{window.removeEventListener("online",onlineListener),window.removeEventListener("offline",offlineListener)}}})}onSubscribe(){__privateGet(this,_cleanup2)||this.setEventListener(__privateGet(this,_setup2))}onUnsubscribe(){var _a13;this.hasListeners()||((_a13=__privateGet(this,_cleanup2))==null||_a13.call(this),__privateSet(this,_cleanup2,void 0))}setEventListener(setup){var _a13;__privateSet(this,_setup2,setup),(_a13=__privateGet(this,_cleanup2))==null||_a13.call(this),__privateSet(this,_cleanup2,setup(this.setOnline.bind(this)))}setOnline(online){__privateGet(this,_online)!==online&&(__privateSet(this,_online,online),this.listeners.forEach(listener=>{listener(online)}))}isOnline(){return __privateGet(this,_online)}},_online=new WeakMap,_cleanup2=new WeakMap,_setup2=new WeakMap,_a3),onlineManager=new OnlineManager;function defaultRetryDelay(failureCount){return Math.min(1e3*2**failureCount,3e4)}function canFetch(networkMode){return(networkMode??"online")==="online"?onlineManager.isOnline():!0}var CancelledError=class extends Error{constructor(options){super("CancelledError"),this.revert=options?.revert,this.silent=options?.silent}};function isCancelledError(value){return value instanceof CancelledError}function createRetryer(config){let isRetryCancelled=!1,failureCount=0,continueFn,status="pending",promiseResolve,promiseReject,promise=new Promise((resolve2,reject2)=>{promiseResolve=resolve2,promiseReject=reject2});promise.catch(noop);let isResolved=()=>status!=="pending",cancel=cancelOptions=>{if(!isResolved()){let error=new CancelledError(cancelOptions);reject(error),config.onCancel?.(error)}},cancelRetry=()=>{isRetryCancelled=!0},continueRetry=()=>{isRetryCancelled=!1},canContinue=()=>focusManager.isFocused()&&(config.networkMode==="always"||onlineManager.isOnline())&&config.canRun(),canStart=()=>canFetch(config.networkMode)&&config.canRun(),resolve=value=>{isResolved()||(continueFn?.(),status="resolved",promiseResolve(value))},reject=value=>{isResolved()||(continueFn?.(),status="rejected",promiseReject(value))},pause=()=>new Promise(continueResolve=>{continueFn=value=>{(isResolved()||canContinue())&&continueResolve(value)},config.onPause?.()}).then(()=>{continueFn=void 0,isResolved()||config.onContinue?.()}),run=()=>{if(isResolved())return;let promiseOrValue,initialPromise=failureCount===0?config.initialPromise:void 0;try{promiseOrValue=initialPromise??config.fn()}catch(error){promiseOrValue=Promise.reject(error)}Promise.resolve(promiseOrValue).then(resolve).catch(error=>{if(isResolved())return;let retry=config.retry??(isServer2()?0:3),retryDelay=config.retryDelay??defaultRetryDelay,delay=typeof retryDelay=="function"?retryDelay(failureCount,error):retryDelay,shouldRetry=retry===!0||typeof retry=="number"&&failureCount<retry||typeof retry=="function"&&retry(failureCount,error);if(isRetryCancelled||!shouldRetry){reject(error);return}failureCount++,config.onFail?.(failureCount,error),sleep(delay).then(()=>canContinue()?void 0:pause()).then(()=>{isRetryCancelled?reject(error):run()})})};return{promise,status:()=>status,cancel,continue:()=>(continueFn?.(),promise),cancelRetry,continueRetry,canStart,start:()=>(canStart()?run():pause().then(run),promise)}}var _gcTimeout,_a4,Removable=(_a4=class{constructor(){__privateAdd(this,_gcTimeout)}destroy(){this.clearGcTimeout()}scheduleGc(){this.clearGcTimeout(),isValidTimeout(this.gcTime)&&__privateSet(this,_gcTimeout,timeoutManager.setTimeout(()=>{this.optionalRemove()},this.gcTime))}updateGcTime(newGcTime){this.gcTime=Math.max(this.gcTime||0,newGcTime??(isServer2()?1/0:3e5))}clearGcTimeout(){__privateGet(this,_gcTimeout)!==void 0&&(timeoutManager.clearTimeout(__privateGet(this,_gcTimeout)),__privateSet(this,_gcTimeout,void 0))}},_gcTimeout=new WeakMap,_a4);function infiniteQueryBehavior(pages){return{onFetch:(context,query)=>{let options=context.options,direction=context.fetchOptions?.meta?.fetchMore?.direction,oldPages=context.state.data?.pages||[],oldPageParams=context.state.data?.pageParams||[],result={pages:[],pageParams:[]},currentPage=0,fetchFn=async()=>{let cancelled=!1,addSignalProperty=object=>{addConsumeAwareSignal(object,()=>context.signal,()=>cancelled=!0)},queryFn=ensureQueryFn(context.options,context.fetchOptions),fetchPage=async(data,param,previous)=>{if(cancelled)return Promise.reject(context.signal.reason);if(param==null&&data.pages.length)return Promise.resolve(data);let queryFnContext=(()=>{let queryFnContext2={client:context.client,queryKey:context.queryKey,pageParam:param,direction:previous?"backward":"forward",meta:context.options.meta};return addSignalProperty(queryFnContext2),queryFnContext2})(),page=await queryFn(queryFnContext),{maxPages}=context.options,addTo=previous?addToStart:addToEnd;return{pages:addTo(data.pages,page,maxPages),pageParams:addTo(data.pageParams,param,maxPages)}};if(direction&&oldPages.length){let previous=direction==="backward",pageParamFn=previous?getPreviousPageParam:getNextPageParam,oldData={pages:oldPages,pageParams:oldPageParams};result=await fetchPage(oldData,pageParamFn(options,oldData),previous)}else{let remainingPages=pages??oldPages.length;do{let param=currentPage===0?oldPageParams[0]??options.initialPageParam:getNextPageParam(options,result);if(currentPage>0&&param==null)break;result=await fetchPage(result,param),currentPage++}while(currentPage<remainingPages)}return result};context.options.persister?context.fetchFn=()=>context.options.persister?.(fetchFn,{client:context.client,queryKey:context.queryKey,meta:context.options.meta,signal:context.signal},query):context.fetchFn=fetchFn}}}function getNextPageParam(options,{pages,pageParams}){let lastIndex=pages.length-1;return pages.length>0?options.getNextPageParam(pages[lastIndex],pages,pageParams[lastIndex],pageParams):void 0}function getPreviousPageParam(options,{pages,pageParams}){return pages.length>0?options.getPreviousPageParam?.(pages[0],pages,pageParams[0],pageParams):void 0}function hasNextPage(options,data){return data?getNextPageParam(options,data)!=null:!1}function hasPreviousPage(options,data){return!data||!options.getPreviousPageParam?!1:getPreviousPageParam(options,data)!=null}var _queryType,_initialState,_revertState,_cache,_client,_retryer,_defaultOptions,_abortSignalConsumed,_Query_instances,dispatch_fn,_a5,Query=(_a5=class extends Removable{constructor(config){super();__privateAdd(this,_Query_instances);__privateAdd(this,_queryType);__privateAdd(this,_initialState);__privateAdd(this,_revertState);__privateAdd(this,_cache);__privateAdd(this,_client);__privateAdd(this,_retryer);__privateAdd(this,_defaultOptions);__privateAdd(this,_abortSignalConsumed);__privateSet(this,_abortSignalConsumed,!1),__privateSet(this,_defaultOptions,config.defaultOptions),this.setOptions(config.options),this.observers=[],__privateSet(this,_client,config.client),__privateSet(this,_cache,__privateGet(this,_client).getQueryCache()),this.queryKey=config.queryKey,this.queryHash=config.queryHash,__privateSet(this,_initialState,getDefaultState(this.options)),this.state=config.state??__privateGet(this,_initialState),this.scheduleGc()}get meta(){return this.options.meta}get queryType(){return __privateGet(this,_queryType)}get promise(){return __privateGet(this,_retryer)?.promise}setOptions(options){if(this.options={...__privateGet(this,_defaultOptions),...options},options?._type&&__privateSet(this,_queryType,options._type),this.updateGcTime(this.options.gcTime),this.state&&this.state.data===void 0){let defaultState=getDefaultState(this.options);defaultState.data!==void 0&&(this.setState(successState(defaultState.data,defaultState.dataUpdatedAt)),__privateSet(this,_initialState,defaultState))}}optionalRemove(){!this.observers.length&&this.state.fetchStatus==="idle"&&__privateGet(this,_cache).remove(this)}setData(newData,options){let data=replaceData(this.state.data,newData,this.options);return __privateMethod(this,_Query_instances,dispatch_fn).call(this,{data,type:"success",dataUpdatedAt:options?.updatedAt,manual:options?.manual}),data}setState(state){__privateMethod(this,_Query_instances,dispatch_fn).call(this,{type:"setState",state})}cancel(options){let promise=__privateGet(this,_retryer)?.promise;return __privateGet(this,_retryer)?.cancel(options),promise?promise.then(noop).catch(noop):Promise.resolve()}destroy(){super.destroy(),this.cancel({silent:!0})}get resetState(){return __privateGet(this,_initialState)}reset(){this.destroy(),this.setState(this.resetState)}isActive(){return this.observers.some(observer=>resolveQueryValue(observer.options.enabled,this)!==!1)}isDisabled(){return this.getObserversCount()>0?!this.isActive():this.options.queryFn===skipToken||!this.isFetched()}isFetched(){return this.state.dataUpdateCount+this.state.errorUpdateCount>0}isStatic(){return this.getObserversCount()>0?this.observers.some(observer=>resolveQueryValue(observer.options.staleTime,this)==="static"):!1}isStale(){return this.getObserversCount()>0?this.observers.some(observer=>observer.getCurrentResult().isStale):this.state.data===void 0||this.state.isInvalidated}isStaleByTime(staleTime=0){return this.state.data===void 0?!0:staleTime==="static"?!1:this.state.isInvalidated?!0:!timeUntilStale(this.state.dataUpdatedAt,staleTime)}onFocus(){this.observers.find(x=>x.shouldFetchOnWindowFocus())?.refetch({cancelRefetch:!1}),__privateGet(this,_retryer)?.continue()}onOnline(){this.observers.find(x=>x.shouldFetchOnReconnect())?.refetch({cancelRefetch:!1}),__privateGet(this,_retryer)?.continue()}addObserver(observer){this.observers.includes(observer)||(this.observers.push(observer),this.clearGcTimeout(),__privateGet(this,_cache).notify({type:"observerAdded",query:this,observer}))}removeObserver(observer){let index=this.observers.indexOf(observer);index!==-1&&(this.observers.splice(index,1),this.observers.length||(__privateGet(this,_retryer)&&(__privateGet(this,_abortSignalConsumed)||this.state.fetchStatus==="paused"&&this.state.status==="pending"?__privateGet(this,_retryer).cancel({revert:!0}):__privateGet(this,_retryer).cancelRetry()),this.scheduleGc()),__privateGet(this,_cache).notify({type:"observerRemoved",query:this,observer}))}getObserversCount(){return this.observers.length}invalidate(){this.state.isInvalidated||__privateMethod(this,_Query_instances,dispatch_fn).call(this,{type:"invalidate"})}async fetch(options,fetchOptions){if(this.state.fetchStatus!=="idle"&&__privateGet(this,_retryer)?.status()!=="rejected"){if(this.state.data!==void 0&&fetchOptions?.cancelRefetch)this.cancel({silent:!0});else if(__privateGet(this,_retryer))return __privateGet(this,_retryer).continueRetry(),__privateGet(this,_retryer).promise}if(options&&this.setOptions(options),!this.options.queryFn){let observer=this.observers.find(x=>x.options.queryFn);observer&&this.setOptions(observer.options)}let abortController=new AbortController,addSignalProperty=object=>{Object.defineProperty(object,"signal",{enumerable:!0,get:()=>(__privateSet(this,_abortSignalConsumed,!0),abortController.signal)})},fetchFn=()=>{let queryFn=ensureQueryFn(this.options,fetchOptions),queryFnContext=(()=>{let queryFnContext2={client:__privateGet(this,_client),queryKey:this.queryKey,meta:this.meta};return addSignalProperty(queryFnContext2),queryFnContext2})();return __privateSet(this,_abortSignalConsumed,!1),this.options.persister?this.options.persister(queryFn,queryFnContext,this):queryFn(queryFnContext)},context=(()=>{let context2={fetchOptions,options:this.options,queryKey:this.queryKey,client:__privateGet(this,_client),state:this.state,fetchFn};return addSignalProperty(context2),context2})();(__privateGet(this,_queryType)==="infinite"?infiniteQueryBehavior(this.options.pages):this.options.behavior)?.onFetch(context,this),__privateSet(this,_revertState,this.state),(this.state.fetchStatus==="idle"||this.state.fetchMeta!==context.fetchOptions?.meta)&&__privateMethod(this,_Query_instances,dispatch_fn).call(this,{type:"fetch",meta:context.fetchOptions?.meta});let retryer=__privateSet(this,_retryer,createRetryer({initialPromise:fetchOptions?.initialPromise,fn:context.fetchFn,onCancel:error=>{error instanceof CancelledError&&error.revert&&this.setState({...__privateGet(this,_revertState),fetchStatus:"idle"}),abortController.abort()},onFail:(failureCount,error)=>{__privateMethod(this,_Query_instances,dispatch_fn).call(this,{type:"failed",failureCount,error})},onPause:()=>{__privateMethod(this,_Query_instances,dispatch_fn).call(this,{type:"pause"})},onContinue:()=>{__privateMethod(this,_Query_instances,dispatch_fn).call(this,{type:"continue"})},retry:context.options.retry,retryDelay:context.options.retryDelay,networkMode:context.options.networkMode,canRun:()=>!0}));try{let data=await retryer.start();if(data===void 0)throw new Error(`${this.queryHash} data is undefined`);return this.setData(data),__privateGet(this,_cache).config.onSuccess?.(data,this),__privateGet(this,_cache).config.onSettled?.(data,this.state.error,this),data}catch(error){if(error instanceof CancelledError){if(error.silent)return __privateGet(this,_retryer).promise;if(error.revert){if(this.state.data===void 0)throw error;return this.state.data}}throw __privateMethod(this,_Query_instances,dispatch_fn).call(this,{type:"error",error}),__privateGet(this,_cache).config.onError?.(error,this),__privateGet(this,_cache).config.onSettled?.(this.state.data,error,this),error}finally{__privateGet(this,_retryer)===retryer&&__privateSet(this,_retryer,void 0),this.scheduleGc()}}},_queryType=new WeakMap,_initialState=new WeakMap,_revertState=new WeakMap,_cache=new WeakMap,_client=new WeakMap,_retryer=new WeakMap,_defaultOptions=new WeakMap,_abortSignalConsumed=new WeakMap,_Query_instances=new WeakSet,dispatch_fn=function(action){let reducer=state=>{switch(action.type){case"failed":return{...state,fetchFailureCount:action.failureCount,fetchFailureReason:action.error};case"pause":return{...state,fetchStatus:"paused"};case"continue":return{...state,fetchStatus:"fetching"};case"fetch":return{...state,...fetchState(state.data,this.options),fetchMeta:action.meta??null};case"success":let newState={...state,...successState(action.data,action.dataUpdatedAt),dataUpdateCount:state.dataUpdateCount+1,...!action.manual&&{fetchStatus:"idle",fetchFailureCount:0,fetchFailureReason:null}};return __privateSet(this,_revertState,action.manual?newState:void 0),newState;case"error":let error=action.error;return{...state,error,errorUpdateCount:state.errorUpdateCount+1,errorUpdatedAt:Date.now(),fetchFailureCount:state.fetchFailureCount+1,fetchFailureReason:error,fetchStatus:"idle",status:"error",isInvalidated:!0};case"invalidate":return{...state,isInvalidated:!0};case"setState":return{...state,...action.state}}};this.state=reducer(this.state),notifyManager.batch(()=>{this.observers.slice().forEach(observer=>{observer.onQueryUpdate()}),__privateGet(this,_cache).notify({query:this,type:"updated",action})})},_a5);function fetchState(data,options){return{fetchFailureCount:0,fetchFailureReason:null,fetchStatus:canFetch(options.networkMode)?"fetching":"paused",...data===void 0&&{error:null,status:"pending"}}}function successState(data,dataUpdatedAt){return{data,dataUpdatedAt:dataUpdatedAt??Date.now(),error:null,isInvalidated:!1,status:"success"}}function getDefaultState(options){let data=typeof options.initialData=="function"?options.initialData():options.initialData,hasData=data!==void 0,initialDataUpdatedAt=hasData?typeof options.initialDataUpdatedAt=="function"?options.initialDataUpdatedAt():options.initialDataUpdatedAt:0;return{data,dataUpdateCount:0,dataUpdatedAt:hasData?initialDataUpdatedAt??Date.now():0,error:null,errorUpdateCount:0,errorUpdatedAt:0,fetchFailureCount:0,fetchFailureReason:null,fetchMeta:null,isInvalidated:!1,status:hasData?"success":"pending",fetchStatus:"idle"}}var _client2,_currentQuery,_currentQueryInitialState,_currentResult,_currentResultState,_currentResultOptions,_selectError,_selectFn,_selectResult,_lastQueryWithDefinedData,_staleTimeoutId,_refetchIntervalId,_currentRefetchInterval,_trackedProps,_QueryObserver_instances,executeFetch_fn,shouldScheduleTimer_fn,updateStaleTimeout_fn,computeRefetchInterval_fn,updateRefetchInterval_fn,updateTimers_fn,clearStaleTimeout_fn,clearRefetchInterval_fn,updateQuery_fn,_a6,QueryObserver=(_a6=class extends Subscribable{constructor(client,options){super();__privateAdd(this,_QueryObserver_instances);__privateAdd(this,_client2);__privateAdd(this,_currentQuery);__privateAdd(this,_currentQueryInitialState);__privateAdd(this,_currentResult);__privateAdd(this,_currentResultState);__privateAdd(this,_currentResultOptions);__privateAdd(this,_selectError);__privateAdd(this,_selectFn);__privateAdd(this,_selectResult);__privateAdd(this,_lastQueryWithDefinedData);__privateAdd(this,_staleTimeoutId);__privateAdd(this,_refetchIntervalId);__privateAdd(this,_currentRefetchInterval);__privateAdd(this,_trackedProps,new Set);this.options=options,__privateSet(this,_client2,client),__privateSet(this,_selectError,null),this.bindMethods(),this.setOptions(options)}bindMethods(){this.refetch=this.refetch.bind(this)}onSubscribe(){this.listeners.size===1&&(__privateGet(this,_currentQuery).addObserver(this),shouldFetchOnMount(__privateGet(this,_currentQuery),this.options)?__privateMethod(this,_QueryObserver_instances,executeFetch_fn).call(this):this.updateResult(),__privateMethod(this,_QueryObserver_instances,updateTimers_fn).call(this))}onUnsubscribe(){this.hasListeners()||this.destroy()}shouldFetchOnReconnect(){return shouldFetchOn(__privateGet(this,_currentQuery),this.options,this.options.refetchOnReconnect)}shouldFetchOnWindowFocus(){return shouldFetchOn(__privateGet(this,_currentQuery),this.options,this.options.refetchOnWindowFocus)}destroy(){this.listeners=new Set,__privateMethod(this,_QueryObserver_instances,clearStaleTimeout_fn).call(this),__privateMethod(this,_QueryObserver_instances,clearRefetchInterval_fn).call(this),__privateGet(this,_currentQuery).removeObserver(this)}setOptions(options){let prevOptions=this.options,prevQuery=__privateGet(this,_currentQuery);if(this.options=__privateGet(this,_client2).defaultQueryOptions(options),this.options.enabled!==void 0&&typeof this.options.enabled!="boolean"&&typeof this.options.enabled!="function"&&typeof resolveQueryValue(this.options.enabled,__privateGet(this,_currentQuery))!="boolean")throw new Error("Expected enabled to be a boolean or a callback that returns a boolean");__privateMethod(this,_QueryObserver_instances,updateQuery_fn).call(this),__privateGet(this,_currentQuery).setOptions(this.options),prevOptions._defaulted&&!shallowEqualObjects(this.options,prevOptions)&&__privateGet(this,_client2).getQueryCache().notify({type:"observerOptionsUpdated",query:__privateGet(this,_currentQuery),observer:this});let mounted=this.hasListeners();mounted&&shouldFetchOptionally(__privateGet(this,_currentQuery),prevQuery,this.options,prevOptions)&&__privateMethod(this,_QueryObserver_instances,executeFetch_fn).call(this),this.updateResult(),mounted&&(__privateGet(this,_currentQuery)!==prevQuery||resolveQueryValue(this.options.enabled,__privateGet(this,_currentQuery))!==resolveQueryValue(prevOptions.enabled,__privateGet(this,_currentQuery))||resolveQueryValue(this.options.staleTime,__privateGet(this,_currentQuery))!==resolveQueryValue(prevOptions.staleTime,__privateGet(this,_currentQuery)))&&__privateMethod(this,_QueryObserver_instances,updateStaleTimeout_fn).call(this);let nextRefetchInterval=__privateMethod(this,_QueryObserver_instances,computeRefetchInterval_fn).call(this);mounted&&(__privateGet(this,_currentQuery)!==prevQuery||resolveQueryValue(this.options.enabled,__privateGet(this,_currentQuery))!==resolveQueryValue(prevOptions.enabled,__privateGet(this,_currentQuery))||nextRefetchInterval!==__privateGet(this,_currentRefetchInterval))&&__privateMethod(this,_QueryObserver_instances,updateRefetchInterval_fn).call(this,nextRefetchInterval)}getOptimisticResult(options){let query=__privateGet(this,_client2).getQueryCache().build(__privateGet(this,_client2),options),result=this.createResult(query,options);return shallowEqualObjects(this.getCurrentResult(),result)||(__privateSet(this,_currentResult,result),__privateSet(this,_currentResultOptions,this.options),__privateSet(this,_currentResultState,__privateGet(this,_currentQuery).state)),result}getCurrentResult(){return __privateGet(this,_currentResult)}trackResult(result,onPropTracked){return new Proxy(result,{get:(target,key)=>(this.trackProp(key),onPropTracked?.(key),Reflect.get(target,key))})}trackProp(key){__privateGet(this,_trackedProps).add(key)}getCurrentQuery(){return __privateGet(this,_currentQuery)}refetch({...options}={}){return this.fetch({...options})}fetchOptimistic(options){let defaultedOptions=__privateGet(this,_client2).defaultQueryOptions(options),query=__privateGet(this,_client2).getQueryCache().build(__privateGet(this,_client2),defaultedOptions),unsubscribe=()=>{},resolveEarly,cachePromise=new Promise(resolve=>{resolveEarly=resolve,unsubscribe=__privateGet(this,_client2).getQueryCache().subscribe(event=>{event.type==="updated"&&event.query.queryHash===query.queryHash&&query.state.data!==void 0&&(unsubscribe(),resolve(this.createResult(query,defaultedOptions)))})});return Promise.race([query.fetch().then(()=>{let result=this.createResult(query,defaultedOptions);return resolveEarly?.(result),result}).finally(()=>{unsubscribe()}),cachePromise])}fetch(fetchOptions){return __privateMethod(this,_QueryObserver_instances,executeFetch_fn).call(this,{...fetchOptions,cancelRefetch:fetchOptions.cancelRefetch??!0}).then(()=>(this.updateResult(),__privateGet(this,_currentResult)))}createResult(query,options){let prevQuery=__privateGet(this,_currentQuery),prevOptions=this.options,prevResult=__privateGet(this,_currentResult),prevResultState=__privateGet(this,_currentResultState),prevResultOptions=__privateGet(this,_currentResultOptions),queryInitialState=query!==prevQuery?query.state:__privateGet(this,_currentQueryInitialState),{state}=query,newState={...state},isPlaceholderData=!1,data;if(options._optimisticResults){let mounted=this.hasListeners(),fetchOnMount=!mounted&&shouldFetchOnMount(query,options),fetchOptionally=mounted&&shouldFetchOptionally(query,prevQuery,options,prevOptions);(fetchOnMount||fetchOptionally)&&(newState={...newState,...fetchState(state.data,query.options)}),options._optimisticResults==="isRestoring"&&(newState.fetchStatus="idle")}let{error,errorUpdatedAt,status}=newState;data=newState.data;let skipSelect=!1;if(options.placeholderData!==void 0&&data===void 0&&status==="pending"){let placeholderData;prevResult?.isPlaceholderData&&options.placeholderData===prevResultOptions?.placeholderData?(placeholderData=prevResult.data,skipSelect=!0):placeholderData=typeof options.placeholderData=="function"?options.placeholderData(__privateGet(this,_lastQueryWithDefinedData)?.state.data,__privateGet(this,_lastQueryWithDefinedData)):options.placeholderData,placeholderData!==void 0&&(status="success",data=replaceData(prevResult?.data,placeholderData,options),isPlaceholderData=!0)}if(options.select&&data!==void 0&&!skipSelect)if(prevResult&&data===prevResultState?.data&&options.select===__privateGet(this,_selectFn))data=__privateGet(this,_selectResult);else try{__privateSet(this,_selectFn,options.select),data=options.select(data),data=replaceData(prevResult?.data,data,options),__privateSet(this,_selectResult,data),__privateSet(this,_selectError,null)}catch(selectError){__privateSet(this,_selectError,selectError)}else data===void 0&&__privateSet(this,_selectError,null);__privateGet(this,_selectError)&&(error=__privateGet(this,_selectError),data=__privateGet(this,_selectResult),errorUpdatedAt=Date.now(),status="error",isPlaceholderData=!1);let isFetching=newState.fetchStatus==="fetching",isPending=status==="pending",isError=status==="error",isLoading=isPending&&isFetching,hasData=data!==void 0;return{status,fetchStatus:newState.fetchStatus,isPending,isSuccess:status==="success",isError,isInitialLoading:isLoading,isLoading,data,dataUpdatedAt:newState.dataUpdatedAt,error,errorUpdatedAt,failureCount:newState.fetchFailureCount,failureReason:newState.fetchFailureReason,errorUpdateCount:newState.errorUpdateCount,isFetched:query.isFetched(),isFetchedAfterMount:newState.dataUpdateCount>queryInitialState.dataUpdateCount||newState.errorUpdateCount>queryInitialState.errorUpdateCount,isFetching,isRefetching:isFetching&&!isPending,isLoadingError:isError&&!hasData,isPaused:newState.fetchStatus==="paused",isPlaceholderData,isRefetchError:isError&&hasData,isStale:isStale(query,options),refetch:this.refetch,isEnabled:resolveQueryValue(options.enabled,query)!==!1}}updateResult(){let prevResult=__privateGet(this,_currentResult),nextResult=this.createResult(__privateGet(this,_currentQuery),this.options);if(__privateSet(this,_currentResultState,__privateGet(this,_currentQuery).state),__privateSet(this,_currentResultOptions,this.options),__privateGet(this,_currentResultState).data!==void 0&&__privateSet(this,_lastQueryWithDefinedData,__privateGet(this,_currentQuery)),shallowEqualObjects(nextResult,prevResult))return;__privateSet(this,_currentResult,nextResult);let notifyListeners=(()=>{if(!prevResult)return!0;let{notifyOnChangeProps}=this.options,notifyOnChangePropsValue=typeof notifyOnChangeProps=="function"?notifyOnChangeProps():notifyOnChangeProps;if(notifyOnChangePropsValue==="all"||!notifyOnChangePropsValue&&!__privateGet(this,_trackedProps).size)return!0;let includedProps=new Set(notifyOnChangePropsValue??__privateGet(this,_trackedProps));return this.options.throwOnError&&includedProps.add("error"),Object.keys(__privateGet(this,_currentResult)).some(key=>{let typedKey=key;return __privateGet(this,_currentResult)[typedKey]!==prevResult[typedKey]&&includedProps.has(typedKey)})})();notifyManager.batch(()=>{notifyListeners&&this.listeners.forEach(listener=>{listener(__privateGet(this,_currentResult))}),__privateGet(this,_client2).getQueryCache().notify({query:__privateGet(this,_currentQuery),type:"observerResultsUpdated"})})}onQueryUpdate(){this.updateResult(),this.hasListeners()&&__privateMethod(this,_QueryObserver_instances,updateTimers_fn).call(this)}},_client2=new WeakMap,_currentQuery=new WeakMap,_currentQueryInitialState=new WeakMap,_currentResult=new WeakMap,_currentResultState=new WeakMap,_currentResultOptions=new WeakMap,_selectError=new WeakMap,_selectFn=new WeakMap,_selectResult=new WeakMap,_lastQueryWithDefinedData=new WeakMap,_staleTimeoutId=new WeakMap,_refetchIntervalId=new WeakMap,_currentRefetchInterval=new WeakMap,_trackedProps=new WeakMap,_QueryObserver_instances=new WeakSet,executeFetch_fn=function(fetchOptions){__privateMethod(this,_QueryObserver_instances,updateQuery_fn).call(this);let promise=__privateGet(this,_currentQuery).fetch(this.options,fetchOptions);return fetchOptions?.throwOnError||(promise=promise.catch(noop)),promise},shouldScheduleTimer_fn=function(timeout){return!isServer2()&&resolveQueryValue(this.options.enabled,__privateGet(this,_currentQuery))!==!1&&isValidTimeout(timeout)},updateStaleTimeout_fn=function(){__privateMethod(this,_QueryObserver_instances,clearStaleTimeout_fn).call(this);let staleTime=resolveQueryValue(this.options.staleTime,__privateGet(this,_currentQuery));if(__privateGet(this,_currentResult).isStale||!__privateMethod(this,_QueryObserver_instances,shouldScheduleTimer_fn).call(this,staleTime))return;let timeout=timeUntilStale(__privateGet(this,_currentResult).dataUpdatedAt,staleTime)+1;__privateSet(this,_staleTimeoutId,timeoutManager.setTimeout(()=>{__privateGet(this,_currentResult).isStale||this.updateResult()},timeout))},computeRefetchInterval_fn=function(){return(typeof this.options.refetchInterval=="function"?this.options.refetchInterval(__privateGet(this,_currentQuery)):this.options.refetchInterval)??!1},updateRefetchInterval_fn=function(nextInterval){__privateMethod(this,_QueryObserver_instances,clearRefetchInterval_fn).call(this),__privateSet(this,_currentRefetchInterval,nextInterval),!(__privateGet(this,_currentRefetchInterval)===0||!__privateMethod(this,_QueryObserver_instances,shouldScheduleTimer_fn).call(this,__privateGet(this,_currentRefetchInterval)))&&__privateSet(this,_refetchIntervalId,timeoutManager.setInterval(()=>{(this.options.refetchIntervalInBackground||focusManager.isFocused())&&__privateMethod(this,_QueryObserver_instances,executeFetch_fn).call(this)},__privateGet(this,_currentRefetchInterval)))},updateTimers_fn=function(){__privateMethod(this,_QueryObserver_instances,updateStaleTimeout_fn).call(this),__privateMethod(this,_QueryObserver_instances,updateRefetchInterval_fn).call(this,__privateMethod(this,_QueryObserver_instances,computeRefetchInterval_fn).call(this))},clearStaleTimeout_fn=function(){__privateGet(this,_staleTimeoutId)!==void 0&&(timeoutManager.clearTimeout(__privateGet(this,_staleTimeoutId)),__privateSet(this,_staleTimeoutId,void 0))},clearRefetchInterval_fn=function(){__privateGet(this,_refetchIntervalId)!==void 0&&(timeoutManager.clearInterval(__privateGet(this,_refetchIntervalId)),__privateSet(this,_refetchIntervalId,void 0))},updateQuery_fn=function(){let query=__privateGet(this,_client2).getQueryCache().build(__privateGet(this,_client2),this.options);if(query===__privateGet(this,_currentQuery))return;let prevQuery=__privateGet(this,_currentQuery);__privateSet(this,_currentQuery,query),__privateSet(this,_currentQueryInitialState,query.state),this.hasListeners()&&(prevQuery?.removeObserver(this),query.addObserver(this))},_a6);function shouldLoadOnMount(query,options){return resolveQueryValue(options.enabled,query)!==!1&&query.state.data===void 0&&!(query.state.status==="error"&&resolveQueryValue(options.retryOnMount,query)===!1)}function shouldFetchOnMount(query,options){return shouldLoadOnMount(query,options)||query.state.data!==void 0&&shouldFetchOn(query,options,options.refetchOnMount)}function shouldFetchOn(query,options,field){if(resolveQueryValue(options.enabled,query)!==!1&&resolveQueryValue(options.staleTime,query)!=="static"){let value=typeof field=="function"?field(query):field;return value==="always"||value!==!1&&isStale(query,options)}return!1}function shouldFetchOptionally(query,prevQuery,options,prevOptions){return(query!==prevQuery||resolveQueryValue(prevOptions.enabled,query)===!1)&&(!options.suspense||query.state.status!=="error")&&isStale(query,options)}function isStale(query,options){return resolveQueryValue(options.enabled,query)!==!1&&query.isStaleByTime(resolveQueryValue(options.staleTime,query))}var InfiniteQueryObserver=class extends QueryObserver{constructor(client,options){super(client,options)}bindMethods(){super.bindMethods(),this.fetchNextPage=this.fetchNextPage.bind(this),this.fetchPreviousPage=this.fetchPreviousPage.bind(this)}setOptions(options){options._type="infinite",super.setOptions(options)}getOptimisticResult(options){return options._type="infinite",super.getOptimisticResult(options)}fetchNextPage(options){return this.fetch({...options,meta:{fetchMore:{direction:"forward"}}})}fetchPreviousPage(options){return this.fetch({...options,meta:{fetchMore:{direction:"backward"}}})}createResult(query,options){let{state}=query,parentResult=super.createResult(query,options),{isFetching,isRefetching,isError,isRefetchError}=parentResult,fetchDirection=state.fetchMeta?.fetchMore?.direction,isFetchNextPageError=isError&&fetchDirection==="forward",isFetchingNextPage=isFetching&&fetchDirection==="forward",isFetchPreviousPageError=isError&&fetchDirection==="backward",isFetchingPreviousPage=isFetching&&fetchDirection==="backward";return{...parentResult,fetchNextPage:this.fetchNextPage,fetchPreviousPage:this.fetchPreviousPage,hasNextPage:hasNextPage(options,state.data),hasPreviousPage:hasPreviousPage(options,state.data),isFetchNextPageError,isFetchingNextPage,isFetchPreviousPageError,isFetchingPreviousPage,isRefetchError:isRefetchError&&!isFetchNextPageError&&!isFetchPreviousPageError,isRefetching:isRefetching&&!isFetchingNextPage&&!isFetchingPreviousPage}}};var _client3,_observers,_mutationCache,_retryer2,_Mutation_instances,dispatch_fn2,_a7,Mutation=(_a7=class extends Removable{constructor(config){super();__privateAdd(this,_Mutation_instances);__privateAdd(this,_client3);__privateAdd(this,_observers);__privateAdd(this,_mutationCache);__privateAdd(this,_retryer2);__privateSet(this,_client3,config.client),this.mutationId=config.mutationId,__privateSet(this,_mutationCache,config.mutationCache),__privateSet(this,_observers,[]),this.state=config.state||getDefaultState2(),this.setOptions(config.options),this.scheduleGc()}setOptions(options){this.options=options,this.updateGcTime(this.options.gcTime)}get meta(){return this.options.meta}addObserver(observer){__privateGet(this,_observers).includes(observer)||(__privateGet(this,_observers).push(observer),this.clearGcTimeout(),__privateGet(this,_mutationCache).notify({type:"observerAdded",mutation:this,observer}))}removeObserver(observer){__privateSet(this,_observers,__privateGet(this,_observers).filter(x=>x!==observer)),this.scheduleGc(),__privateGet(this,_mutationCache).notify({type:"observerRemoved",mutation:this,observer})}optionalRemove(){__privateGet(this,_observers).length||(this.state.status==="pending"?this.scheduleGc():__privateGet(this,_mutationCache).remove(this))}continue(){return __privateGet(this,_retryer2)?.continue()??(this.state.status==="pending"?this.execute(this.state.variables):Promise.resolve())}async execute(variables){let onContinue=()=>{__privateMethod(this,_Mutation_instances,dispatch_fn2).call(this,{type:"continue"})},mutationFnContext={client:__privateGet(this,_client3),meta:this.options.meta,mutationKey:this.options.mutationKey},retryer=__privateSet(this,_retryer2,createRetryer({fn:()=>this.options.mutationFn?this.options.mutationFn(variables,mutationFnContext):Promise.reject(new Error("No mutationFn found")),onFail:(failureCount,error)=>{__privateMethod(this,_Mutation_instances,dispatch_fn2).call(this,{type:"failed",failureCount,error})},onPause:()=>{__privateMethod(this,_Mutation_instances,dispatch_fn2).call(this,{type:"pause"})},onContinue,retry:this.options.retry??0,retryDelay:this.options.retryDelay,networkMode:this.options.networkMode,canRun:()=>__privateGet(this,_mutationCache).canRun(this)})),restored=this.state.status==="pending",isPaused=!retryer.canStart();try{if(restored)onContinue();else{__privateMethod(this,_Mutation_instances,dispatch_fn2).call(this,{type:"pending",variables,isPaused}),__privateGet(this,_mutationCache).config.onMutate&&await __privateGet(this,_mutationCache).config.onMutate(variables,this,mutationFnContext);let context=await this.options.onMutate?.(variables,mutationFnContext);context!==this.state.context&&__privateMethod(this,_Mutation_instances,dispatch_fn2).call(this,{type:"pending",context,variables,isPaused})}let data=await retryer.start();return await __privateGet(this,_mutationCache).config.onSuccess?.(data,variables,this.state.context,this,mutationFnContext),await this.options.onSuccess?.(data,variables,this.state.context,mutationFnContext),await __privateGet(this,_mutationCache).config.onSettled?.(data,null,this.state.variables,this.state.context,this,mutationFnContext),await this.options.onSettled?.(data,null,variables,this.state.context,mutationFnContext),__privateMethod(this,_Mutation_instances,dispatch_fn2).call(this,{type:"success",data}),data}catch(error){try{await __privateGet(this,_mutationCache).config.onError?.(error,variables,this.state.context,this,mutationFnContext)}catch(e){Promise.reject(e)}try{await this.options.onError?.(error,variables,this.state.context,mutationFnContext)}catch(e){Promise.reject(e)}try{await __privateGet(this,_mutationCache).config.onSettled?.(void 0,error,this.state.variables,this.state.context,this,mutationFnContext)}catch(e){Promise.reject(e)}try{await this.options.onSettled?.(void 0,error,variables,this.state.context,mutationFnContext)}catch(e){Promise.reject(e)}throw __privateMethod(this,_Mutation_instances,dispatch_fn2).call(this,{type:"error",error}),error}finally{__privateGet(this,_retryer2)===retryer&&__privateSet(this,_retryer2,void 0),__privateGet(this,_mutationCache).runNext(this)}}},_client3=new WeakMap,_observers=new WeakMap,_mutationCache=new WeakMap,_retryer2=new WeakMap,_Mutation_instances=new WeakSet,dispatch_fn2=function(action){let reducer=state=>{switch(action.type){case"failed":return{...state,failureCount:action.failureCount,failureReason:action.error};case"pause":return{...state,isPaused:!0};case"continue":return{...state,isPaused:!1};case"pending":return{...state,context:action.context,data:void 0,failureCount:0,failureReason:null,error:null,isPaused:action.isPaused,status:"pending",variables:action.variables,submittedAt:Date.now()};case"success":return{...state,data:action.data,failureCount:0,failureReason:null,error:null,status:"success",isPaused:!1};case"error":return{...state,data:void 0,error:action.error,failureCount:state.failureCount+1,failureReason:action.error,isPaused:!1,status:"error"}}};this.state=reducer(this.state),notifyManager.batch(()=>{__privateGet(this,_observers).forEach(observer=>{observer.onMutationUpdate(action)}),__privateGet(this,_mutationCache).notify({mutation:this,type:"updated",action})})},_a7);function getDefaultState2(){return{context:void 0,data:void 0,error:null,failureCount:0,failureReason:null,isPaused:!1,status:"idle",variables:void 0,submittedAt:0}}var _mutations,_scopes,_mutationId,_a8,MutationCache=(_a8=class extends Subscribable{constructor(config={}){super();__privateAdd(this,_mutations);__privateAdd(this,_scopes);__privateAdd(this,_mutationId);this.config=config,__privateSet(this,_mutations,new Set),__privateSet(this,_scopes,new Map),__privateSet(this,_mutationId,0)}build(client,options,state){let mutation=new Mutation({client,mutationCache:this,mutationId:++__privateWrapper(this,_mutationId)._,options:client.defaultMutationOptions(options),state});return this.add(mutation),mutation}add(mutation){__privateGet(this,_mutations).add(mutation);let scope=scopeFor(mutation);if(typeof scope=="string"){let scopedMutations=__privateGet(this,_scopes).get(scope);scopedMutations?scopedMutations.push(mutation):__privateGet(this,_scopes).set(scope,[mutation])}this.notify({type:"added",mutation})}remove(mutation){if(__privateGet(this,_mutations).delete(mutation)){let scope=scopeFor(mutation);if(typeof scope=="string"){let scopedMutations=__privateGet(this,_scopes).get(scope);if(scopedMutations)if(scopedMutations.length>1){let index=scopedMutations.indexOf(mutation);index!==-1&&scopedMutations.splice(index,1)}else scopedMutations[0]===mutation&&__privateGet(this,_scopes).delete(scope)}}this.notify({type:"removed",mutation})}canRun(mutation){let scope=scopeFor(mutation);if(typeof scope=="string"){let firstPendingMutation=__privateGet(this,_scopes).get(scope)?.find(m=>m.state.status==="pending");return!firstPendingMutation||firstPendingMutation===mutation}else return!0}runNext(mutation){let scope=scopeFor(mutation);return typeof scope=="string"?__privateGet(this,_scopes).get(scope)?.find(m=>m!==mutation&&m.state.isPaused)?.continue()??Promise.resolve():Promise.resolve()}clear(){notifyManager.batch(()=>{__privateGet(this,_mutations).forEach(mutation=>{this.notify({type:"removed",mutation})}),__privateGet(this,_mutations).clear(),__privateGet(this,_scopes).clear()})}getAll(){return Array.from(__privateGet(this,_mutations))}find(filters){let defaultedFilters={exact:!0,...filters};return this.getAll().find(mutation=>matchMutation(defaultedFilters,mutation))}findAll(filters={}){return this.getAll().filter(mutation=>matchMutation(filters,mutation))}notify(event){notifyManager.batch(()=>{this.listeners.forEach(listener=>{listener(event)})})}resumePausedMutations(){let pausedMutations=this.getAll().filter(x=>x.state.isPaused);return notifyManager.batch(()=>Promise.all(pausedMutations.map(mutation=>mutation.continue().catch(noop))))}},_mutations=new WeakMap,_scopes=new WeakMap,_mutationId=new WeakMap,_a8);function scopeFor(mutation){return mutation.options.scope?.id}var _client4,_currentResult2,_currentMutation,_mutateOptions,_MutationObserver_instances,updateResult_fn,notify_fn,_a9,MutationObserver=(_a9=class extends Subscribable{constructor(client,options){super();__privateAdd(this,_MutationObserver_instances);__privateAdd(this,_client4);__privateAdd(this,_currentResult2);__privateAdd(this,_currentMutation);__privateAdd(this,_mutateOptions);__privateSet(this,_client4,client),this.setOptions(options),this.bindMethods(),__privateMethod(this,_MutationObserver_instances,updateResult_fn).call(this)}bindMethods(){this.mutate=this.mutate.bind(this),this.reset=this.reset.bind(this)}setOptions(options){let prevOptions=this.options;this.options=__privateGet(this,_client4).defaultMutationOptions(options),shallowEqualObjects(this.options,prevOptions)||__privateGet(this,_client4).getMutationCache().notify({type:"observerOptionsUpdated",mutation:__privateGet(this,_currentMutation),observer:this}),prevOptions?.mutationKey&&this.options.mutationKey&&hashKey(prevOptions.mutationKey)!==hashKey(this.options.mutationKey)?this.reset():__privateGet(this,_currentMutation)?.state.status==="pending"&&__privateGet(this,_currentMutation).setOptions(this.options)}onSubscribe(){this.listeners.size===1&&__privateGet(this,_currentMutation)&&(__privateGet(this,_currentMutation).addObserver(this),__privateMethod(this,_MutationObserver_instances,updateResult_fn).call(this))}onUnsubscribe(){this.hasListeners()||__privateGet(this,_currentMutation)?.removeObserver(this)}onMutationUpdate(action){__privateMethod(this,_MutationObserver_instances,updateResult_fn).call(this),__privateMethod(this,_MutationObserver_instances,notify_fn).call(this,action)}getCurrentResult(){return __privateGet(this,_currentResult2)}reset(){__privateGet(this,_currentMutation)?.removeObserver(this),__privateSet(this,_currentMutation,void 0),__privateMethod(this,_MutationObserver_instances,updateResult_fn).call(this),__privateMethod(this,_MutationObserver_instances,notify_fn).call(this)}mutate(variables,options){return __privateSet(this,_mutateOptions,options),__privateGet(this,_currentMutation)?.removeObserver(this),__privateSet(this,_currentMutation,__privateGet(this,_client4).getMutationCache().build(__privateGet(this,_client4),this.options)),__privateGet(this,_currentMutation).addObserver(this),__privateGet(this,_currentMutation).execute(variables)}},_client4=new WeakMap,_currentResult2=new WeakMap,_currentMutation=new WeakMap,_mutateOptions=new WeakMap,_MutationObserver_instances=new WeakSet,updateResult_fn=function(){let state=__privateGet(this,_currentMutation)?.state??getDefaultState2();__privateSet(this,_currentResult2,{...state,isPending:state.status==="pending",isSuccess:state.status==="success",isError:state.status==="error",isIdle:state.status==="idle",mutate:this.mutate,reset:this.reset})},notify_fn=function(action){notifyManager.batch(()=>{if(__privateGet(this,_mutateOptions)&&this.hasListeners()){let variables=__privateGet(this,_currentResult2).variables,onMutateResult=__privateGet(this,_currentResult2).context,context={client:__privateGet(this,_client4),meta:this.options.meta,mutationKey:this.options.mutationKey};if(action?.type==="success"){try{__privateGet(this,_mutateOptions).onSuccess?.(action.data,variables,onMutateResult,context)}catch(e){Promise.reject(e)}try{__privateGet(this,_mutateOptions).onSettled?.(action.data,null,variables,onMutateResult,context)}catch(e){Promise.reject(e)}}else if(action?.type==="error"){try{__privateGet(this,_mutateOptions).onError?.(action.error,variables,onMutateResult,context)}catch(e){Promise.reject(e)}try{__privateGet(this,_mutateOptions).onSettled?.(void 0,action.error,variables,onMutateResult,context)}catch(e){Promise.reject(e)}}}this.listeners.forEach(listener=>{listener(__privateGet(this,_currentResult2))})})},_a9);function difference(array1,array2){let excludeSet=new Set(array2);return array1.filter(x=>!excludeSet.has(x))}var _client5,_result,_queries,_options,_observers2,_combinedResult,_lastCombine,_lastResult,_lastQueryHashes,_observerMatches,_QueriesObserver_instances,trackResult_fn,combineResult_fn,shouldSkipCombine_fn,findMatchingObservers_fn,onUpdate_fn,notify_fn2,_a10,QueriesObserver=(_a10=class extends Subscribable{constructor(client,queries,options){super();__privateAdd(this,_QueriesObserver_instances);__privateAdd(this,_client5);__privateAdd(this,_result);__privateAdd(this,_queries);__privateAdd(this,_options);__privateAdd(this,_observers2);__privateAdd(this,_combinedResult);__privateAdd(this,_lastCombine);__privateAdd(this,_lastResult);__privateAdd(this,_lastQueryHashes);__privateAdd(this,_observerMatches,[]);__privateSet(this,_client5,client),__privateSet(this,_options,options),__privateSet(this,_queries,[]),__privateSet(this,_observers2,[]),__privateSet(this,_result,[]),this.setQueries(queries)}onSubscribe(){this.listeners.size===1&&__privateGet(this,_observers2).forEach(observer=>{observer.subscribe(result=>{__privateMethod(this,_QueriesObserver_instances,onUpdate_fn).call(this,observer,result)})})}onUnsubscribe(){this.listeners.size||this.destroy()}destroy(){this.listeners=new Set,__privateGet(this,_observers2).forEach(observer=>{observer.destroy()})}setQueries(queries,options){__privateSet(this,_queries,queries),__privateSet(this,_options,options),notifyManager.batch(()=>{let prevObservers=__privateGet(this,_observers2),newObserverMatches=__privateMethod(this,_QueriesObserver_instances,findMatchingObservers_fn).call(this,__privateGet(this,_queries));newObserverMatches.forEach(match=>match.observer.setOptions(match.defaultedQueryOptions));let newObservers=newObserverMatches.map(match=>match.observer),newResult=newObservers.map(observer=>observer.getCurrentResult()),hasLengthChange=prevObservers.length!==newObservers.length,hasIndexChange=newObservers.some((observer,index)=>observer!==prevObservers[index]),hasStructuralChange=hasLengthChange||hasIndexChange,hasResultChange=hasStructuralChange?!0:newResult.some((result,index)=>{let prev=__privateGet(this,_result)[index];return!prev||!shallowEqualObjects(result,prev)});!hasStructuralChange&&!hasResultChange||(hasStructuralChange&&(__privateSet(this,_observerMatches,newObserverMatches),__privateSet(this,_observers2,newObservers)),__privateSet(this,_result,newResult),this.hasListeners()&&(hasStructuralChange&&(difference(prevObservers,newObservers).forEach(observer=>{observer.destroy()}),difference(newObservers,prevObservers).forEach(observer=>{observer.subscribe(result=>{__privateMethod(this,_QueriesObserver_instances,onUpdate_fn).call(this,observer,result)})})),__privateMethod(this,_QueriesObserver_instances,notify_fn2).call(this)))})}getCurrentResult(){return __privateGet(this,_result)}getQueries(){return __privateGet(this,_observers2).map(observer=>observer.getCurrentQuery())}getObservers(){return __privateGet(this,_observers2)}getOptimisticResult(queries,combine){let matches=__privateMethod(this,_QueriesObserver_instances,findMatchingObservers_fn).call(this,queries),result=matches.map(match=>match.observer.getOptimisticResult(match.defaultedQueryOptions)),queryHashes=matches.map(match=>match.defaultedQueryOptions.queryHash);return[result,r=>__privateMethod(this,_QueriesObserver_instances,combineResult_fn).call(this,r??result,combine,queryHashes),()=>__privateMethod(this,_QueriesObserver_instances,trackResult_fn).call(this,result,matches)]}},_client5=new WeakMap,_result=new WeakMap,_queries=new WeakMap,_options=new WeakMap,_observers2=new WeakMap,_combinedResult=new WeakMap,_lastCombine=new WeakMap,_lastResult=new WeakMap,_lastQueryHashes=new WeakMap,_observerMatches=new WeakMap,_QueriesObserver_instances=new WeakSet,trackResult_fn=function(result,matches){let trackedProps=new Set;return matches.map((match,index)=>{let observerResult=result[index];return match.defaultedQueryOptions.notifyOnChangeProps?observerResult:match.observer.trackResult(observerResult,accessedProp=>{trackedProps.has(accessedProp)||(trackedProps.add(accessedProp),matches.forEach(m=>{m.observer.trackProp(accessedProp)}))})})},combineResult_fn=function(input,combine,queryHashes){if(combine){let lastHashes=__privateGet(this,_lastQueryHashes),queryHashesChanged=queryHashes!==void 0&&lastHashes!==void 0&&(lastHashes.length!==queryHashes.length||queryHashes.some((hash,i)=>hash!==lastHashes[i]));return(__privateGet(this,_result)!==__privateGet(this,_lastResult)||queryHashesChanged||combine!==__privateGet(this,_lastCombine))&&(__privateSet(this,_lastCombine,combine),__privateSet(this,_lastResult,__privateGet(this,_result)),queryHashes!==void 0&&__privateSet(this,_lastQueryHashes,queryHashes),__privateSet(this,_combinedResult,replaceEqualDeep(__privateGet(this,_combinedResult),combine(input)))),__privateGet(this,_combinedResult)}return input},shouldSkipCombine_fn=function(){return!__privateGet(this,_options)?.combine||__privateGet(this,_observers2).some((observer,index)=>observer.options.suspense&&__privateGet(this,_result)[index]?.data===void 0)},findMatchingObservers_fn=function(queries){let prevObserversMap=new Map;__privateGet(this,_observers2).forEach(observer=>{let key=observer.options.queryHash;if(!key)return;let previousObservers=prevObserversMap.get(key);previousObservers?previousObservers.push(observer):prevObserversMap.set(key,[observer])});let observers=[];return queries.forEach(options=>{let defaultedOptions=__privateGet(this,_client5).defaultQueryOptions(options),observer=prevObserversMap.get(defaultedOptions.queryHash)?.shift()??new QueryObserver(__privateGet(this,_client5),defaultedOptions);observers.push({defaultedQueryOptions:defaultedOptions,observer})}),observers},onUpdate_fn=function(observer,result){let index=__privateGet(this,_observers2).indexOf(observer);index!==-1&&(__privateSet(this,_result,__privateGet(this,_result).slice()),__privateGet(this,_result)[index]=result,__privateMethod(this,_QueriesObserver_instances,notify_fn2).call(this))},notify_fn2=function(){if(this.hasListeners()){let shouldSkipCombine=__privateMethod(this,_QueriesObserver_instances,shouldSkipCombine_fn).call(this),previousResult=__privateGet(this,_combinedResult),newResult=shouldSkipCombine?previousResult:__privateMethod(this,_QueriesObserver_instances,combineResult_fn).call(this,__privateMethod(this,_QueriesObserver_instances,trackResult_fn).call(this,__privateGet(this,_result),__privateGet(this,_observerMatches)),__privateGet(this,_options)?.combine);(shouldSkipCombine||previousResult!==newResult)&&notifyManager.batch(()=>{this.listeners.forEach(listener=>{listener(__privateGet(this,_result))})})}},_a10);var _queries2,_a11,QueryCache=(_a11=class extends Subscribable{constructor(config={}){super();__privateAdd(this,_queries2);this.config=config,__privateSet(this,_queries2,new Map)}build(client,options,state){let queryKey=options.queryKey,queryHash=options.queryHash??hashQueryKeyByOptions(queryKey,options),query=this.get(queryHash);return query||(query=new Query({client,queryKey,queryHash,options:client.defaultQueryOptions(options),state,defaultOptions:client.getQueryDefaults(queryKey)}),this.add(query)),query}add(query){__privateGet(this,_queries2).has(query.queryHash)||(__privateGet(this,_queries2).set(query.queryHash,query),this.notify({type:"added",query}))}remove(query){let queryInMap=__privateGet(this,_queries2).get(query.queryHash);queryInMap&&(query.destroy(),queryInMap===query&&__privateGet(this,_queries2).delete(query.queryHash),this.notify({type:"removed",query}))}clear(){notifyManager.batch(()=>{this.getAll().forEach(query=>{this.remove(query)})})}get(queryHash){return __privateGet(this,_queries2).get(queryHash)}getAll(){return[...__privateGet(this,_queries2).values()]}find(filters){let defaultedFilters={exact:!0,...filters};return this.getAll().find(query=>matchQuery(defaultedFilters,query))}findAll(filters={}){let queries=this.getAll();return Object.keys(filters).length>0?queries.filter(query=>matchQuery(filters,query)):queries}notify(event){notifyManager.batch(()=>{this.listeners.forEach(listener=>{listener(event)})})}onFocus(){notifyManager.batch(()=>{this.getAll().forEach(query=>{query.onFocus()})})}onOnline(){notifyManager.batch(()=>{this.getAll().forEach(query=>{query.onOnline()})})}},_queries2=new WeakMap,_a11);var _queryCache,_mutationCache2,_defaultOptions2,_queryDefaults,_mutationDefaults,_mountCount,_unsubscribeFocus,_unsubscribeOnline,_a12,QueryClient=(_a12=class{constructor(config={}){__privateAdd(this,_queryCache);__privateAdd(this,_mutationCache2);__privateAdd(this,_defaultOptions2);__privateAdd(this,_queryDefaults);__privateAdd(this,_mutationDefaults);__privateAdd(this,_mountCount);__privateAdd(this,_unsubscribeFocus);__privateAdd(this,_unsubscribeOnline);__privateSet(this,_queryCache,config.queryCache||new QueryCache),__privateSet(this,_mutationCache2,config.mutationCache||new MutationCache),__privateSet(this,_defaultOptions2,config.defaultOptions||{}),__privateSet(this,_queryDefaults,new Map),__privateSet(this,_mutationDefaults,new Map),__privateSet(this,_mountCount,0)}mount(){__privateWrapper(this,_mountCount)._++,__privateGet(this,_mountCount)===1&&(__privateSet(this,_unsubscribeFocus,focusManager.subscribe(async focused=>{focused&&(await this.resumePausedMutations(),__privateGet(this,_queryCache).onFocus())})),__privateSet(this,_unsubscribeOnline,onlineManager.subscribe(async online=>{online&&(await this.resumePausedMutations(),__privateGet(this,_queryCache).onOnline())})))}unmount(){var _a13,_b;__privateWrapper(this,_mountCount)._--,__privateGet(this,_mountCount)===0&&((_a13=__privateGet(this,_unsubscribeFocus))==null||_a13.call(this),__privateSet(this,_unsubscribeFocus,void 0),(_b=__privateGet(this,_unsubscribeOnline))==null||_b.call(this),__privateSet(this,_unsubscribeOnline,void 0))}isFetching(filters){return __privateGet(this,_queryCache).findAll({...filters,fetchStatus:"fetching"}).length}isMutating(filters){return __privateGet(this,_mutationCache2).findAll({...filters,status:"pending"}).length}getQueryData(queryKey){let options=this.defaultQueryOptions({queryKey});return __privateGet(this,_queryCache).get(options.queryHash)?.state.data}ensureQueryData(options){let defaultedOptions=this.defaultQueryOptions(options),query=__privateGet(this,_queryCache).build(this,defaultedOptions),cachedData=query.state.data;return cachedData===void 0?this.fetchQuery(options):(options.revalidateIfStale&&query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime,query))&&this.prefetchQuery(defaultedOptions),Promise.resolve(cachedData))}getQueriesData(filters){return __privateGet(this,_queryCache).findAll(filters).map(({queryKey,state})=>[queryKey,state.data])}setQueryData(queryKey,updater,options){let defaultedOptions=this.defaultQueryOptions({queryKey}),prevData=__privateGet(this,_queryCache).get(defaultedOptions.queryHash)?.state.data,data=functionalUpdate(updater,prevData);if(data!==void 0)return __privateGet(this,_queryCache).build(this,defaultedOptions).setData(data,{...options,manual:!0})}setQueriesData(filters,updater,options){return notifyManager.batch(()=>__privateGet(this,_queryCache).findAll(filters).map(({queryKey})=>[queryKey,this.setQueryData(queryKey,updater,options)]))}getQueryState(queryKey){let options=this.defaultQueryOptions({queryKey});return __privateGet(this,_queryCache).get(options.queryHash)?.state}removeQueries(filters){let queryCache=__privateGet(this,_queryCache);notifyManager.batch(()=>{queryCache.findAll(filters).forEach(query=>{queryCache.remove(query)})})}resetQueries(filters,options){let queryCache=__privateGet(this,_queryCache);return notifyManager.batch(()=>{let matched=queryCache.findAll(filters),queriesToRefetch=new Set(matched);return matched.forEach(query=>{query.reset()}),this.refetchQueries({type:"active",predicate:query=>queriesToRefetch.has(query)},options)})}cancelQueries(filters,cancelOptions={}){let defaultedCancelOptions={revert:!0,...cancelOptions},promises=notifyManager.batch(()=>__privateGet(this,_queryCache).findAll(filters).map(query=>query.cancel(defaultedCancelOptions)));return Promise.all(promises).then(noop).catch(noop)}invalidateQueries(filters,options={}){return notifyManager.batch(()=>(__privateGet(this,_queryCache).findAll(filters).forEach(query=>{query.invalidate()}),filters?.refetchType==="none"?Promise.resolve():this.refetchQueries({...filters,type:filters?.refetchType??filters?.type??"active"},options)))}refetchQueries(filters,options={}){let fetchOptions={...options,cancelRefetch:options.cancelRefetch??!0},promises=notifyManager.batch(()=>__privateGet(this,_queryCache).findAll(filters).filter(query=>!query.isDisabled()&&!query.isStatic()).map(query=>{let promise=query.fetch(void 0,fetchOptions);return fetchOptions.throwOnError||(promise=promise.catch(noop)),query.state.fetchStatus==="paused"?Promise.resolve():promise}));return Promise.all(promises).then(noop)}async query(options){let defaultedOptions=this.defaultQueryOptions(options);defaultedOptions.retry===void 0&&(defaultedOptions.retry=!1);let query=__privateGet(this,_queryCache).build(this,defaultedOptions),queryData=query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime,query))?await query.fetch(defaultedOptions):query.state.data,select=defaultedOptions.select;return select?select(queryData):queryData}fetchQuery(options){let defaultedOptions=this.defaultQueryOptions(options);defaultedOptions.retry===void 0&&(defaultedOptions.retry=!1);let query=__privateGet(this,_queryCache).build(this,defaultedOptions);return query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime,query))?query.fetch(defaultedOptions):Promise.resolve(query.state.data)}prefetchQuery(options){return this.fetchQuery(options).then(noop).catch(noop)}infiniteQuery(options){return options._type="infinite",this.query(options)}fetchInfiniteQuery(options){return options._type="infinite",this.fetchQuery(options)}prefetchInfiniteQuery(options){return this.fetchInfiniteQuery(options).then(noop).catch(noop)}ensureInfiniteQueryData(options){return options._type="infinite",this.ensureQueryData(options)}resumePausedMutations(){return onlineManager.isOnline()?__privateGet(this,_mutationCache2).resumePausedMutations():Promise.resolve()}getQueryCache(){return __privateGet(this,_queryCache)}getMutationCache(){return __privateGet(this,_mutationCache2)}getDefaultOptions(){return __privateGet(this,_defaultOptions2)}setDefaultOptions(options){__privateSet(this,_defaultOptions2,options)}setQueryDefaults(queryKey,options){__privateGet(this,_queryDefaults).set(hashKey(queryKey),{queryKey,defaultOptions:options})}getQueryDefaults(queryKey){let defaults=[...__privateGet(this,_queryDefaults).values()],result={};return defaults.forEach(queryDefault=>{partialMatchKey(queryKey,queryDefault.queryKey)&&Object.assign(result,queryDefault.defaultOptions)}),result}setMutationDefaults(mutationKey,options){__privateGet(this,_mutationDefaults).set(hashKey(mutationKey),{mutationKey,defaultOptions:options})}getMutationDefaults(mutationKey){let defaults=[...__privateGet(this,_mutationDefaults).values()],result={};return defaults.forEach(queryDefault=>{partialMatchKey(mutationKey,queryDefault.mutationKey)&&Object.assign(result,queryDefault.defaultOptions)}),result}defaultQueryOptions(options){if(options._defaulted)return options;let defaultedOptions={...__privateGet(this,_defaultOptions2).queries,...this.getQueryDefaults(options.queryKey),...options,_defaulted:!0};return defaultedOptions.queryHash||(defaultedOptions.queryHash=hashQueryKeyByOptions(defaultedOptions.queryKey,defaultedOptions)),defaultedOptions.refetchOnReconnect===void 0&&(defaultedOptions.refetchOnReconnect=defaultedOptions.networkMode!=="always"),defaultedOptions.throwOnError===void 0&&(defaultedOptions.throwOnError=!!defaultedOptions.suspense),!defaultedOptions.networkMode&&defaultedOptions.persister&&(defaultedOptions.networkMode="offlineFirst"),defaultedOptions.queryFn===skipToken&&(defaultedOptions.enabled=!1),defaultedOptions}defaultMutationOptions(options){return options?._defaulted?options:{...__privateGet(this,_defaultOptions2).mutations,...options?.mutationKey&&this.getMutationDefaults(options.mutationKey),...options,_defaulted:!0}}clear(){__privateGet(this,_queryCache).clear(),__privateGet(this,_mutationCache2).clear()}},_queryCache=new WeakMap,_mutationCache2=new WeakMap,_defaultOptions2=new WeakMap,_queryDefaults=new WeakMap,_mutationDefaults=new WeakMap,_mountCount=new WeakMap,_unsubscribeFocus=new WeakMap,_unsubscribeOnline=new WeakMap,_a12);function streamedQuery({streamFn,refetchMode="reset",reducer=(items,chunk)=>addToEnd(items,chunk),initialValue=[]}){return async context=>{let query=context.client.getQueryCache().find({queryKey:context.queryKey,exact:!0}),isRefetch=!!query&&query.isFetched();isRefetch&&refetchMode==="reset"&&query.setState({...query.resetState,fetchStatus:"fetching"});let result=initialValue,cancelled=!1,stream=await streamFn(addConsumeAwareSignal({client:context.client,meta:context.meta,queryKey:context.queryKey,pageParam:context.pageParam,direction:context.direction},()=>context.signal,()=>cancelled=!0)),isReplaceRefetch=isRefetch&&refetchMode==="replace";for await(let chunk of stream){if(cancelled)break;isReplaceRefetch?result=reducer(result,chunk):context.client.setQueryData(context.queryKey,prev=>reducer(prev===void 0?initialValue:prev,chunk))}return isReplaceRefetch&&!cancelled&&context.client.setQueryData(context.queryKey,result),context.client.getQueryData(context.queryKey)??initialValue}}var dataTagSymbol=Symbol(),dataTagErrorSymbol=Symbol(),unsetMarker=Symbol();var HydrationBoundary=({children,options={},state,queryClient})=>{let client=useQueryClient(queryClient),optionsRef=React2.useRef(options);React2.useEffect(()=>{optionsRef.current=options});let hydrationQueue=React2.useMemo(()=>{if(state){if(typeof state!="object")return;let queryCache=client.getQueryCache(),queries=state.queries||[],newQueries=[],existingQueries=[];for(let dehydratedQuery of queries){let existingQuery=queryCache.get(dehydratedQuery.queryHash);existingQuery?(dehydratedQuery.state.dataUpdatedAt>existingQuery.state.dataUpdatedAt||dehydratedQuery.promise&&existingQuery.state.status!=="pending"&&existingQuery.state.fetchStatus!=="fetching"&&dehydratedQuery.dehydratedAt!==void 0&&dehydratedQuery.dehydratedAt>existingQuery.state.dataUpdatedAt)&&existingQueries.push(dehydratedQuery):newQueries.push(dehydratedQuery)}if(newQueries.length>0&&hydrate(client,{queries:newQueries},optionsRef.current),existingQueries.length>0)return existingQueries}},[client,state]);return React2.useEffect(()=>{hydrationQueue&&hydrate(client,{queries:hydrationQueue},optionsRef.current)},[client,hydrationQueue]),children};import*as React3 from"react";var IsRestoringContext=React3.createContext(!1),useIsRestoring=()=>React3.useContext(IsRestoringContext),IsRestoringProvider=IsRestoringContext.Provider;import*as React4 from"react";import{jsx as jsx2}from"react/jsx-runtime";function createValue(){let isReset=!1;return{clearReset:()=>{isReset=!1},reset:()=>{isReset=!0},isReset:()=>isReset}}var QueryErrorResetBoundaryContext=React4.createContext(createValue()),useQueryErrorResetBoundary=()=>React4.useContext(QueryErrorResetBoundaryContext),QueryErrorResetBoundary=({children})=>{let[value]=React4.useState(()=>createValue());return jsx2(QueryErrorResetBoundaryContext.Provider,{value,children:typeof children=="function"?children(value):children})};import*as React5 from"react";var ensurePreventErrorBoundaryRetry=(options,errorResetBoundary,query)=>{let throwOnError=query?.state.error&&typeof options.throwOnError=="function"?shouldThrowError(options.throwOnError,[query.state.error,query]):options.throwOnError;(options.suspense||throwOnError)&&(errorResetBoundary.isReset()||(options.retryOnMount=!1))},useClearResetErrorBoundary=errorResetBoundary=>{React5.useEffect(()=>{errorResetBoundary.clearReset()},[errorResetBoundary])},getHasError=({result,errorResetBoundary,throwOnError,query,suspense})=>result.isError&&!errorResetBoundary.isReset()&&!result.isFetching&&query&&(suspense&&result.data===void 0||shouldThrowError(throwOnError,[result.error,query]));var defaultThrowOnError=(_error,query)=>query.state.data===void 0,ensureSuspenseTimers=defaultedOptions=>{if(defaultedOptions.suspense){let clamp=value=>value==="static"?value:Math.max(value??1e3,1e3),originalStaleTime=defaultedOptions.staleTime;defaultedOptions.staleTime=typeof originalStaleTime=="function"?(...args)=>clamp(originalStaleTime(...args)):clamp(originalStaleTime),typeof defaultedOptions.gcTime=="number"&&(defaultedOptions.gcTime=Math.max(defaultedOptions.gcTime,1e3))}},shouldSuspend=(defaultedOptions,result)=>defaultedOptions?.suspense&&result.isPending,fetchOptimistic=(defaultedOptions,observer,errorResetBoundary)=>observer.fetchOptimistic(defaultedOptions).catch(()=>{errorResetBoundary.clearReset()});import*as React6 from"react";function useQueries({queries,...options},queryClient){let client=useQueryClient(queryClient),isRestoring=useIsRestoring(),errorResetBoundary=useQueryErrorResetBoundary(),subscribed=options.subscribed!==!1,defaultedQueries=React6.useMemo(()=>queries.map(opts=>{let defaultedOptions=client.defaultQueryOptions(opts);return defaultedOptions._optimisticResults=isRestoring?"isRestoring":subscribed?"optimistic":void 0,defaultedOptions}),[queries,client,isRestoring,subscribed]);defaultedQueries.forEach(queryOptions2=>{ensureSuspenseTimers(queryOptions2);let query=client.getQueryCache().get(queryOptions2.queryHash);ensurePreventErrorBoundaryRetry(queryOptions2,errorResetBoundary,query)}),useClearResetErrorBoundary(errorResetBoundary);let[observer]=React6.useState(()=>new QueriesObserver(client,defaultedQueries,options)),[optimisticResult,getCombinedResult,trackResult]=observer.getOptimisticResult(defaultedQueries,options.combine),shouldSubscribe=!isRestoring&&subscribed;React6.useSyncExternalStore(React6.useCallback(onStoreChange=>shouldSubscribe?observer.subscribe(notifyManager.batchCalls(onStoreChange)):noop,[observer,shouldSubscribe]),()=>observer.getCurrentResult(),()=>observer.getCurrentResult()),React6.useEffect(()=>{observer.setQueries(defaultedQueries,options)},[defaultedQueries,options,observer]);let suspensePromises=optimisticResult.some((result,index)=>shouldSuspend(defaultedQueries[index],result))?optimisticResult.flatMap((result,index)=>{let opts=defaultedQueries[index];if(opts&&shouldSuspend(opts,result)){let queryObserver=new QueryObserver(client,opts);return fetchOptimistic(opts,queryObserver,errorResetBoundary)}return[]}):[];if(suspensePromises.length>0)throw Promise.all(suspensePromises);let firstSingleResultWhichShouldThrow=optimisticResult.find((result,index)=>{let query=defaultedQueries[index];return query&&getHasError({result,errorResetBoundary,throwOnError:query.throwOnError,query:client.getQueryCache().get(query.queryHash),suspense:query.suspense})});if(firstSingleResultWhichShouldThrow)throw firstSingleResultWhichShouldThrow.error;return getCombinedResult(trackResult())}import*as React7 from"react";function useBaseQuery(options,Observer,queryClient){let isRestoring=useIsRestoring(),errorResetBoundary=useQueryErrorResetBoundary(),client=useQueryClient(queryClient),defaultedOptions=client.defaultQueryOptions(options),query=client.getQueryCache().get(defaultedOptions.queryHash),subscribed=options.subscribed!==!1;defaultedOptions._optimisticResults=isRestoring?"isRestoring":subscribed?"optimistic":void 0,ensureSuspenseTimers(defaultedOptions),ensurePreventErrorBoundaryRetry(defaultedOptions,errorResetBoundary,query),useClearResetErrorBoundary(errorResetBoundary);let[observer]=React7.useState(()=>new Observer(client,defaultedOptions)),result=observer.getOptimisticResult(defaultedOptions),shouldSubscribe=!isRestoring&&subscribed;if(React7.useSyncExternalStore(React7.useCallback(onStoreChange=>{let unsubscribe=shouldSubscribe?observer.subscribe(notifyManager.batchCalls(onStoreChange)):noop;return observer.updateResult(),unsubscribe},[observer,shouldSubscribe]),()=>observer.getCurrentResult(),()=>observer.getCurrentResult()),React7.useEffect(()=>{observer.setOptions(defaultedOptions)},[defaultedOptions,observer]),shouldSuspend(defaultedOptions,result))throw fetchOptimistic(defaultedOptions,observer,errorResetBoundary);if(getHasError({result,errorResetBoundary,throwOnError:defaultedOptions.throwOnError,query,suspense:defaultedOptions.suspense}))throw result.error;return defaultedOptions.notifyOnChangeProps?result:observer.trackResult(result)}function useQuery(options,queryClient){return useBaseQuery(options,QueryObserver,queryClient)}function useSuspenseQuery(options,queryClient){return useBaseQuery({...options,enabled:!0,suspense:!0,throwOnError:defaultThrowOnError,placeholderData:void 0},QueryObserver,queryClient)}function useSuspenseInfiniteQuery(options,queryClient){return useBaseQuery({...options,enabled:!0,suspense:!0,throwOnError:defaultThrowOnError,placeholderData:void 0},InfiniteQueryObserver,queryClient)}function useSuspenseQueries(options,queryClient){return useQueries({...options,queries:options.queries.map(query=>({...query,suspense:!0,throwOnError:defaultThrowOnError,enabled:!0,placeholderData:void 0}))},queryClient)}function usePrefetchQuery(options,queryClient){let client=useQueryClient(queryClient);client.getQueryState(options.queryKey)||client.query(options).catch(noop)}function usePrefetchInfiniteQuery(options,queryClient){let client=useQueryClient(queryClient);client.getQueryState(options.queryKey)||client.infiniteQuery(options).catch(noop)}function queryOptions(options){return options}function infiniteQueryOptions(options){return options}import*as React8 from"react";function useIsFetching(filters,queryClient){let client=useQueryClient(queryClient),queryCache=client.getQueryCache();return React8.useSyncExternalStore(React8.useCallback(onStoreChange=>queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),[queryCache]),()=>client.isFetching(filters),()=>client.isFetching(filters))}import*as React9 from"react";function useIsMutating(filters,queryClient){let client=useQueryClient(queryClient);return useMutationState({filters:{...filters,status:"pending"}},client).length}function getResult(mutationCache,options){return mutationCache.findAll(options.filters).map(mutation=>options.select?options.select(mutation):mutation.state)}function useMutationState(options={},queryClient){let mutationCache=useQueryClient(queryClient).getMutationCache(),optionsRef=React9.useRef(options),result=React9.useRef(null);return result.current===null&&(result.current=getResult(mutationCache,options)),React9.useEffect(()=>{optionsRef.current=options}),React9.useSyncExternalStore(React9.useCallback(onStoreChange=>mutationCache.subscribe(()=>{let nextResult=replaceEqualDeep(result.current,getResult(mutationCache,optionsRef.current));result.current!==nextResult&&(result.current=nextResult,notifyManager.schedule(onStoreChange))}),[mutationCache]),()=>result.current,()=>result.current)}import*as React10 from"react";function useMutation(options,queryClient){let client=useQueryClient(queryClient),[observer]=React10.useState(()=>new MutationObserver(client,options));React10.useEffect(()=>{observer.setOptions(options)},[observer,options]);let result=React10.useSyncExternalStore(React10.useCallback(onStoreChange=>observer.subscribe(notifyManager.batchCalls(onStoreChange)),[observer]),()=>observer.getCurrentResult(),()=>observer.getCurrentResult()),mutate=React10.useCallback((...args)=>{observer.mutate(args[0],args[1]).catch(noop)},[observer]);if(result.error&&shouldThrowError(observer.options.throwOnError,[result.error]))throw result.error;return{...result,mutate,mutateAsync:result.mutate}}function mutationOptions(options){return options}function useInfiniteQuery(options,queryClient){return useBaseQuery(options,InfiniteQueryObserver,queryClient)}var ojm_shim_react_query_default=void 0??modern_exports;export{CancelledError,HydrationBoundary,InfiniteQueryObserver,IsRestoringProvider,Mutation,MutationCache,MutationObserver,QueriesObserver,Query,QueryCache,QueryClient,QueryClientContext,QueryClientProvider,QueryErrorResetBoundary,QueryObserver,dataTagErrorSymbol,dataTagSymbol,ojm_shim_react_query_default as default,defaultScheduler,defaultShouldDehydrateMutation,defaultShouldDehydrateQuery,dehydrate,dehydrateQuery,environmentManager,streamedQuery as experimental_streamedQuery,focusManager,hashKey,hydrate,infiniteQueryOptions,isCancelledError,isServer,keepPreviousData,matchMutation,matchQuery,mutationOptions,noop,notifyManager,onlineManager,partialMatchKey,queryOptions,replaceEqualDeep,shouldThrowError,skipToken,timeoutManager,unsetMarker,useInfiniteQuery,useIsFetching,useIsMutating,useIsRestoring,useMutation,useMutationState,usePrefetchInfiniteQuery,usePrefetchQuery,useQueries,useQuery,useQueryClient,useQueryErrorResetBoundary,useSuspenseInfiniteQuery,useSuspenseQueries,useSuspenseQuery};