{"version":3,"file":"react/js/vendor.reduxjs@current-4bcb4490.66b41f475bf89964eaab.js","mappings":"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","sources":["webpack:///./node_modules/@reduxjs/toolkit/dist/query/react/rtk-query-react.modern.mjs","webpack:///./node_modules/@reduxjs/toolkit/dist/query/rtk-query.modern.mjs"],"sourcesContent":["// src/query/react/index.ts\nimport { buildCreateApi, coreModule } from \"@reduxjs/toolkit/query\";\n\n// src/query/react/module.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage3 } from \"@reduxjs/toolkit\";\n\n// src/query/endpointDefinitions.ts\nfunction isQueryDefinition(e) {\n  return e.type === \"query\" /* query */;\n}\nfunction isMutationDefinition(e) {\n  return e.type === \"mutation\" /* mutation */;\n}\n\n// src/query/tsHelpers.ts\nfunction safeAssign(target, ...args) {\n  return Object.assign(target, ...args);\n}\n\n// src/query/utils/capitalize.ts\nfunction capitalize(str) {\n  return str.replace(str[0], str[0].toUpperCase());\n}\n\n// src/query/core/rtkImports.ts\nimport { createAction, createSlice, createSelector, createAsyncThunk, combineReducers, createNextState, isAnyOf, isAllOf, isAction, isPending, isRejected, isFulfilled, isRejectedWithValue, isAsyncThunkAction, prepareAutoBatched, SHOULD_AUTOBATCH, isPlainObject, nanoid } from \"@reduxjs/toolkit\";\n\n// src/query/react/buildHooks.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage2 } from \"@reduxjs/toolkit\";\nimport { formatProdErrorMessage as _formatProdErrorMessage } from \"@reduxjs/toolkit\";\nimport { QueryStatus, skipToken } from \"@reduxjs/toolkit/query\";\nimport { useCallback, useDebugValue, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo2, useRef as useRef3, useState } from \"react\";\nimport { shallowEqual as shallowEqual2 } from \"react-redux\";\n\n// src/query/defaultSerializeQueryArgs.ts\nvar cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;\nvar defaultSerializeQueryArgs = ({\n  endpointName,\n  queryArgs\n}) => {\n  let serialized = \"\";\n  const cached = cache?.get(queryArgs);\n  if (typeof cached === \"string\") {\n    serialized = cached;\n  } else {\n    const stringified = JSON.stringify(queryArgs, (key, value) => {\n      value = typeof value === \"bigint\" ? {\n        $bigint: value.toString()\n      } : value;\n      value = isPlainObject(value) ? Object.keys(value).sort().reduce((acc, key2) => {\n        acc[key2] = value[key2];\n        return acc;\n      }, {}) : value;\n      return value;\n    });\n    if (isPlainObject(queryArgs)) {\n      cache?.set(queryArgs, stringified);\n    }\n    serialized = stringified;\n  }\n  return `${endpointName}(${serialized})`;\n};\n\n// src/query/react/constants.ts\nvar UNINITIALIZED_VALUE = Symbol();\n\n// src/query/react/useSerializedStableValue.ts\nimport { useEffect, useRef, useMemo } from \"react\";\nfunction useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {\n  const incoming = useMemo(() => ({\n    queryArgs,\n    serialized: typeof queryArgs == \"object\" ? serialize({\n      queryArgs,\n      endpointDefinition,\n      endpointName\n    }) : queryArgs\n  }), [queryArgs, serialize, endpointDefinition, endpointName]);\n  const cache2 = useRef(incoming);\n  useEffect(() => {\n    if (cache2.current.serialized !== incoming.serialized) {\n      cache2.current = incoming;\n    }\n  }, [incoming]);\n  return cache2.current.serialized === incoming.serialized ? cache2.current.queryArgs : queryArgs;\n}\n\n// src/query/react/useShallowStableValue.ts\nimport { useEffect as useEffect2, useRef as useRef2 } from \"react\";\nimport { shallowEqual } from \"react-redux\";\nfunction useShallowStableValue(value) {\n  const cache2 = useRef2(value);\n  useEffect2(() => {\n    if (!shallowEqual(cache2.current, value)) {\n      cache2.current = value;\n    }\n  }, [value]);\n  return shallowEqual(cache2.current, value) ? cache2.current : value;\n}\n\n// src/query/react/buildHooks.ts\nvar useIsomorphicLayoutEffect = typeof window !== \"undefined\" && !!window.document && !!window.document.createElement ? useLayoutEffect : useEffect3;\nvar noPendingQueryStateSelector = (selected) => {\n  if (selected.isUninitialized) {\n    return {\n      ...selected,\n      isUninitialized: false,\n      isFetching: true,\n      isLoading: selected.data !== void 0 ? false : true,\n      status: QueryStatus.pending\n    };\n  }\n  return selected;\n};\nfunction buildHooks({\n  api,\n  moduleOptions: {\n    batch,\n    hooks: {\n      useDispatch,\n      useSelector,\n      useStore\n    },\n    unstable__sideEffectsInRender,\n    createSelector: createSelector2\n  },\n  serializeQueryArgs,\n  context\n}) {\n  const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : useEffect3;\n  return {\n    buildQueryHooks,\n    buildMutationHook,\n    usePrefetch\n  };\n  function queryStatePreSelector(currentState, lastResult, queryArgs) {\n    if (lastResult?.endpointName && currentState.isUninitialized) {\n      const {\n        endpointName\n      } = lastResult;\n      const endpointDefinition = context.endpointDefinitions[endpointName];\n      if (serializeQueryArgs({\n        queryArgs: lastResult.originalArgs,\n        endpointDefinition,\n        endpointName\n      }) === serializeQueryArgs({\n        queryArgs,\n        endpointDefinition,\n        endpointName\n      }))\n        lastResult = void 0;\n    }\n    let data = currentState.isSuccess ? currentState.data : lastResult?.data;\n    if (data === void 0)\n      data = currentState.data;\n    const hasData = data !== void 0;\n    const isFetching = currentState.isLoading;\n    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;\n    const isSuccess = currentState.isSuccess || isFetching && hasData;\n    return {\n      ...currentState,\n      data,\n      currentData: currentState.data,\n      isFetching,\n      isLoading,\n      isSuccess\n    };\n  }\n  function usePrefetch(endpointName, defaultOptions) {\n    const dispatch = useDispatch();\n    const stableDefaultOptions = useShallowStableValue(defaultOptions);\n    return useCallback((arg, options) => dispatch(api.util.prefetch(endpointName, arg, {\n      ...stableDefaultOptions,\n      ...options\n    })), [endpointName, dispatch, stableDefaultOptions]);\n  }\n  function buildQueryHooks(name) {\n    const useQuerySubscription = (arg, {\n      refetchOnReconnect,\n      refetchOnFocus,\n      refetchOnMountOrArgChange,\n      skip = false,\n      pollingInterval = 0,\n      skipPollingIfUnfocused = false\n    } = {}) => {\n      const {\n        initiate\n      } = api.endpoints[name];\n      const dispatch = useDispatch();\n      const subscriptionSelectorsRef = useRef3(void 0);\n      if (!subscriptionSelectorsRef.current) {\n        const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());\n        if (process.env.NODE_ENV !== \"production\") {\n          if (typeof returnedValue !== \"object\" || typeof returnedValue?.type === \"string\") {\n            throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage(37) : `Warning: Middleware for RTK-Query API at reducerPath \"${api.reducerPath}\" has not been added to the store.\n    You must add the middleware for RTK-Query to function correctly!`);\n          }\n        }\n        subscriptionSelectorsRef.current = returnedValue;\n      }\n      const stableArg = useStableQueryArgs(\n        skip ? skipToken : arg,\n        // Even if the user provided a per-endpoint `serializeQueryArgs` with\n        // a consistent return value, _here_ we want to use the default behavior\n        // so we can tell if _anything_ actually changed. Otherwise, we can end up\n        // with a case where the query args did change but the serialization doesn't,\n        // and then we never try to initiate a refetch.\n        defaultSerializeQueryArgs,\n        context.endpointDefinitions[name],\n        name\n      );\n      const stableSubscriptionOptions = useShallowStableValue({\n        refetchOnReconnect,\n        refetchOnFocus,\n        pollingInterval,\n        skipPollingIfUnfocused\n      });\n      const lastRenderHadSubscription = useRef3(false);\n      const promiseRef = useRef3(void 0);\n      let {\n        queryCacheKey,\n        requestId\n      } = promiseRef.current || {};\n      let currentRenderHasSubscription = false;\n      if (queryCacheKey && requestId) {\n        currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);\n      }\n      const subscriptionRemoved = !currentRenderHasSubscription && lastRenderHadSubscription.current;\n      usePossiblyImmediateEffect(() => {\n        lastRenderHadSubscription.current = currentRenderHasSubscription;\n      });\n      usePossiblyImmediateEffect(() => {\n        if (subscriptionRemoved) {\n          promiseRef.current = void 0;\n        }\n      }, [subscriptionRemoved]);\n      usePossiblyImmediateEffect(() => {\n        const lastPromise = promiseRef.current;\n        if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"removeMeOnCompilation\") {\n          console.log(subscriptionRemoved);\n        }\n        if (stableArg === skipToken) {\n          lastPromise?.unsubscribe();\n          promiseRef.current = void 0;\n          return;\n        }\n        const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;\n        if (!lastPromise || lastPromise.arg !== stableArg) {\n          lastPromise?.unsubscribe();\n          const promise = dispatch(initiate(stableArg, {\n            subscriptionOptions: stableSubscriptionOptions,\n            forceRefetch: refetchOnMountOrArgChange\n          }));\n          promiseRef.current = promise;\n        } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {\n          lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);\n        }\n      }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved]);\n      useEffect3(() => {\n        return () => {\n          promiseRef.current?.unsubscribe();\n          promiseRef.current = void 0;\n        };\n      }, []);\n      return useMemo2(() => ({\n        /**\n         * A method to manually refetch data for the query\n         */\n        refetch: () => {\n          if (!promiseRef.current)\n            throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage2(38) : \"Cannot refetch a query that has not been started yet.\");\n          return promiseRef.current?.refetch();\n        }\n      }), []);\n    };\n    const useLazyQuerySubscription = ({\n      refetchOnReconnect,\n      refetchOnFocus,\n      pollingInterval = 0,\n      skipPollingIfUnfocused = false\n    } = {}) => {\n      const {\n        initiate\n      } = api.endpoints[name];\n      const dispatch = useDispatch();\n      const [arg, setArg] = useState(UNINITIALIZED_VALUE);\n      const promiseRef = useRef3(void 0);\n      const stableSubscriptionOptions = useShallowStableValue({\n        refetchOnReconnect,\n        refetchOnFocus,\n        pollingInterval,\n        skipPollingIfUnfocused\n      });\n      usePossiblyImmediateEffect(() => {\n        const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;\n        if (stableSubscriptionOptions !== lastSubscriptionOptions) {\n          promiseRef.current?.updateSubscriptionOptions(stableSubscriptionOptions);\n        }\n      }, [stableSubscriptionOptions]);\n      const subscriptionOptionsRef = useRef3(stableSubscriptionOptions);\n      usePossiblyImmediateEffect(() => {\n        subscriptionOptionsRef.current = stableSubscriptionOptions;\n      }, [stableSubscriptionOptions]);\n      const trigger = useCallback(function(arg2, preferCacheValue = false) {\n        let promise;\n        batch(() => {\n          promiseRef.current?.unsubscribe();\n          promiseRef.current = promise = dispatch(initiate(arg2, {\n            subscriptionOptions: subscriptionOptionsRef.current,\n            forceRefetch: !preferCacheValue\n          }));\n          setArg(arg2);\n        });\n        return promise;\n      }, [dispatch, initiate]);\n      useEffect3(() => {\n        return () => {\n          promiseRef?.current?.unsubscribe();\n        };\n      }, []);\n      useEffect3(() => {\n        if (arg !== UNINITIALIZED_VALUE && !promiseRef.current) {\n          trigger(arg, true);\n        }\n      }, [arg, trigger]);\n      return useMemo2(() => [trigger, arg], [trigger, arg]);\n    };\n    const useQueryState = (arg, {\n      skip = false,\n      selectFromResult\n    } = {}) => {\n      const {\n        select\n      } = api.endpoints[name];\n      const stableArg = useStableQueryArgs(skip ? skipToken : arg, serializeQueryArgs, context.endpointDefinitions[name], name);\n      const lastValue = useRef3(void 0);\n      const selectDefaultResult = useMemo2(() => createSelector2([select(stableArg), (_, lastResult) => lastResult, (_) => stableArg], queryStatePreSelector, {\n        memoizeOptions: {\n          resultEqualityCheck: shallowEqual2\n        }\n      }), [select, stableArg]);\n      const querySelector = useMemo2(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult, {\n        devModeChecks: {\n          identityFunctionCheck: \"never\"\n        }\n      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);\n      const currentState = useSelector((state) => querySelector(state, lastValue.current), shallowEqual2);\n      const store = useStore();\n      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);\n      useIsomorphicLayoutEffect(() => {\n        lastValue.current = newLastValue;\n      }, [newLastValue]);\n      return currentState;\n    };\n    return {\n      useQueryState,\n      useQuerySubscription,\n      useLazyQuerySubscription,\n      useLazyQuery(options) {\n        const [trigger, arg] = useLazyQuerySubscription(options);\n        const queryStateResults = useQueryState(arg, {\n          ...options,\n          skip: arg === UNINITIALIZED_VALUE\n        });\n        const info = useMemo2(() => ({\n          lastArg: arg\n        }), [arg]);\n        return useMemo2(() => [trigger, queryStateResults, info], [trigger, queryStateResults, info]);\n      },\n      useQuery(arg, options) {\n        const querySubscriptionResults = useQuerySubscription(arg, options);\n        const queryStateResults = useQueryState(arg, {\n          selectFromResult: arg === skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,\n          ...options\n        });\n        const {\n          data,\n          status,\n          isLoading,\n          isSuccess,\n          isError,\n          error\n        } = queryStateResults;\n        useDebugValue({\n          data,\n          status,\n          isLoading,\n          isSuccess,\n          isError,\n          error\n        });\n        return useMemo2(() => ({\n          ...queryStateResults,\n          ...querySubscriptionResults\n        }), [queryStateResults, querySubscriptionResults]);\n      }\n    };\n  }\n  function buildMutationHook(name) {\n    return ({\n      selectFromResult,\n      fixedCacheKey\n    } = {}) => {\n      const {\n        select,\n        initiate\n      } = api.endpoints[name];\n      const dispatch = useDispatch();\n      const [promise, setPromise] = useState();\n      useEffect3(() => () => {\n        if (!promise?.arg.fixedCacheKey) {\n          promise?.reset();\n        }\n      }, [promise]);\n      const triggerMutation = useCallback(function(arg) {\n        const promise2 = dispatch(initiate(arg, {\n          fixedCacheKey\n        }));\n        setPromise(promise2);\n        return promise2;\n      }, [dispatch, initiate, fixedCacheKey]);\n      const {\n        requestId\n      } = promise || {};\n      const selectDefaultResult = useMemo2(() => select({\n        fixedCacheKey,\n        requestId: promise?.requestId\n      }), [fixedCacheKey, promise, select]);\n      const mutationSelector = useMemo2(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult) : selectDefaultResult, [selectFromResult, selectDefaultResult]);\n      const currentState = useSelector(mutationSelector, shallowEqual2);\n      const originalArgs = fixedCacheKey == null ? promise?.arg.originalArgs : void 0;\n      const reset = useCallback(() => {\n        batch(() => {\n          if (promise) {\n            setPromise(void 0);\n          }\n          if (fixedCacheKey) {\n            dispatch(api.internalActions.removeMutationResult({\n              requestId,\n              fixedCacheKey\n            }));\n          }\n        });\n      }, [dispatch, fixedCacheKey, promise, requestId]);\n      const {\n        endpointName,\n        data,\n        status,\n        isLoading,\n        isSuccess,\n        isError,\n        error\n      } = currentState;\n      useDebugValue({\n        endpointName,\n        data,\n        status,\n        isLoading,\n        isSuccess,\n        isError,\n        error\n      });\n      const finalState = useMemo2(() => ({\n        ...currentState,\n        originalArgs,\n        reset\n      }), [currentState, originalArgs, reset]);\n      return useMemo2(() => [triggerMutation, finalState], [triggerMutation, finalState]);\n    };\n  }\n}\n\n// src/query/react/module.ts\nimport { batch as rrBatch, useDispatch as rrUseDispatch, useSelector as rrUseSelector, useStore as rrUseStore } from \"react-redux\";\nimport { createSelector as _createSelector } from \"reselect\";\n\n// src/query/utils/countObjectKeys.ts\nfunction countObjectKeys(obj) {\n  let count = 0;\n  for (const _key in obj) {\n    count++;\n  }\n  return count;\n}\n\n// src/query/react/module.ts\nvar reactHooksModuleName = /* @__PURE__ */ Symbol();\nvar reactHooksModule = ({\n  batch = rrBatch,\n  hooks = {\n    useDispatch: rrUseDispatch,\n    useSelector: rrUseSelector,\n    useStore: rrUseStore\n  },\n  createSelector: createSelector2 = _createSelector,\n  unstable__sideEffectsInRender = false,\n  ...rest\n} = {}) => {\n  if (process.env.NODE_ENV !== \"production\") {\n    const hookNames = [\"useDispatch\", \"useSelector\", \"useStore\"];\n    let warned = false;\n    for (const hookName of hookNames) {\n      if (countObjectKeys(rest) > 0) {\n        if (rest[hookName]) {\n          if (!warned) {\n            console.warn(\"As of RTK 2.0, the hooks now need to be specified as one object, provided under a `hooks` key:\\n`reactHooksModule({ hooks: { useDispatch, useSelector, useStore } })`\");\n            warned = true;\n          }\n        }\n        hooks[hookName] = rest[hookName];\n      }\n      if (typeof hooks[hookName] !== \"function\") {\n        throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage3(36) : `When using custom hooks for context, all ${hookNames.length} hooks need to be provided: ${hookNames.join(\", \")}.\nHook ${hookName} was either not provided or not a function.`);\n      }\n    }\n  }\n  return {\n    name: reactHooksModuleName,\n    init(api, {\n      serializeQueryArgs\n    }, context) {\n      const anyApi = api;\n      const {\n        buildQueryHooks,\n        buildMutationHook,\n        usePrefetch\n      } = buildHooks({\n        api,\n        moduleOptions: {\n          batch,\n          hooks,\n          unstable__sideEffectsInRender,\n          createSelector: createSelector2\n        },\n        serializeQueryArgs,\n        context\n      });\n      safeAssign(anyApi, {\n        usePrefetch\n      });\n      safeAssign(context, {\n        batch\n      });\n      return {\n        injectEndpoint(endpointName, definition) {\n          if (isQueryDefinition(definition)) {\n            const {\n              useQuery,\n              useLazyQuery,\n              useLazyQuerySubscription,\n              useQueryState,\n              useQuerySubscription\n            } = buildQueryHooks(endpointName);\n            safeAssign(anyApi.endpoints[endpointName], {\n              useQuery,\n              useLazyQuery,\n              useLazyQuerySubscription,\n              useQueryState,\n              useQuerySubscription\n            });\n            api[`use${capitalize(endpointName)}Query`] = useQuery;\n            api[`useLazy${capitalize(endpointName)}Query`] = useLazyQuery;\n          } else if (isMutationDefinition(definition)) {\n            const useMutation = buildMutationHook(endpointName);\n            safeAssign(anyApi.endpoints[endpointName], {\n              useMutation\n            });\n            api[`use${capitalize(endpointName)}Mutation`] = useMutation;\n          }\n        }\n      };\n    }\n  };\n};\n\n// src/query/react/index.ts\nexport * from \"@reduxjs/toolkit/query\";\n\n// src/query/react/ApiProvider.tsx\nimport { formatProdErrorMessage as _formatProdErrorMessage4 } from \"@reduxjs/toolkit\";\nimport { configureStore } from \"@reduxjs/toolkit\";\nimport { useContext } from \"react\";\nimport { useEffect as useEffect4 } from \"react\";\nimport React from \"react\";\nimport { Provider, ReactReduxContext } from \"react-redux\";\nimport { setupListeners } from \"@reduxjs/toolkit/query\";\nfunction ApiProvider(props) {\n  const context = props.context || ReactReduxContext;\n  const existingContext = useContext(context);\n  if (existingContext) {\n    throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage4(35) : \"Existing Redux context detected. If you already have a store set up, please use the traditional Redux setup.\");\n  }\n  const [store] = React.useState(() => configureStore({\n    reducer: {\n      [props.api.reducerPath]: props.api.reducer\n    },\n    middleware: (gDM) => gDM().concat(props.api.middleware)\n  }));\n  useEffect4(() => props.setupListeners === false ? void 0 : setupListeners(store.dispatch, props.setupListeners), [props.setupListeners, store.dispatch]);\n  return /* @__PURE__ */ React.createElement(Provider, { store, context }, props.children);\n}\n\n// src/query/react/index.ts\nvar createApi = /* @__PURE__ */ buildCreateApi(coreModule(), reactHooksModule());\nexport {\n  ApiProvider,\n  createApi,\n  reactHooksModule,\n  reactHooksModuleName\n};\n//# sourceMappingURL=rtk-query-react.modern.mjs.map","// src/query/core/apiState.ts\nvar QueryStatus = /* @__PURE__ */ ((QueryStatus2) => {\n  QueryStatus2[\"uninitialized\"] = \"uninitialized\";\n  QueryStatus2[\"pending\"] = \"pending\";\n  QueryStatus2[\"fulfilled\"] = \"fulfilled\";\n  QueryStatus2[\"rejected\"] = \"rejected\";\n  return QueryStatus2;\n})(QueryStatus || {});\nfunction getRequestStatusFlags(status) {\n  return {\n    status,\n    isUninitialized: status === \"uninitialized\" /* uninitialized */,\n    isLoading: status === \"pending\" /* pending */,\n    isSuccess: status === \"fulfilled\" /* fulfilled */,\n    isError: status === \"rejected\" /* rejected */\n  };\n}\n\n// src/query/utils/isAbsoluteUrl.ts\nfunction isAbsoluteUrl(url) {\n  return new RegExp(`(^|:)//`).test(url);\n}\n\n// src/query/utils/joinUrls.ts\nvar withoutTrailingSlash = (url) => url.replace(/\\/$/, \"\");\nvar withoutLeadingSlash = (url) => url.replace(/^\\//, \"\");\nfunction joinUrls(base, url) {\n  if (!base) {\n    return url;\n  }\n  if (!url) {\n    return base;\n  }\n  if (isAbsoluteUrl(url)) {\n    return url;\n  }\n  const delimiter = base.endsWith(\"/\") || !url.startsWith(\"?\") ? \"/\" : \"\";\n  base = withoutTrailingSlash(base);\n  url = withoutLeadingSlash(url);\n  return `${base}${delimiter}${url}`;\n}\n\n// src/query/utils/flatten.ts\nvar flatten = (arr) => [].concat(...arr);\n\n// src/query/utils/isOnline.ts\nfunction isOnline() {\n  return typeof navigator === \"undefined\" ? true : navigator.onLine === void 0 ? true : navigator.onLine;\n}\n\n// src/query/utils/isDocumentVisible.ts\nfunction isDocumentVisible() {\n  if (typeof document === \"undefined\") {\n    return true;\n  }\n  return document.visibilityState !== \"hidden\";\n}\n\n// src/query/core/rtkImports.ts\nimport { createAction, createSlice, createSelector, createAsyncThunk, combineReducers, createNextState, isAnyOf, isAllOf, isAction, isPending, isRejected, isFulfilled, isRejectedWithValue, isAsyncThunkAction, prepareAutoBatched, SHOULD_AUTOBATCH, isPlainObject, nanoid } from \"@reduxjs/toolkit\";\n\n// src/query/utils/copyWithStructuralSharing.ts\nvar isPlainObject2 = isPlainObject;\nfunction copyWithStructuralSharing(oldObj, newObj) {\n  if (oldObj === newObj || !(isPlainObject2(oldObj) && isPlainObject2(newObj) || Array.isArray(oldObj) && Array.isArray(newObj))) {\n    return newObj;\n  }\n  const newKeys = Object.keys(newObj);\n  const oldKeys = Object.keys(oldObj);\n  let isSameObject = newKeys.length === oldKeys.length;\n  const mergeObj = Array.isArray(newObj) ? [] : {};\n  for (const key of newKeys) {\n    mergeObj[key] = copyWithStructuralSharing(oldObj[key], newObj[key]);\n    if (isSameObject)\n      isSameObject = oldObj[key] === mergeObj[key];\n  }\n  return isSameObject ? oldObj : mergeObj;\n}\n\n// src/query/fetchBaseQuery.ts\nvar defaultFetchFn = (...args) => fetch(...args);\nvar defaultValidateStatus = (response) => response.status >= 200 && response.status <= 299;\nvar defaultIsJsonContentType = (headers) => (\n  /*applicat*/\n  /ion\\/(vnd\\.api\\+)?json/.test(headers.get(\"content-type\") || \"\")\n);\nfunction stripUndefined(obj) {\n  if (!isPlainObject(obj)) {\n    return obj;\n  }\n  const copy = {\n    ...obj\n  };\n  for (const [k, v] of Object.entries(copy)) {\n    if (v === void 0)\n      delete copy[k];\n  }\n  return copy;\n}\nfunction fetchBaseQuery({\n  baseUrl,\n  prepareHeaders = (x) => x,\n  fetchFn = defaultFetchFn,\n  paramsSerializer,\n  isJsonContentType = defaultIsJsonContentType,\n  jsonContentType = \"application/json\",\n  jsonReplacer,\n  timeout: defaultTimeout,\n  responseHandler: globalResponseHandler,\n  validateStatus: globalValidateStatus,\n  ...baseFetchOptions\n} = {}) {\n  if (typeof fetch === \"undefined\" && fetchFn === defaultFetchFn) {\n    console.warn(\"Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments.\");\n  }\n  return async (arg, api) => {\n    const {\n      signal,\n      getState,\n      extra,\n      endpoint,\n      forced,\n      type\n    } = api;\n    let meta;\n    let {\n      url,\n      headers = new Headers(baseFetchOptions.headers),\n      params = void 0,\n      responseHandler = globalResponseHandler ?? \"json\",\n      validateStatus = globalValidateStatus ?? defaultValidateStatus,\n      timeout = defaultTimeout,\n      ...rest\n    } = typeof arg == \"string\" ? {\n      url: arg\n    } : arg;\n    let config = {\n      ...baseFetchOptions,\n      signal,\n      ...rest\n    };\n    headers = new Headers(stripUndefined(headers));\n    config.headers = await prepareHeaders(headers, {\n      getState,\n      extra,\n      endpoint,\n      forced,\n      type\n    }) || headers;\n    const isJsonifiable = (body) => typeof body === \"object\" && (isPlainObject(body) || Array.isArray(body) || typeof body.toJSON === \"function\");\n    if (!config.headers.has(\"content-type\") && isJsonifiable(config.body)) {\n      config.headers.set(\"content-type\", jsonContentType);\n    }\n    if (isJsonifiable(config.body) && isJsonContentType(config.headers)) {\n      config.body = JSON.stringify(config.body, jsonReplacer);\n    }\n    if (params) {\n      const divider = ~url.indexOf(\"?\") ? \"&\" : \"?\";\n      const query = paramsSerializer ? paramsSerializer(params) : new URLSearchParams(stripUndefined(params));\n      url += divider + query;\n    }\n    url = joinUrls(baseUrl, url);\n    const request = new Request(url, config);\n    const requestClone = new Request(url, config);\n    meta = {\n      request: requestClone\n    };\n    let response, timedOut = false, timeoutId = timeout && setTimeout(() => {\n      timedOut = true;\n      api.abort();\n    }, timeout);\n    try {\n      response = await fetchFn(request);\n    } catch (e) {\n      return {\n        error: {\n          status: timedOut ? \"TIMEOUT_ERROR\" : \"FETCH_ERROR\",\n          error: String(e)\n        },\n        meta\n      };\n    } finally {\n      if (timeoutId)\n        clearTimeout(timeoutId);\n    }\n    const responseClone = response.clone();\n    meta.response = responseClone;\n    let resultData;\n    let responseText = \"\";\n    try {\n      let handleResponseError;\n      await Promise.all([\n        handleResponse(response, responseHandler).then((r) => resultData = r, (e) => handleResponseError = e),\n        // see https://github.com/node-fetch/node-fetch/issues/665#issuecomment-538995182\n        // we *have* to \"use up\" both streams at the same time or they will stop running in node-fetch scenarios\n        responseClone.text().then((r) => responseText = r, () => {\n        })\n      ]);\n      if (handleResponseError)\n        throw handleResponseError;\n    } catch (e) {\n      return {\n        error: {\n          status: \"PARSING_ERROR\",\n          originalStatus: response.status,\n          data: responseText,\n          error: String(e)\n        },\n        meta\n      };\n    }\n    return validateStatus(response, resultData) ? {\n      data: resultData,\n      meta\n    } : {\n      error: {\n        status: response.status,\n        data: resultData\n      },\n      meta\n    };\n  };\n  async function handleResponse(response, responseHandler) {\n    if (typeof responseHandler === \"function\") {\n      return responseHandler(response);\n    }\n    if (responseHandler === \"content-type\") {\n      responseHandler = isJsonContentType(response.headers) ? \"json\" : \"text\";\n    }\n    if (responseHandler === \"json\") {\n      const text = await response.text();\n      return text.length ? JSON.parse(text) : null;\n    }\n    return response.text();\n  }\n}\n\n// src/query/HandledError.ts\nvar HandledError = class {\n  constructor(value, meta = void 0) {\n    this.value = value;\n    this.meta = meta;\n  }\n};\n\n// src/query/retry.ts\nasync function defaultBackoff(attempt = 0, maxRetries = 5) {\n  const attempts = Math.min(attempt, maxRetries);\n  const timeout = ~~((Math.random() + 0.4) * (300 << attempts));\n  await new Promise((resolve) => setTimeout((res) => resolve(res), timeout));\n}\nfunction fail(e) {\n  throw Object.assign(new HandledError({\n    error: e\n  }), {\n    throwImmediately: true\n  });\n}\nvar EMPTY_OPTIONS = {};\nvar retryWithBackoff = (baseQuery, defaultOptions) => async (args, api, extraOptions) => {\n  const possibleMaxRetries = [5, (defaultOptions || EMPTY_OPTIONS).maxRetries, (extraOptions || EMPTY_OPTIONS).maxRetries].filter((x) => x !== void 0);\n  const [maxRetries] = possibleMaxRetries.slice(-1);\n  const defaultRetryCondition = (_, __, {\n    attempt\n  }) => attempt <= maxRetries;\n  const options = {\n    maxRetries,\n    backoff: defaultBackoff,\n    retryCondition: defaultRetryCondition,\n    ...defaultOptions,\n    ...extraOptions\n  };\n  let retry2 = 0;\n  while (true) {\n    try {\n      const result = await baseQuery(args, api, extraOptions);\n      if (result.error) {\n        throw new HandledError(result);\n      }\n      return result;\n    } catch (e) {\n      retry2++;\n      if (e.throwImmediately) {\n        if (e instanceof HandledError) {\n          return e.value;\n        }\n        throw e;\n      }\n      if (e instanceof HandledError && !options.retryCondition(e.value.error, args, {\n        attempt: retry2,\n        baseQueryApi: api,\n        extraOptions\n      })) {\n        return e.value;\n      }\n      await options.backoff(retry2, options.maxRetries);\n    }\n  }\n};\nvar retry = /* @__PURE__ */ Object.assign(retryWithBackoff, {\n  fail\n});\n\n// src/query/core/setupListeners.ts\nvar onFocus = /* @__PURE__ */ createAction(\"__rtkq/focused\");\nvar onFocusLost = /* @__PURE__ */ createAction(\"__rtkq/unfocused\");\nvar onOnline = /* @__PURE__ */ createAction(\"__rtkq/online\");\nvar onOffline = /* @__PURE__ */ createAction(\"__rtkq/offline\");\nvar initialized = false;\nfunction setupListeners(dispatch, customHandler) {\n  function defaultHandler() {\n    const handleFocus = () => dispatch(onFocus());\n    const handleFocusLost = () => dispatch(onFocusLost());\n    const handleOnline = () => dispatch(onOnline());\n    const handleOffline = () => dispatch(onOffline());\n    const handleVisibilityChange = () => {\n      if (window.document.visibilityState === \"visible\") {\n        handleFocus();\n      } else {\n        handleFocusLost();\n      }\n    };\n    if (!initialized) {\n      if (typeof window !== \"undefined\" && window.addEventListener) {\n        window.addEventListener(\"visibilitychange\", handleVisibilityChange, false);\n        window.addEventListener(\"focus\", handleFocus, false);\n        window.addEventListener(\"online\", handleOnline, false);\n        window.addEventListener(\"offline\", handleOffline, false);\n        initialized = true;\n      }\n    }\n    const unsubscribe = () => {\n      window.removeEventListener(\"focus\", handleFocus);\n      window.removeEventListener(\"visibilitychange\", handleVisibilityChange);\n      window.removeEventListener(\"online\", handleOnline);\n      window.removeEventListener(\"offline\", handleOffline);\n      initialized = false;\n    };\n    return unsubscribe;\n  }\n  return customHandler ? customHandler(dispatch, {\n    onFocus,\n    onFocusLost,\n    onOffline,\n    onOnline\n  }) : defaultHandler();\n}\n\n// src/query/endpointDefinitions.ts\nfunction isQueryDefinition(e) {\n  return e.type === \"query\" /* query */;\n}\nfunction isMutationDefinition(e) {\n  return e.type === \"mutation\" /* mutation */;\n}\nfunction calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {\n  if (isFunction(description)) {\n    return description(result, error, queryArg, meta).map(expandTagDescription).map(assertTagTypes);\n  }\n  if (Array.isArray(description)) {\n    return description.map(expandTagDescription).map(assertTagTypes);\n  }\n  return [];\n}\nfunction isFunction(t) {\n  return typeof t === \"function\";\n}\nfunction expandTagDescription(description) {\n  return typeof description === \"string\" ? {\n    type: description\n  } : description;\n}\n\n// src/query/core/buildInitiate.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage } from \"@reduxjs/toolkit\";\n\n// src/query/utils/isNotNullish.ts\nfunction isNotNullish(v) {\n  return v != null;\n}\n\n// src/query/utils/countObjectKeys.ts\nfunction countObjectKeys(obj) {\n  let count = 0;\n  for (const _key in obj) {\n    count++;\n  }\n  return count;\n}\n\n// src/tsHelpers.ts\nfunction asSafePromise(promise, fallback) {\n  return promise.catch(fallback);\n}\n\n// src/query/core/buildInitiate.ts\nvar forceQueryFnSymbol = Symbol(\"forceQueryFn\");\nvar isUpsertQuery = (arg) => typeof arg[forceQueryFnSymbol] === \"function\";\nfunction buildInitiate({\n  serializeQueryArgs,\n  queryThunk,\n  mutationThunk,\n  api,\n  context\n}) {\n  const runningQueries = /* @__PURE__ */ new Map();\n  const runningMutations = /* @__PURE__ */ new Map();\n  const {\n    unsubscribeQueryResult,\n    removeMutationResult,\n    updateSubscriptionOptions\n  } = api.internalActions;\n  return {\n    buildInitiateQuery,\n    buildInitiateMutation,\n    getRunningQueryThunk,\n    getRunningMutationThunk,\n    getRunningQueriesThunk,\n    getRunningMutationsThunk\n  };\n  function getRunningQueryThunk(endpointName, queryArgs) {\n    return (dispatch) => {\n      const endpointDefinition = context.endpointDefinitions[endpointName];\n      const queryCacheKey = serializeQueryArgs({\n        queryArgs,\n        endpointDefinition,\n        endpointName\n      });\n      return runningQueries.get(dispatch)?.[queryCacheKey];\n    };\n  }\n  function getRunningMutationThunk(_endpointName, fixedCacheKeyOrRequestId) {\n    return (dispatch) => {\n      return runningMutations.get(dispatch)?.[fixedCacheKeyOrRequestId];\n    };\n  }\n  function getRunningQueriesThunk() {\n    return (dispatch) => Object.values(runningQueries.get(dispatch) || {}).filter(isNotNullish);\n  }\n  function getRunningMutationsThunk() {\n    return (dispatch) => Object.values(runningMutations.get(dispatch) || {}).filter(isNotNullish);\n  }\n  function middlewareWarning(dispatch) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (middlewareWarning.triggered)\n        return;\n      const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());\n      middlewareWarning.triggered = true;\n      if (typeof returnedValue !== \"object\" || typeof returnedValue?.type === \"string\") {\n        throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage(34) : `Warning: Middleware for RTK-Query API at reducerPath \"${api.reducerPath}\" has not been added to the store.\nYou must add the middleware for RTK-Query to function correctly!`);\n      }\n    }\n  }\n  function buildInitiateQuery(endpointName, endpointDefinition) {\n    const queryAction = (arg, {\n      subscribe = true,\n      forceRefetch,\n      subscriptionOptions,\n      [forceQueryFnSymbol]: forceQueryFn,\n      ...rest\n    } = {}) => (dispatch, getState) => {\n      const queryCacheKey = serializeQueryArgs({\n        queryArgs: arg,\n        endpointDefinition,\n        endpointName\n      });\n      const thunk = queryThunk({\n        ...rest,\n        type: \"query\",\n        subscribe,\n        forceRefetch,\n        subscriptionOptions,\n        endpointName,\n        originalArgs: arg,\n        queryCacheKey,\n        [forceQueryFnSymbol]: forceQueryFn\n      });\n      const selector = api.endpoints[endpointName].select(arg);\n      const thunkResult = dispatch(thunk);\n      const stateAfter = selector(getState());\n      middlewareWarning(dispatch);\n      const {\n        requestId,\n        abort\n      } = thunkResult;\n      const skippedSynchronously = stateAfter.requestId !== requestId;\n      const runningQuery = runningQueries.get(dispatch)?.[queryCacheKey];\n      const selectFromState = () => selector(getState());\n      const statePromise = Object.assign(forceQueryFn ? (\n        // a query has been forced (upsertQueryData)\n        // -> we want to resolve it once data has been written with the data that will be written\n        thunkResult.then(selectFromState)\n      ) : skippedSynchronously && !runningQuery ? (\n        // a query has been skipped due to a condition and we do not have any currently running query\n        // -> we want to resolve it immediately with the current data\n        Promise.resolve(stateAfter)\n      ) : (\n        // query just started or one is already in flight\n        // -> wait for the running query, then resolve with data from after that\n        Promise.all([runningQuery, thunkResult]).then(selectFromState)\n      ), {\n        arg,\n        requestId,\n        subscriptionOptions,\n        queryCacheKey,\n        abort,\n        async unwrap() {\n          const result = await statePromise;\n          if (result.isError) {\n            throw result.error;\n          }\n          return result.data;\n        },\n        refetch: () => dispatch(queryAction(arg, {\n          subscribe: false,\n          forceRefetch: true\n        })),\n        unsubscribe() {\n          if (subscribe)\n            dispatch(unsubscribeQueryResult({\n              queryCacheKey,\n              requestId\n            }));\n        },\n        updateSubscriptionOptions(options) {\n          statePromise.subscriptionOptions = options;\n          dispatch(updateSubscriptionOptions({\n            endpointName,\n            requestId,\n            queryCacheKey,\n            options\n          }));\n        }\n      });\n      if (!runningQuery && !skippedSynchronously && !forceQueryFn) {\n        const running = runningQueries.get(dispatch) || {};\n        running[queryCacheKey] = statePromise;\n        runningQueries.set(dispatch, running);\n        statePromise.then(() => {\n          delete running[queryCacheKey];\n          if (!countObjectKeys(running)) {\n            runningQueries.delete(dispatch);\n          }\n        });\n      }\n      return statePromise;\n    };\n    return queryAction;\n  }\n  function buildInitiateMutation(endpointName) {\n    return (arg, {\n      track = true,\n      fixedCacheKey\n    } = {}) => (dispatch, getState) => {\n      const thunk = mutationThunk({\n        type: \"mutation\",\n        endpointName,\n        originalArgs: arg,\n        track,\n        fixedCacheKey\n      });\n      const thunkResult = dispatch(thunk);\n      middlewareWarning(dispatch);\n      const {\n        requestId,\n        abort,\n        unwrap\n      } = thunkResult;\n      const returnValuePromise = asSafePromise(thunkResult.unwrap().then((data) => ({\n        data\n      })), (error) => ({\n        error\n      }));\n      const reset = () => {\n        dispatch(removeMutationResult({\n          requestId,\n          fixedCacheKey\n        }));\n      };\n      const ret = Object.assign(returnValuePromise, {\n        arg: thunkResult.arg,\n        requestId,\n        abort,\n        unwrap,\n        reset\n      });\n      const running = runningMutations.get(dispatch) || {};\n      runningMutations.set(dispatch, running);\n      running[requestId] = ret;\n      ret.then(() => {\n        delete running[requestId];\n        if (!countObjectKeys(running)) {\n          runningMutations.delete(dispatch);\n        }\n      });\n      if (fixedCacheKey) {\n        running[fixedCacheKey] = ret;\n        ret.then(() => {\n          if (running[fixedCacheKey] === ret) {\n            delete running[fixedCacheKey];\n            if (!countObjectKeys(running)) {\n              runningMutations.delete(dispatch);\n            }\n          }\n        });\n      }\n      return ret;\n    };\n  }\n}\n\n// src/query/core/buildThunks.ts\nimport { isDraftable, produceWithPatches } from \"immer\";\nfunction defaultTransformResponse(baseQueryReturnValue) {\n  return baseQueryReturnValue;\n}\nfunction buildThunks({\n  reducerPath,\n  baseQuery,\n  context: {\n    endpointDefinitions\n  },\n  serializeQueryArgs,\n  api,\n  assertTagType\n}) {\n  const patchQueryData = (endpointName, args, patches, updateProvided) => (dispatch, getState) => {\n    const endpointDefinition = endpointDefinitions[endpointName];\n    const queryCacheKey = serializeQueryArgs({\n      queryArgs: args,\n      endpointDefinition,\n      endpointName\n    });\n    dispatch(api.internalActions.queryResultPatched({\n      queryCacheKey,\n      patches\n    }));\n    if (!updateProvided) {\n      return;\n    }\n    const newValue = api.endpoints[endpointName].select(args)(\n      // Work around TS 4.1 mismatch\n      getState()\n    );\n    const providedTags = calculateProvidedBy(endpointDefinition.providesTags, newValue.data, void 0, args, {}, assertTagType);\n    dispatch(api.internalActions.updateProvidedBy({\n      queryCacheKey,\n      providedTags\n    }));\n  };\n  const updateQueryData = (endpointName, args, updateRecipe, updateProvided = true) => (dispatch, getState) => {\n    const endpointDefinition = api.endpoints[endpointName];\n    const currentState = endpointDefinition.select(args)(\n      // Work around TS 4.1 mismatch\n      getState()\n    );\n    let ret = {\n      patches: [],\n      inversePatches: [],\n      undo: () => dispatch(api.util.patchQueryData(endpointName, args, ret.inversePatches, updateProvided))\n    };\n    if (currentState.status === \"uninitialized\" /* uninitialized */) {\n      return ret;\n    }\n    let newValue;\n    if (\"data\" in currentState) {\n      if (isDraftable(currentState.data)) {\n        const [value, patches, inversePatches] = produceWithPatches(currentState.data, updateRecipe);\n        ret.patches.push(...patches);\n        ret.inversePatches.push(...inversePatches);\n        newValue = value;\n      } else {\n        newValue = updateRecipe(currentState.data);\n        ret.patches.push({\n          op: \"replace\",\n          path: [],\n          value: newValue\n        });\n        ret.inversePatches.push({\n          op: \"replace\",\n          path: [],\n          value: currentState.data\n        });\n      }\n    }\n    if (ret.patches.length === 0) {\n      return ret;\n    }\n    dispatch(api.util.patchQueryData(endpointName, args, ret.patches, updateProvided));\n    return ret;\n  };\n  const upsertQueryData = (endpointName, args, value) => (dispatch) => {\n    return dispatch(api.endpoints[endpointName].initiate(args, {\n      subscribe: false,\n      forceRefetch: true,\n      [forceQueryFnSymbol]: () => ({\n        data: value\n      })\n    }));\n  };\n  const executeEndpoint = async (arg, {\n    signal,\n    abort,\n    rejectWithValue,\n    fulfillWithValue,\n    dispatch,\n    getState,\n    extra\n  }) => {\n    const endpointDefinition = endpointDefinitions[arg.endpointName];\n    try {\n      let transformResponse = defaultTransformResponse;\n      let result;\n      const baseQueryApi = {\n        signal,\n        abort,\n        dispatch,\n        getState,\n        extra,\n        endpoint: arg.endpointName,\n        type: arg.type,\n        forced: arg.type === \"query\" ? isForcedQuery(arg, getState()) : void 0\n      };\n      const forceQueryFn = arg.type === \"query\" ? arg[forceQueryFnSymbol] : void 0;\n      if (forceQueryFn) {\n        result = forceQueryFn();\n      } else if (endpointDefinition.query) {\n        result = await baseQuery(endpointDefinition.query(arg.originalArgs), baseQueryApi, endpointDefinition.extraOptions);\n        if (endpointDefinition.transformResponse) {\n          transformResponse = endpointDefinition.transformResponse;\n        }\n      } else {\n        result = await endpointDefinition.queryFn(arg.originalArgs, baseQueryApi, endpointDefinition.extraOptions, (arg2) => baseQuery(arg2, baseQueryApi, endpointDefinition.extraOptions));\n      }\n      if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n        const what = endpointDefinition.query ? \"`baseQuery`\" : \"`queryFn`\";\n        let err;\n        if (!result) {\n          err = `${what} did not return anything.`;\n        } else if (typeof result !== \"object\") {\n          err = `${what} did not return an object.`;\n        } else if (result.error && result.data) {\n          err = `${what} returned an object containing both \\`error\\` and \\`result\\`.`;\n        } else if (result.error === void 0 && result.data === void 0) {\n          err = `${what} returned an object containing neither a valid \\`error\\` and \\`result\\`. At least one of them should not be \\`undefined\\``;\n        } else {\n          for (const key of Object.keys(result)) {\n            if (key !== \"error\" && key !== \"data\" && key !== \"meta\") {\n              err = `The object returned by ${what} has the unknown property ${key}.`;\n              break;\n            }\n          }\n        }\n        if (err) {\n          console.error(`Error encountered handling the endpoint ${arg.endpointName}.\n              ${err}\n              It needs to return an object with either the shape \\`{ data: <value> }\\` or \\`{ error: <value> }\\` that may contain an optional \\`meta\\` property.\n              Object returned was:`, result);\n        }\n      }\n      if (result.error)\n        throw new HandledError(result.error, result.meta);\n      return fulfillWithValue(await transformResponse(result.data, result.meta, arg.originalArgs), {\n        fulfilledTimeStamp: Date.now(),\n        baseQueryMeta: result.meta,\n        [SHOULD_AUTOBATCH]: true\n      });\n    } catch (error) {\n      let catchedError = error;\n      if (catchedError instanceof HandledError) {\n        let transformErrorResponse = defaultTransformResponse;\n        if (endpointDefinition.query && endpointDefinition.transformErrorResponse) {\n          transformErrorResponse = endpointDefinition.transformErrorResponse;\n        }\n        try {\n          return rejectWithValue(await transformErrorResponse(catchedError.value, catchedError.meta, arg.originalArgs), {\n            baseQueryMeta: catchedError.meta,\n            [SHOULD_AUTOBATCH]: true\n          });\n        } catch (e) {\n          catchedError = e;\n        }\n      }\n      if (typeof process !== \"undefined\" && process.env.NODE_ENV !== \"production\") {\n        console.error(`An unhandled error occurred processing a request for the endpoint \"${arg.endpointName}\".\nIn the case of an unhandled error, no tags will be \"provided\" or \"invalidated\".`, catchedError);\n      } else {\n        console.error(catchedError);\n      }\n      throw catchedError;\n    }\n  };\n  function isForcedQuery(arg, state) {\n    const requestState = state[reducerPath]?.queries?.[arg.queryCacheKey];\n    const baseFetchOnMountOrArgChange = state[reducerPath]?.config.refetchOnMountOrArgChange;\n    const fulfilledVal = requestState?.fulfilledTimeStamp;\n    const refetchVal = arg.forceRefetch ?? (arg.subscribe && baseFetchOnMountOrArgChange);\n    if (refetchVal) {\n      return refetchVal === true || (Number(/* @__PURE__ */ new Date()) - Number(fulfilledVal)) / 1e3 >= refetchVal;\n    }\n    return false;\n  }\n  const queryThunk = createAsyncThunk(`${reducerPath}/executeQuery`, executeEndpoint, {\n    getPendingMeta() {\n      return {\n        startedTimeStamp: Date.now(),\n        [SHOULD_AUTOBATCH]: true\n      };\n    },\n    condition(queryThunkArgs, {\n      getState\n    }) {\n      const state = getState();\n      const requestState = state[reducerPath]?.queries?.[queryThunkArgs.queryCacheKey];\n      const fulfilledVal = requestState?.fulfilledTimeStamp;\n      const currentArg = queryThunkArgs.originalArgs;\n      const previousArg = requestState?.originalArgs;\n      const endpointDefinition = endpointDefinitions[queryThunkArgs.endpointName];\n      if (isUpsertQuery(queryThunkArgs)) {\n        return true;\n      }\n      if (requestState?.status === \"pending\") {\n        return false;\n      }\n      if (isForcedQuery(queryThunkArgs, state)) {\n        return true;\n      }\n      if (isQueryDefinition(endpointDefinition) && endpointDefinition?.forceRefetch?.({\n        currentArg,\n        previousArg,\n        endpointState: requestState,\n        state\n      })) {\n        return true;\n      }\n      if (fulfilledVal) {\n        return false;\n      }\n      return true;\n    },\n    dispatchConditionRejection: true\n  });\n  const mutationThunk = createAsyncThunk(`${reducerPath}/executeMutation`, executeEndpoint, {\n    getPendingMeta() {\n      return {\n        startedTimeStamp: Date.now(),\n        [SHOULD_AUTOBATCH]: true\n      };\n    }\n  });\n  const hasTheForce = (options) => \"force\" in options;\n  const hasMaxAge = (options) => \"ifOlderThan\" in options;\n  const prefetch = (endpointName, arg, options) => (dispatch, getState) => {\n    const force = hasTheForce(options) && options.force;\n    const maxAge = hasMaxAge(options) && options.ifOlderThan;\n    const queryAction = (force2 = true) => {\n      const options2 = {\n        forceRefetch: force2,\n        isPrefetch: true\n      };\n      return api.endpoints[endpointName].initiate(arg, options2);\n    };\n    const latestStateValue = api.endpoints[endpointName].select(arg)(getState());\n    if (force) {\n      dispatch(queryAction());\n    } else if (maxAge) {\n      const lastFulfilledTs = latestStateValue?.fulfilledTimeStamp;\n      if (!lastFulfilledTs) {\n        dispatch(queryAction());\n        return;\n      }\n      const shouldRetrigger = (Number(/* @__PURE__ */ new Date()) - Number(new Date(lastFulfilledTs))) / 1e3 >= maxAge;\n      if (shouldRetrigger) {\n        dispatch(queryAction());\n      }\n    } else {\n      dispatch(queryAction(false));\n    }\n  };\n  function matchesEndpoint(endpointName) {\n    return (action) => action?.meta?.arg?.endpointName === endpointName;\n  }\n  function buildMatchThunkActions(thunk, endpointName) {\n    return {\n      matchPending: isAllOf(isPending(thunk), matchesEndpoint(endpointName)),\n      matchFulfilled: isAllOf(isFulfilled(thunk), matchesEndpoint(endpointName)),\n      matchRejected: isAllOf(isRejected(thunk), matchesEndpoint(endpointName))\n    };\n  }\n  return {\n    queryThunk,\n    mutationThunk,\n    prefetch,\n    updateQueryData,\n    upsertQueryData,\n    patchQueryData,\n    buildMatchThunkActions\n  };\n}\nfunction calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {\n  return calculateProvidedBy(endpointDefinitions[action.meta.arg.endpointName][type], isFulfilled(action) ? action.payload : void 0, isRejectedWithValue(action) ? action.payload : void 0, action.meta.arg.originalArgs, \"baseQueryMeta\" in action.meta ? action.meta.baseQueryMeta : void 0, assertTagType);\n}\n\n// src/query/core/buildSlice.ts\nimport { isDraft } from \"immer\";\nimport { applyPatches, original } from \"immer\";\nfunction updateQuerySubstateIfExists(state, queryCacheKey, update) {\n  const substate = state[queryCacheKey];\n  if (substate) {\n    update(substate);\n  }\n}\nfunction getMutationCacheKey(id) {\n  return (\"arg\" in id ? id.arg.fixedCacheKey : id.fixedCacheKey) ?? id.requestId;\n}\nfunction updateMutationSubstateIfExists(state, id, update) {\n  const substate = state[getMutationCacheKey(id)];\n  if (substate) {\n    update(substate);\n  }\n}\nvar initialState = {};\nfunction buildSlice({\n  reducerPath,\n  queryThunk,\n  mutationThunk,\n  context: {\n    endpointDefinitions: definitions,\n    apiUid,\n    extractRehydrationInfo,\n    hasRehydrationInfo\n  },\n  assertTagType,\n  config\n}) {\n  const resetApiState = createAction(`${reducerPath}/resetApiState`);\n  const querySlice = createSlice({\n    name: `${reducerPath}/queries`,\n    initialState,\n    reducers: {\n      removeQueryResult: {\n        reducer(draft, {\n          payload: {\n            queryCacheKey\n          }\n        }) {\n          delete draft[queryCacheKey];\n        },\n        prepare: prepareAutoBatched()\n      },\n      queryResultPatched: {\n        reducer(draft, {\n          payload: {\n            queryCacheKey,\n            patches\n          }\n        }) {\n          updateQuerySubstateIfExists(draft, queryCacheKey, (substate) => {\n            substate.data = applyPatches(substate.data, patches.concat());\n          });\n        },\n        prepare: prepareAutoBatched()\n      }\n    },\n    extraReducers(builder) {\n      builder.addCase(queryThunk.pending, (draft, {\n        meta,\n        meta: {\n          arg\n        }\n      }) => {\n        const upserting = isUpsertQuery(arg);\n        draft[arg.queryCacheKey] ??= {\n          status: \"uninitialized\" /* uninitialized */,\n          endpointName: arg.endpointName\n        };\n        updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {\n          substate.status = \"pending\" /* pending */;\n          substate.requestId = upserting && substate.requestId ? (\n            // for `upsertQuery` **updates**, keep the current `requestId`\n            substate.requestId\n          ) : (\n            // for normal queries or `upsertQuery` **inserts** always update the `requestId`\n            meta.requestId\n          );\n          if (arg.originalArgs !== void 0) {\n            substate.originalArgs = arg.originalArgs;\n          }\n          substate.startedTimeStamp = meta.startedTimeStamp;\n        });\n      }).addCase(queryThunk.fulfilled, (draft, {\n        meta,\n        payload\n      }) => {\n        updateQuerySubstateIfExists(draft, meta.arg.queryCacheKey, (substate) => {\n          if (substate.requestId !== meta.requestId && !isUpsertQuery(meta.arg))\n            return;\n          const {\n            merge\n          } = definitions[meta.arg.endpointName];\n          substate.status = \"fulfilled\" /* fulfilled */;\n          if (merge) {\n            if (substate.data !== void 0) {\n              const {\n                fulfilledTimeStamp,\n                arg,\n                baseQueryMeta,\n                requestId\n              } = meta;\n              let newData = createNextState(substate.data, (draftSubstateData) => {\n                return merge(draftSubstateData, payload, {\n                  arg: arg.originalArgs,\n                  baseQueryMeta,\n                  fulfilledTimeStamp,\n                  requestId\n                });\n              });\n              substate.data = newData;\n            } else {\n              substate.data = payload;\n            }\n          } else {\n            substate.data = definitions[meta.arg.endpointName].structuralSharing ?? true ? copyWithStructuralSharing(isDraft(substate.data) ? original(substate.data) : substate.data, payload) : payload;\n          }\n          delete substate.error;\n          substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;\n        });\n      }).addCase(queryThunk.rejected, (draft, {\n        meta: {\n          condition,\n          arg,\n          requestId\n        },\n        error,\n        payload\n      }) => {\n        updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {\n          if (condition) {\n          } else {\n            if (substate.requestId !== requestId)\n              return;\n            substate.status = \"rejected\" /* rejected */;\n            substate.error = payload ?? error;\n          }\n        });\n      }).addMatcher(hasRehydrationInfo, (draft, action) => {\n        const {\n          queries\n        } = extractRehydrationInfo(action);\n        for (const [key, entry] of Object.entries(queries)) {\n          if (\n            // do not rehydrate entries that were currently in flight.\n            entry?.status === \"fulfilled\" /* fulfilled */ || entry?.status === \"rejected\" /* rejected */\n          ) {\n            draft[key] = entry;\n          }\n        }\n      });\n    }\n  });\n  const mutationSlice = createSlice({\n    name: `${reducerPath}/mutations`,\n    initialState,\n    reducers: {\n      removeMutationResult: {\n        reducer(draft, {\n          payload\n        }) {\n          const cacheKey = getMutationCacheKey(payload);\n          if (cacheKey in draft) {\n            delete draft[cacheKey];\n          }\n        },\n        prepare: prepareAutoBatched()\n      }\n    },\n    extraReducers(builder) {\n      builder.addCase(mutationThunk.pending, (draft, {\n        meta,\n        meta: {\n          requestId,\n          arg,\n          startedTimeStamp\n        }\n      }) => {\n        if (!arg.track)\n          return;\n        draft[getMutationCacheKey(meta)] = {\n          requestId,\n          status: \"pending\" /* pending */,\n          endpointName: arg.endpointName,\n          startedTimeStamp\n        };\n      }).addCase(mutationThunk.fulfilled, (draft, {\n        payload,\n        meta\n      }) => {\n        if (!meta.arg.track)\n          return;\n        updateMutationSubstateIfExists(draft, meta, (substate) => {\n          if (substate.requestId !== meta.requestId)\n            return;\n          substate.status = \"fulfilled\" /* fulfilled */;\n          substate.data = payload;\n          substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;\n        });\n      }).addCase(mutationThunk.rejected, (draft, {\n        payload,\n        error,\n        meta\n      }) => {\n        if (!meta.arg.track)\n          return;\n        updateMutationSubstateIfExists(draft, meta, (substate) => {\n          if (substate.requestId !== meta.requestId)\n            return;\n          substate.status = \"rejected\" /* rejected */;\n          substate.error = payload ?? error;\n        });\n      }).addMatcher(hasRehydrationInfo, (draft, action) => {\n        const {\n          mutations\n        } = extractRehydrationInfo(action);\n        for (const [key, entry] of Object.entries(mutations)) {\n          if (\n            // do not rehydrate entries that were currently in flight.\n            (entry?.status === \"fulfilled\" /* fulfilled */ || entry?.status === \"rejected\" /* rejected */) && // only rehydrate endpoints that were persisted using a `fixedCacheKey`\n            key !== entry?.requestId\n          ) {\n            draft[key] = entry;\n          }\n        }\n      });\n    }\n  });\n  const invalidationSlice = createSlice({\n    name: `${reducerPath}/invalidation`,\n    initialState,\n    reducers: {\n      updateProvidedBy: {\n        reducer(draft, action) {\n          const {\n            queryCacheKey,\n            providedTags\n          } = action.payload;\n          for (const tagTypeSubscriptions of Object.values(draft)) {\n            for (const idSubscriptions of Object.values(tagTypeSubscriptions)) {\n              const foundAt = idSubscriptions.indexOf(queryCacheKey);\n              if (foundAt !== -1) {\n                idSubscriptions.splice(foundAt, 1);\n              }\n            }\n          }\n          for (const {\n            type,\n            id\n          } of providedTags) {\n            const subscribedQueries = (draft[type] ??= {})[id || \"__internal_without_id\"] ??= [];\n            const alreadySubscribed = subscribedQueries.includes(queryCacheKey);\n            if (!alreadySubscribed) {\n              subscribedQueries.push(queryCacheKey);\n            }\n          }\n        },\n        prepare: prepareAutoBatched()\n      }\n    },\n    extraReducers(builder) {\n      builder.addCase(querySlice.actions.removeQueryResult, (draft, {\n        payload: {\n          queryCacheKey\n        }\n      }) => {\n        for (const tagTypeSubscriptions of Object.values(draft)) {\n          for (const idSubscriptions of Object.values(tagTypeSubscriptions)) {\n            const foundAt = idSubscriptions.indexOf(queryCacheKey);\n            if (foundAt !== -1) {\n              idSubscriptions.splice(foundAt, 1);\n            }\n          }\n        }\n      }).addMatcher(hasRehydrationInfo, (draft, action) => {\n        const {\n          provided\n        } = extractRehydrationInfo(action);\n        for (const [type, incomingTags] of Object.entries(provided)) {\n          for (const [id, cacheKeys] of Object.entries(incomingTags)) {\n            const subscribedQueries = (draft[type] ??= {})[id || \"__internal_without_id\"] ??= [];\n            for (const queryCacheKey of cacheKeys) {\n              const alreadySubscribed = subscribedQueries.includes(queryCacheKey);\n              if (!alreadySubscribed) {\n                subscribedQueries.push(queryCacheKey);\n              }\n            }\n          }\n        }\n      }).addMatcher(isAnyOf(isFulfilled(queryThunk), isRejectedWithValue(queryThunk)), (draft, action) => {\n        const providedTags = calculateProvidedByThunk(action, \"providesTags\", definitions, assertTagType);\n        const {\n          queryCacheKey\n        } = action.meta.arg;\n        invalidationSlice.caseReducers.updateProvidedBy(draft, invalidationSlice.actions.updateProvidedBy({\n          queryCacheKey,\n          providedTags\n        }));\n      });\n    }\n  });\n  const subscriptionSlice = createSlice({\n    name: `${reducerPath}/subscriptions`,\n    initialState,\n    reducers: {\n      updateSubscriptionOptions(d, a) {\n      },\n      unsubscribeQueryResult(d, a) {\n      },\n      internal_getRTKQSubscriptions() {\n      }\n    }\n  });\n  const internalSubscriptionsSlice = createSlice({\n    name: `${reducerPath}/internalSubscriptions`,\n    initialState,\n    reducers: {\n      subscriptionsUpdated: {\n        reducer(state, action) {\n          return applyPatches(state, action.payload);\n        },\n        prepare: prepareAutoBatched()\n      }\n    }\n  });\n  const configSlice = createSlice({\n    name: `${reducerPath}/config`,\n    initialState: {\n      online: isOnline(),\n      focused: isDocumentVisible(),\n      middlewareRegistered: false,\n      ...config\n    },\n    reducers: {\n      middlewareRegistered(state, {\n        payload\n      }) {\n        state.middlewareRegistered = state.middlewareRegistered === \"conflict\" || apiUid !== payload ? \"conflict\" : true;\n      }\n    },\n    extraReducers: (builder) => {\n      builder.addCase(onOnline, (state) => {\n        state.online = true;\n      }).addCase(onOffline, (state) => {\n        state.online = false;\n      }).addCase(onFocus, (state) => {\n        state.focused = true;\n      }).addCase(onFocusLost, (state) => {\n        state.focused = false;\n      }).addMatcher(hasRehydrationInfo, (draft) => ({\n        ...draft\n      }));\n    }\n  });\n  const combinedReducer = combineReducers({\n    queries: querySlice.reducer,\n    mutations: mutationSlice.reducer,\n    provided: invalidationSlice.reducer,\n    subscriptions: internalSubscriptionsSlice.reducer,\n    config: configSlice.reducer\n  });\n  const reducer = (state, action) => combinedReducer(resetApiState.match(action) ? void 0 : state, action);\n  const actions = {\n    ...configSlice.actions,\n    ...querySlice.actions,\n    ...subscriptionSlice.actions,\n    ...internalSubscriptionsSlice.actions,\n    ...mutationSlice.actions,\n    ...invalidationSlice.actions,\n    resetApiState\n  };\n  return {\n    reducer,\n    actions\n  };\n}\n\n// src/query/core/buildSelectors.ts\nvar skipToken = /* @__PURE__ */ Symbol.for(\"RTKQ/skipToken\");\nvar initialSubState = {\n  status: \"uninitialized\" /* uninitialized */\n};\nvar defaultQuerySubState = /* @__PURE__ */ createNextState(initialSubState, () => {\n});\nvar defaultMutationSubState = /* @__PURE__ */ createNextState(initialSubState, () => {\n});\nfunction buildSelectors({\n  serializeQueryArgs,\n  reducerPath,\n  createSelector: createSelector2\n}) {\n  const selectSkippedQuery = (state) => defaultQuerySubState;\n  const selectSkippedMutation = (state) => defaultMutationSubState;\n  return {\n    buildQuerySelector,\n    buildMutationSelector,\n    selectInvalidatedBy,\n    selectCachedArgsForQuery\n  };\n  function withRequestFlags(substate) {\n    return {\n      ...substate,\n      ...getRequestStatusFlags(substate.status)\n    };\n  }\n  function selectInternalState(rootState) {\n    const state = rootState[reducerPath];\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!state) {\n        if (selectInternalState.triggered)\n          return state;\n        selectInternalState.triggered = true;\n        console.error(`Error: No data found at \\`state.${reducerPath}\\`. Did you forget to add the reducer to the store?`);\n      }\n    }\n    return state;\n  }\n  function buildQuerySelector(endpointName, endpointDefinition) {\n    return (queryArgs) => {\n      const serializedArgs = serializeQueryArgs({\n        queryArgs,\n        endpointDefinition,\n        endpointName\n      });\n      const selectQuerySubstate = (state) => selectInternalState(state)?.queries?.[serializedArgs] ?? defaultQuerySubState;\n      const finalSelectQuerySubState = queryArgs === skipToken ? selectSkippedQuery : selectQuerySubstate;\n      return createSelector2(finalSelectQuerySubState, withRequestFlags);\n    };\n  }\n  function buildMutationSelector() {\n    return (id) => {\n      let mutationId;\n      if (typeof id === \"object\") {\n        mutationId = getMutationCacheKey(id) ?? skipToken;\n      } else {\n        mutationId = id;\n      }\n      const selectMutationSubstate = (state) => selectInternalState(state)?.mutations?.[mutationId] ?? defaultMutationSubState;\n      const finalSelectMutationSubstate = mutationId === skipToken ? selectSkippedMutation : selectMutationSubstate;\n      return createSelector2(finalSelectMutationSubstate, withRequestFlags);\n    };\n  }\n  function selectInvalidatedBy(state, tags) {\n    const apiState = state[reducerPath];\n    const toInvalidate = /* @__PURE__ */ new Set();\n    for (const tag of tags.map(expandTagDescription)) {\n      const provided = apiState.provided[tag.type];\n      if (!provided) {\n        continue;\n      }\n      let invalidateSubscriptions = (tag.id !== void 0 ? (\n        // id given: invalidate all queries that provide this type & id\n        provided[tag.id]\n      ) : (\n        // no id: invalidate all queries that provide this type\n        flatten(Object.values(provided))\n      )) ?? [];\n      for (const invalidate of invalidateSubscriptions) {\n        toInvalidate.add(invalidate);\n      }\n    }\n    return flatten(Array.from(toInvalidate.values()).map((queryCacheKey) => {\n      const querySubState = apiState.queries[queryCacheKey];\n      return querySubState ? [{\n        queryCacheKey,\n        endpointName: querySubState.endpointName,\n        originalArgs: querySubState.originalArgs\n      }] : [];\n    }));\n  }\n  function selectCachedArgsForQuery(state, queryName) {\n    return Object.values(state[reducerPath].queries).filter((entry) => entry?.endpointName === queryName && entry.status !== \"uninitialized\" /* uninitialized */).map((entry) => entry.originalArgs);\n  }\n}\n\n// src/query/createApi.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage2 } from \"@reduxjs/toolkit\";\n\n// src/query/defaultSerializeQueryArgs.ts\nvar cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;\nvar defaultSerializeQueryArgs = ({\n  endpointName,\n  queryArgs\n}) => {\n  let serialized = \"\";\n  const cached = cache?.get(queryArgs);\n  if (typeof cached === \"string\") {\n    serialized = cached;\n  } else {\n    const stringified = JSON.stringify(queryArgs, (key, value) => {\n      value = typeof value === \"bigint\" ? {\n        $bigint: value.toString()\n      } : value;\n      value = isPlainObject(value) ? Object.keys(value).sort().reduce((acc, key2) => {\n        acc[key2] = value[key2];\n        return acc;\n      }, {}) : value;\n      return value;\n    });\n    if (isPlainObject(queryArgs)) {\n      cache?.set(queryArgs, stringified);\n    }\n    serialized = stringified;\n  }\n  return `${endpointName}(${serialized})`;\n};\n\n// src/query/createApi.ts\nimport { weakMapMemoize } from \"reselect\";\nfunction buildCreateApi(...modules) {\n  return function baseCreateApi(options) {\n    const extractRehydrationInfo = weakMapMemoize((action) => options.extractRehydrationInfo?.(action, {\n      reducerPath: options.reducerPath ?? \"api\"\n    }));\n    const optionsWithDefaults = {\n      reducerPath: \"api\",\n      keepUnusedDataFor: 60,\n      refetchOnMountOrArgChange: false,\n      refetchOnFocus: false,\n      refetchOnReconnect: false,\n      invalidationBehavior: \"delayed\",\n      ...options,\n      extractRehydrationInfo,\n      serializeQueryArgs(queryArgsApi) {\n        let finalSerializeQueryArgs = defaultSerializeQueryArgs;\n        if (\"serializeQueryArgs\" in queryArgsApi.endpointDefinition) {\n          const endpointSQA = queryArgsApi.endpointDefinition.serializeQueryArgs;\n          finalSerializeQueryArgs = (queryArgsApi2) => {\n            const initialResult = endpointSQA(queryArgsApi2);\n            if (typeof initialResult === \"string\") {\n              return initialResult;\n            } else {\n              return defaultSerializeQueryArgs({\n                ...queryArgsApi2,\n                queryArgs: initialResult\n              });\n            }\n          };\n        } else if (options.serializeQueryArgs) {\n          finalSerializeQueryArgs = options.serializeQueryArgs;\n        }\n        return finalSerializeQueryArgs(queryArgsApi);\n      },\n      tagTypes: [...options.tagTypes || []]\n    };\n    const context = {\n      endpointDefinitions: {},\n      batch(fn) {\n        fn();\n      },\n      apiUid: nanoid(),\n      extractRehydrationInfo,\n      hasRehydrationInfo: weakMapMemoize((action) => extractRehydrationInfo(action) != null)\n    };\n    const api = {\n      injectEndpoints,\n      enhanceEndpoints({\n        addTagTypes,\n        endpoints\n      }) {\n        if (addTagTypes) {\n          for (const eT of addTagTypes) {\n            if (!optionsWithDefaults.tagTypes.includes(eT)) {\n              ;\n              optionsWithDefaults.tagTypes.push(eT);\n            }\n          }\n        }\n        if (endpoints) {\n          for (const [endpointName, partialDefinition] of Object.entries(endpoints)) {\n            if (typeof partialDefinition === \"function\") {\n              partialDefinition(context.endpointDefinitions[endpointName]);\n            } else {\n              Object.assign(context.endpointDefinitions[endpointName] || {}, partialDefinition);\n            }\n          }\n        }\n        return api;\n      }\n    };\n    const initializedModules = modules.map((m) => m.init(api, optionsWithDefaults, context));\n    function injectEndpoints(inject) {\n      const evaluatedEndpoints = inject.endpoints({\n        query: (x) => ({\n          ...x,\n          type: \"query\" /* query */\n        }),\n        mutation: (x) => ({\n          ...x,\n          type: \"mutation\" /* mutation */\n        })\n      });\n      for (const [endpointName, definition] of Object.entries(evaluatedEndpoints)) {\n        if (inject.overrideExisting !== true && endpointName in context.endpointDefinitions) {\n          if (inject.overrideExisting === \"throw\") {\n            throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage2(39) : `called \\`injectEndpoints\\` to override already-existing endpointName ${endpointName} without specifying \\`overrideExisting: true\\``);\n          } else if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n            console.error(`called \\`injectEndpoints\\` to override already-existing endpointName ${endpointName} without specifying \\`overrideExisting: true\\``);\n          }\n          continue;\n        }\n        context.endpointDefinitions[endpointName] = definition;\n        for (const m of initializedModules) {\n          m.injectEndpoint(endpointName, definition);\n        }\n      }\n      return api;\n    }\n    return api.injectEndpoints({\n      endpoints: options.endpoints\n    });\n  };\n}\n\n// src/query/fakeBaseQuery.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage3 } from \"@reduxjs/toolkit\";\nfunction fakeBaseQuery() {\n  return function() {\n    throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage3(33) : \"When using `fakeBaseQuery`, all queries & mutations must use the `queryFn` definition syntax.\");\n  };\n}\n\n// src/query/core/buildMiddleware/cacheCollection.ts\nimport { isAnyOf as isAnyOf2 } from \"@reduxjs/toolkit\";\nfunction isObjectEmpty(obj) {\n  for (let k in obj) {\n    return false;\n  }\n  return true;\n}\nvar THIRTY_TWO_BIT_MAX_TIMER_SECONDS = 2147483647 / 1e3 - 1;\nvar buildCacheCollectionHandler = ({\n  reducerPath,\n  api,\n  queryThunk,\n  context,\n  internalState\n}) => {\n  const {\n    removeQueryResult,\n    unsubscribeQueryResult\n  } = api.internalActions;\n  const canTriggerUnsubscribe = isAnyOf2(unsubscribeQueryResult.match, queryThunk.fulfilled, queryThunk.rejected);\n  function anySubscriptionsRemainingForKey(queryCacheKey) {\n    const subscriptions = internalState.currentSubscriptions[queryCacheKey];\n    return !!subscriptions && !isObjectEmpty(subscriptions);\n  }\n  const currentRemovalTimeouts = {};\n  const handler = (action, mwApi, internalState2) => {\n    if (canTriggerUnsubscribe(action)) {\n      const state = mwApi.getState()[reducerPath];\n      const {\n        queryCacheKey\n      } = unsubscribeQueryResult.match(action) ? action.payload : action.meta.arg;\n      handleUnsubscribe(queryCacheKey, state.queries[queryCacheKey]?.endpointName, mwApi, state.config);\n    }\n    if (api.util.resetApiState.match(action)) {\n      for (const [key, timeout] of Object.entries(currentRemovalTimeouts)) {\n        if (timeout)\n          clearTimeout(timeout);\n        delete currentRemovalTimeouts[key];\n      }\n    }\n    if (context.hasRehydrationInfo(action)) {\n      const state = mwApi.getState()[reducerPath];\n      const {\n        queries\n      } = context.extractRehydrationInfo(action);\n      for (const [queryCacheKey, queryState] of Object.entries(queries)) {\n        handleUnsubscribe(queryCacheKey, queryState?.endpointName, mwApi, state.config);\n      }\n    }\n  };\n  function handleUnsubscribe(queryCacheKey, endpointName, api2, config) {\n    const endpointDefinition = context.endpointDefinitions[endpointName];\n    const keepUnusedDataFor = endpointDefinition?.keepUnusedDataFor ?? config.keepUnusedDataFor;\n    if (keepUnusedDataFor === Infinity) {\n      return;\n    }\n    const finalKeepUnusedDataFor = Math.max(0, Math.min(keepUnusedDataFor, THIRTY_TWO_BIT_MAX_TIMER_SECONDS));\n    if (!anySubscriptionsRemainingForKey(queryCacheKey)) {\n      const currentTimeout = currentRemovalTimeouts[queryCacheKey];\n      if (currentTimeout) {\n        clearTimeout(currentTimeout);\n      }\n      currentRemovalTimeouts[queryCacheKey] = setTimeout(() => {\n        if (!anySubscriptionsRemainingForKey(queryCacheKey)) {\n          api2.dispatch(removeQueryResult({\n            queryCacheKey\n          }));\n        }\n        delete currentRemovalTimeouts[queryCacheKey];\n      }, finalKeepUnusedDataFor * 1e3);\n    }\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/invalidationByTags.ts\nvar buildInvalidationByTagsHandler = ({\n  reducerPath,\n  context,\n  context: {\n    endpointDefinitions\n  },\n  mutationThunk,\n  queryThunk,\n  api,\n  assertTagType,\n  refetchQuery,\n  internalState\n}) => {\n  const {\n    removeQueryResult\n  } = api.internalActions;\n  const isThunkActionWithTags = isAnyOf(isFulfilled(mutationThunk), isRejectedWithValue(mutationThunk));\n  const isQueryEnd = isAnyOf(isFulfilled(mutationThunk, queryThunk), isRejected(mutationThunk, queryThunk));\n  let pendingTagInvalidations = [];\n  const handler = (action, mwApi) => {\n    if (isThunkActionWithTags(action)) {\n      invalidateTags(calculateProvidedByThunk(action, \"invalidatesTags\", endpointDefinitions, assertTagType), mwApi);\n    } else if (isQueryEnd(action)) {\n      invalidateTags([], mwApi);\n    } else if (api.util.invalidateTags.match(action)) {\n      invalidateTags(calculateProvidedBy(action.payload, void 0, void 0, void 0, void 0, assertTagType), mwApi);\n    }\n  };\n  function hasPendingRequests(state) {\n    for (const key in state.queries) {\n      if (state.queries[key]?.status === \"pending\" /* pending */)\n        return true;\n    }\n    for (const key in state.mutations) {\n      if (state.mutations[key]?.status === \"pending\" /* pending */)\n        return true;\n    }\n    return false;\n  }\n  function invalidateTags(newTags, mwApi) {\n    const rootState = mwApi.getState();\n    const state = rootState[reducerPath];\n    pendingTagInvalidations.push(...newTags);\n    if (state.config.invalidationBehavior === \"delayed\" && hasPendingRequests(state)) {\n      return;\n    }\n    const tags = pendingTagInvalidations;\n    pendingTagInvalidations = [];\n    if (tags.length === 0)\n      return;\n    const toInvalidate = api.util.selectInvalidatedBy(rootState, tags);\n    context.batch(() => {\n      const valuesArray = Array.from(toInvalidate.values());\n      for (const {\n        queryCacheKey\n      } of valuesArray) {\n        const querySubState = state.queries[queryCacheKey];\n        const subscriptionSubState = internalState.currentSubscriptions[queryCacheKey] ?? {};\n        if (querySubState) {\n          if (countObjectKeys(subscriptionSubState) === 0) {\n            mwApi.dispatch(removeQueryResult({\n              queryCacheKey\n            }));\n          } else if (querySubState.status !== \"uninitialized\" /* uninitialized */) {\n            mwApi.dispatch(refetchQuery(querySubState, queryCacheKey));\n          }\n        }\n      }\n    });\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/polling.ts\nvar buildPollingHandler = ({\n  reducerPath,\n  queryThunk,\n  api,\n  refetchQuery,\n  internalState\n}) => {\n  const currentPolls = {};\n  const handler = (action, mwApi) => {\n    if (api.internalActions.updateSubscriptionOptions.match(action) || api.internalActions.unsubscribeQueryResult.match(action)) {\n      updatePollingInterval(action.payload, mwApi);\n    }\n    if (queryThunk.pending.match(action) || queryThunk.rejected.match(action) && action.meta.condition) {\n      updatePollingInterval(action.meta.arg, mwApi);\n    }\n    if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action) && !action.meta.condition) {\n      startNextPoll(action.meta.arg, mwApi);\n    }\n    if (api.util.resetApiState.match(action)) {\n      clearPolls();\n    }\n  };\n  function startNextPoll({\n    queryCacheKey\n  }, api2) {\n    const state = api2.getState()[reducerPath];\n    const querySubState = state.queries[queryCacheKey];\n    const subscriptions = internalState.currentSubscriptions[queryCacheKey];\n    if (!querySubState || querySubState.status === \"uninitialized\" /* uninitialized */)\n      return;\n    const {\n      lowestPollingInterval,\n      skipPollingIfUnfocused\n    } = findLowestPollingInterval(subscriptions);\n    if (!Number.isFinite(lowestPollingInterval))\n      return;\n    const currentPoll = currentPolls[queryCacheKey];\n    if (currentPoll?.timeout) {\n      clearTimeout(currentPoll.timeout);\n      currentPoll.timeout = void 0;\n    }\n    const nextPollTimestamp = Date.now() + lowestPollingInterval;\n    currentPolls[queryCacheKey] = {\n      nextPollTimestamp,\n      pollingInterval: lowestPollingInterval,\n      timeout: setTimeout(() => {\n        if (state.config.focused || !skipPollingIfUnfocused) {\n          api2.dispatch(refetchQuery(querySubState, queryCacheKey));\n        }\n        startNextPoll({\n          queryCacheKey\n        }, api2);\n      }, lowestPollingInterval)\n    };\n  }\n  function updatePollingInterval({\n    queryCacheKey\n  }, api2) {\n    const state = api2.getState()[reducerPath];\n    const querySubState = state.queries[queryCacheKey];\n    const subscriptions = internalState.currentSubscriptions[queryCacheKey];\n    if (!querySubState || querySubState.status === \"uninitialized\" /* uninitialized */) {\n      return;\n    }\n    const {\n      lowestPollingInterval\n    } = findLowestPollingInterval(subscriptions);\n    if (!Number.isFinite(lowestPollingInterval)) {\n      cleanupPollForKey(queryCacheKey);\n      return;\n    }\n    const currentPoll = currentPolls[queryCacheKey];\n    const nextPollTimestamp = Date.now() + lowestPollingInterval;\n    if (!currentPoll || nextPollTimestamp < currentPoll.nextPollTimestamp) {\n      startNextPoll({\n        queryCacheKey\n      }, api2);\n    }\n  }\n  function cleanupPollForKey(key) {\n    const existingPoll = currentPolls[key];\n    if (existingPoll?.timeout) {\n      clearTimeout(existingPoll.timeout);\n    }\n    delete currentPolls[key];\n  }\n  function clearPolls() {\n    for (const key of Object.keys(currentPolls)) {\n      cleanupPollForKey(key);\n    }\n  }\n  function findLowestPollingInterval(subscribers = {}) {\n    let skipPollingIfUnfocused = false;\n    let lowestPollingInterval = Number.POSITIVE_INFINITY;\n    for (let key in subscribers) {\n      if (!!subscribers[key].pollingInterval) {\n        lowestPollingInterval = Math.min(subscribers[key].pollingInterval, lowestPollingInterval);\n        skipPollingIfUnfocused = subscribers[key].skipPollingIfUnfocused || skipPollingIfUnfocused;\n      }\n    }\n    return {\n      lowestPollingInterval,\n      skipPollingIfUnfocused\n    };\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/windowEventHandling.ts\nvar buildWindowEventHandler = ({\n  reducerPath,\n  context,\n  api,\n  refetchQuery,\n  internalState\n}) => {\n  const {\n    removeQueryResult\n  } = api.internalActions;\n  const handler = (action, mwApi) => {\n    if (onFocus.match(action)) {\n      refetchValidQueries(mwApi, \"refetchOnFocus\");\n    }\n    if (onOnline.match(action)) {\n      refetchValidQueries(mwApi, \"refetchOnReconnect\");\n    }\n  };\n  function refetchValidQueries(api2, type) {\n    const state = api2.getState()[reducerPath];\n    const queries = state.queries;\n    const subscriptions = internalState.currentSubscriptions;\n    context.batch(() => {\n      for (const queryCacheKey of Object.keys(subscriptions)) {\n        const querySubState = queries[queryCacheKey];\n        const subscriptionSubState = subscriptions[queryCacheKey];\n        if (!subscriptionSubState || !querySubState)\n          continue;\n        const shouldRefetch = Object.values(subscriptionSubState).some((sub) => sub[type] === true) || Object.values(subscriptionSubState).every((sub) => sub[type] === void 0) && state.config[type];\n        if (shouldRefetch) {\n          if (countObjectKeys(subscriptionSubState) === 0) {\n            api2.dispatch(removeQueryResult({\n              queryCacheKey\n            }));\n          } else if (querySubState.status !== \"uninitialized\" /* uninitialized */) {\n            api2.dispatch(refetchQuery(querySubState, queryCacheKey));\n          }\n        }\n      }\n    });\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/cacheLifecycle.ts\nvar neverResolvedError = new Error(\"Promise never resolved before cacheEntryRemoved.\");\nvar buildCacheLifecycleHandler = ({\n  api,\n  reducerPath,\n  context,\n  queryThunk,\n  mutationThunk,\n  internalState\n}) => {\n  const isQueryThunk = isAsyncThunkAction(queryThunk);\n  const isMutationThunk = isAsyncThunkAction(mutationThunk);\n  const isFulfilledThunk = isFulfilled(queryThunk, mutationThunk);\n  const lifecycleMap = {};\n  const handler = (action, mwApi, stateBefore) => {\n    const cacheKey = getCacheKey(action);\n    if (queryThunk.pending.match(action)) {\n      const oldState = stateBefore[reducerPath].queries[cacheKey];\n      const state = mwApi.getState()[reducerPath].queries[cacheKey];\n      if (!oldState && state) {\n        handleNewKey(action.meta.arg.endpointName, action.meta.arg.originalArgs, cacheKey, mwApi, action.meta.requestId);\n      }\n    } else if (mutationThunk.pending.match(action)) {\n      const state = mwApi.getState()[reducerPath].mutations[cacheKey];\n      if (state) {\n        handleNewKey(action.meta.arg.endpointName, action.meta.arg.originalArgs, cacheKey, mwApi, action.meta.requestId);\n      }\n    } else if (isFulfilledThunk(action)) {\n      const lifecycle = lifecycleMap[cacheKey];\n      if (lifecycle?.valueResolved) {\n        lifecycle.valueResolved({\n          data: action.payload,\n          meta: action.meta.baseQueryMeta\n        });\n        delete lifecycle.valueResolved;\n      }\n    } else if (api.internalActions.removeQueryResult.match(action) || api.internalActions.removeMutationResult.match(action)) {\n      const lifecycle = lifecycleMap[cacheKey];\n      if (lifecycle) {\n        delete lifecycleMap[cacheKey];\n        lifecycle.cacheEntryRemoved();\n      }\n    } else if (api.util.resetApiState.match(action)) {\n      for (const [cacheKey2, lifecycle] of Object.entries(lifecycleMap)) {\n        delete lifecycleMap[cacheKey2];\n        lifecycle.cacheEntryRemoved();\n      }\n    }\n  };\n  function getCacheKey(action) {\n    if (isQueryThunk(action))\n      return action.meta.arg.queryCacheKey;\n    if (isMutationThunk(action)) {\n      return action.meta.arg.fixedCacheKey ?? action.meta.requestId;\n    }\n    if (api.internalActions.removeQueryResult.match(action))\n      return action.payload.queryCacheKey;\n    if (api.internalActions.removeMutationResult.match(action))\n      return getMutationCacheKey(action.payload);\n    return \"\";\n  }\n  function handleNewKey(endpointName, originalArgs, queryCacheKey, mwApi, requestId) {\n    const endpointDefinition = context.endpointDefinitions[endpointName];\n    const onCacheEntryAdded = endpointDefinition?.onCacheEntryAdded;\n    if (!onCacheEntryAdded)\n      return;\n    let lifecycle = {};\n    const cacheEntryRemoved = new Promise((resolve) => {\n      lifecycle.cacheEntryRemoved = resolve;\n    });\n    const cacheDataLoaded = Promise.race([new Promise((resolve) => {\n      lifecycle.valueResolved = resolve;\n    }), cacheEntryRemoved.then(() => {\n      throw neverResolvedError;\n    })]);\n    cacheDataLoaded.catch(() => {\n    });\n    lifecycleMap[queryCacheKey] = lifecycle;\n    const selector = api.endpoints[endpointName].select(endpointDefinition.type === \"query\" /* query */ ? originalArgs : queryCacheKey);\n    const extra = mwApi.dispatch((_, __, extra2) => extra2);\n    const lifecycleApi = {\n      ...mwApi,\n      getCacheEntry: () => selector(mwApi.getState()),\n      requestId,\n      extra,\n      updateCachedData: endpointDefinition.type === \"query\" /* query */ ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,\n      cacheDataLoaded,\n      cacheEntryRemoved\n    };\n    const runningHandler = onCacheEntryAdded(originalArgs, lifecycleApi);\n    Promise.resolve(runningHandler).catch((e) => {\n      if (e === neverResolvedError)\n        return;\n      throw e;\n    });\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/queryLifecycle.ts\nvar buildQueryLifecycleHandler = ({\n  api,\n  context,\n  queryThunk,\n  mutationThunk\n}) => {\n  const isPendingThunk = isPending(queryThunk, mutationThunk);\n  const isRejectedThunk = isRejected(queryThunk, mutationThunk);\n  const isFullfilledThunk = isFulfilled(queryThunk, mutationThunk);\n  const lifecycleMap = {};\n  const handler = (action, mwApi) => {\n    if (isPendingThunk(action)) {\n      const {\n        requestId,\n        arg: {\n          endpointName,\n          originalArgs\n        }\n      } = action.meta;\n      const endpointDefinition = context.endpointDefinitions[endpointName];\n      const onQueryStarted = endpointDefinition?.onQueryStarted;\n      if (onQueryStarted) {\n        const lifecycle = {};\n        const queryFulfilled = new Promise((resolve, reject) => {\n          lifecycle.resolve = resolve;\n          lifecycle.reject = reject;\n        });\n        queryFulfilled.catch(() => {\n        });\n        lifecycleMap[requestId] = lifecycle;\n        const selector = api.endpoints[endpointName].select(endpointDefinition.type === \"query\" /* query */ ? originalArgs : requestId);\n        const extra = mwApi.dispatch((_, __, extra2) => extra2);\n        const lifecycleApi = {\n          ...mwApi,\n          getCacheEntry: () => selector(mwApi.getState()),\n          requestId,\n          extra,\n          updateCachedData: endpointDefinition.type === \"query\" /* query */ ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,\n          queryFulfilled\n        };\n        onQueryStarted(originalArgs, lifecycleApi);\n      }\n    } else if (isFullfilledThunk(action)) {\n      const {\n        requestId,\n        baseQueryMeta\n      } = action.meta;\n      lifecycleMap[requestId]?.resolve({\n        data: action.payload,\n        meta: baseQueryMeta\n      });\n      delete lifecycleMap[requestId];\n    } else if (isRejectedThunk(action)) {\n      const {\n        requestId,\n        rejectedWithValue,\n        baseQueryMeta\n      } = action.meta;\n      lifecycleMap[requestId]?.reject({\n        error: action.payload ?? action.error,\n        isUnhandledError: !rejectedWithValue,\n        meta: baseQueryMeta\n      });\n      delete lifecycleMap[requestId];\n    }\n  };\n  return handler;\n};\n\n// src/query/core/buildMiddleware/devMiddleware.ts\nvar buildDevCheckHandler = ({\n  api,\n  context: {\n    apiUid\n  },\n  reducerPath\n}) => {\n  return (action, mwApi) => {\n    if (api.util.resetApiState.match(action)) {\n      mwApi.dispatch(api.internalActions.middlewareRegistered(apiUid));\n    }\n    if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n      if (api.internalActions.middlewareRegistered.match(action) && action.payload === apiUid && mwApi.getState()[reducerPath]?.config?.middlewareRegistered === \"conflict\") {\n        console.warn(`There is a mismatch between slice and middleware for the reducerPath \"${reducerPath}\".\nYou can only have one api per reducer path, this will lead to crashes in various situations!${reducerPath === \"api\" ? `\nIf you have multiple apis, you *have* to specify the reducerPath option when using createApi!` : \"\"}`);\n      }\n    }\n  };\n};\n\n// src/query/core/buildMiddleware/batchActions.ts\nimport { produceWithPatches as produceWithPatches2 } from \"immer\";\nvar buildBatchedActionsHandler = ({\n  api,\n  queryThunk,\n  internalState\n}) => {\n  const subscriptionsPrefix = `${api.reducerPath}/subscriptions`;\n  let previousSubscriptions = null;\n  let updateSyncTimer = null;\n  const {\n    updateSubscriptionOptions,\n    unsubscribeQueryResult\n  } = api.internalActions;\n  const actuallyMutateSubscriptions = (mutableState, action) => {\n    if (updateSubscriptionOptions.match(action)) {\n      const {\n        queryCacheKey,\n        requestId,\n        options\n      } = action.payload;\n      if (mutableState?.[queryCacheKey]?.[requestId]) {\n        mutableState[queryCacheKey][requestId] = options;\n      }\n      return true;\n    }\n    if (unsubscribeQueryResult.match(action)) {\n      const {\n        queryCacheKey,\n        requestId\n      } = action.payload;\n      if (mutableState[queryCacheKey]) {\n        delete mutableState[queryCacheKey][requestId];\n      }\n      return true;\n    }\n    if (api.internalActions.removeQueryResult.match(action)) {\n      delete mutableState[action.payload.queryCacheKey];\n      return true;\n    }\n    if (queryThunk.pending.match(action)) {\n      const {\n        meta: {\n          arg,\n          requestId\n        }\n      } = action;\n      const substate = mutableState[arg.queryCacheKey] ??= {};\n      substate[`${requestId}_running`] = {};\n      if (arg.subscribe) {\n        substate[requestId] = arg.subscriptionOptions ?? substate[requestId] ?? {};\n      }\n      return true;\n    }\n    let mutated = false;\n    if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action)) {\n      const state = mutableState[action.meta.arg.queryCacheKey] || {};\n      const key = `${action.meta.requestId}_running`;\n      mutated ||= !!state[key];\n      delete state[key];\n    }\n    if (queryThunk.rejected.match(action)) {\n      const {\n        meta: {\n          condition,\n          arg,\n          requestId\n        }\n      } = action;\n      if (condition && arg.subscribe) {\n        const substate = mutableState[arg.queryCacheKey] ??= {};\n        substate[requestId] = arg.subscriptionOptions ?? substate[requestId] ?? {};\n        mutated = true;\n      }\n    }\n    return mutated;\n  };\n  const getSubscriptions = () => internalState.currentSubscriptions;\n  const getSubscriptionCount = (queryCacheKey) => {\n    const subscriptions = getSubscriptions();\n    const subscriptionsForQueryArg = subscriptions[queryCacheKey] ?? {};\n    return countObjectKeys(subscriptionsForQueryArg);\n  };\n  const isRequestSubscribed = (queryCacheKey, requestId) => {\n    const subscriptions = getSubscriptions();\n    return !!subscriptions?.[queryCacheKey]?.[requestId];\n  };\n  const subscriptionSelectors = {\n    getSubscriptions,\n    getSubscriptionCount,\n    isRequestSubscribed\n  };\n  return (action, mwApi) => {\n    if (!previousSubscriptions) {\n      previousSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));\n    }\n    if (api.util.resetApiState.match(action)) {\n      previousSubscriptions = internalState.currentSubscriptions = {};\n      updateSyncTimer = null;\n      return [true, false];\n    }\n    if (api.internalActions.internal_getRTKQSubscriptions.match(action)) {\n      return [false, subscriptionSelectors];\n    }\n    const didMutate = actuallyMutateSubscriptions(internalState.currentSubscriptions, action);\n    let actionShouldContinue = true;\n    if (didMutate) {\n      if (!updateSyncTimer) {\n        updateSyncTimer = setTimeout(() => {\n          const newSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));\n          const [, patches] = produceWithPatches2(previousSubscriptions, () => newSubscriptions);\n          mwApi.next(api.internalActions.subscriptionsUpdated(patches));\n          previousSubscriptions = newSubscriptions;\n          updateSyncTimer = null;\n        }, 500);\n      }\n      const isSubscriptionSliceAction = typeof action.type == \"string\" && !!action.type.startsWith(subscriptionsPrefix);\n      const isAdditionalSubscriptionAction = queryThunk.rejected.match(action) && action.meta.condition && !!action.meta.arg.subscribe;\n      actionShouldContinue = !isSubscriptionSliceAction && !isAdditionalSubscriptionAction;\n    }\n    return [actionShouldContinue, false];\n  };\n};\n\n// src/query/core/buildMiddleware/index.ts\nfunction buildMiddleware(input) {\n  const {\n    reducerPath,\n    queryThunk,\n    api,\n    context\n  } = input;\n  const {\n    apiUid\n  } = context;\n  const actions = {\n    invalidateTags: createAction(`${reducerPath}/invalidateTags`)\n  };\n  const isThisApiSliceAction = (action) => action.type.startsWith(`${reducerPath}/`);\n  const handlerBuilders = [buildDevCheckHandler, buildCacheCollectionHandler, buildInvalidationByTagsHandler, buildPollingHandler, buildCacheLifecycleHandler, buildQueryLifecycleHandler];\n  const middleware = (mwApi) => {\n    let initialized2 = false;\n    let internalState = {\n      currentSubscriptions: {}\n    };\n    const builderArgs = {\n      ...input,\n      internalState,\n      refetchQuery,\n      isThisApiSliceAction\n    };\n    const handlers = handlerBuilders.map((build) => build(builderArgs));\n    const batchedActionsHandler = buildBatchedActionsHandler(builderArgs);\n    const windowEventsHandler = buildWindowEventHandler(builderArgs);\n    return (next) => {\n      return (action) => {\n        if (!isAction(action)) {\n          return next(action);\n        }\n        if (!initialized2) {\n          initialized2 = true;\n          mwApi.dispatch(api.internalActions.middlewareRegistered(apiUid));\n        }\n        const mwApiWithNext = {\n          ...mwApi,\n          next\n        };\n        const stateBefore = mwApi.getState();\n        const [actionShouldContinue, internalProbeResult] = batchedActionsHandler(action, mwApiWithNext, stateBefore);\n        let res;\n        if (actionShouldContinue) {\n          res = next(action);\n        } else {\n          res = internalProbeResult;\n        }\n        if (!!mwApi.getState()[reducerPath]) {\n          windowEventsHandler(action, mwApiWithNext, stateBefore);\n          if (isThisApiSliceAction(action) || context.hasRehydrationInfo(action)) {\n            for (let handler of handlers) {\n              handler(action, mwApiWithNext, stateBefore);\n            }\n          }\n        }\n        return res;\n      };\n    };\n  };\n  return {\n    middleware,\n    actions\n  };\n  function refetchQuery(querySubState, queryCacheKey, override = {}) {\n    return queryThunk({\n      type: \"query\",\n      endpointName: querySubState.endpointName,\n      originalArgs: querySubState.originalArgs,\n      subscribe: false,\n      forceRefetch: true,\n      queryCacheKey,\n      ...override\n    });\n  }\n}\n\n// src/query/tsHelpers.ts\nfunction assertCast(v) {\n}\nfunction safeAssign(target, ...args) {\n  return Object.assign(target, ...args);\n}\n\n// src/query/core/module.ts\nimport { enablePatches } from \"immer\";\nvar coreModuleName = /* @__PURE__ */ Symbol();\nvar coreModule = ({\n  createSelector: createSelector2 = createSelector\n} = {}) => ({\n  name: coreModuleName,\n  init(api, {\n    baseQuery,\n    tagTypes,\n    reducerPath,\n    serializeQueryArgs,\n    keepUnusedDataFor,\n    refetchOnMountOrArgChange,\n    refetchOnFocus,\n    refetchOnReconnect,\n    invalidationBehavior\n  }, context) {\n    enablePatches();\n    assertCast(serializeQueryArgs);\n    const assertTagType = (tag) => {\n      if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n        if (!tagTypes.includes(tag.type)) {\n          console.error(`Tag type '${tag.type}' was used, but not specified in \\`tagTypes\\`!`);\n        }\n      }\n      return tag;\n    };\n    Object.assign(api, {\n      reducerPath,\n      endpoints: {},\n      internalActions: {\n        onOnline,\n        onOffline,\n        onFocus,\n        onFocusLost\n      },\n      util: {}\n    });\n    const {\n      queryThunk,\n      mutationThunk,\n      patchQueryData,\n      updateQueryData,\n      upsertQueryData,\n      prefetch,\n      buildMatchThunkActions\n    } = buildThunks({\n      baseQuery,\n      reducerPath,\n      context,\n      api,\n      serializeQueryArgs,\n      assertTagType\n    });\n    const {\n      reducer,\n      actions: sliceActions\n    } = buildSlice({\n      context,\n      queryThunk,\n      mutationThunk,\n      reducerPath,\n      assertTagType,\n      config: {\n        refetchOnFocus,\n        refetchOnReconnect,\n        refetchOnMountOrArgChange,\n        keepUnusedDataFor,\n        reducerPath,\n        invalidationBehavior\n      }\n    });\n    safeAssign(api.util, {\n      patchQueryData,\n      updateQueryData,\n      upsertQueryData,\n      prefetch,\n      resetApiState: sliceActions.resetApiState\n    });\n    safeAssign(api.internalActions, sliceActions);\n    const {\n      middleware,\n      actions: middlewareActions\n    } = buildMiddleware({\n      reducerPath,\n      context,\n      queryThunk,\n      mutationThunk,\n      api,\n      assertTagType\n    });\n    safeAssign(api.util, middlewareActions);\n    safeAssign(api, {\n      reducer,\n      middleware\n    });\n    const {\n      buildQuerySelector,\n      buildMutationSelector,\n      selectInvalidatedBy,\n      selectCachedArgsForQuery\n    } = buildSelectors({\n      serializeQueryArgs,\n      reducerPath,\n      createSelector: createSelector2\n    });\n    safeAssign(api.util, {\n      selectInvalidatedBy,\n      selectCachedArgsForQuery\n    });\n    const {\n      buildInitiateQuery,\n      buildInitiateMutation,\n      getRunningMutationThunk,\n      getRunningMutationsThunk,\n      getRunningQueriesThunk,\n      getRunningQueryThunk\n    } = buildInitiate({\n      queryThunk,\n      mutationThunk,\n      api,\n      serializeQueryArgs,\n      context\n    });\n    safeAssign(api.util, {\n      getRunningMutationThunk,\n      getRunningMutationsThunk,\n      getRunningQueryThunk,\n      getRunningQueriesThunk\n    });\n    return {\n      name: coreModuleName,\n      injectEndpoint(endpointName, definition) {\n        const anyApi = api;\n        anyApi.endpoints[endpointName] ??= {};\n        if (isQueryDefinition(definition)) {\n          safeAssign(anyApi.endpoints[endpointName], {\n            name: endpointName,\n            select: buildQuerySelector(endpointName, definition),\n            initiate: buildInitiateQuery(endpointName, definition)\n          }, buildMatchThunkActions(queryThunk, endpointName));\n        } else if (isMutationDefinition(definition)) {\n          safeAssign(anyApi.endpoints[endpointName], {\n            name: endpointName,\n            select: buildMutationSelector(),\n            initiate: buildInitiateMutation(endpointName)\n          }, buildMatchThunkActions(mutationThunk, endpointName));\n        }\n      }\n    };\n  }\n});\n\n// src/query/core/index.ts\nvar createApi = /* @__PURE__ */ buildCreateApi(coreModule());\nexport {\n  QueryStatus,\n  buildCreateApi,\n  copyWithStructuralSharing,\n  coreModule,\n  coreModuleName,\n  createApi,\n  defaultSerializeQueryArgs,\n  fakeBaseQuery,\n  fetchBaseQuery,\n  retry,\n  setupListeners,\n  skipToken\n};\n//# sourceMappingURL=rtk-query.modern.mjs.map"],"names":["safeAssign","target","args","Object","assign","capitalize","str","replace","toUpperCase","cache","WeakMap","defaultSerializeQueryArgs","endpointName","queryArgs","serialized","cached","get","stringified","JSON","stringify","key","value","$bigint","toString","keys","sort","reduce","acc","key2","set","UNINITIALIZED_VALUE","Symbol","useStableQueryArgs","serialize","endpointDefinition","incoming","useMemo","cache2","useRef","useEffect","current","useShallowStableValue","useIsomorphicLayoutEffect","window","document","createElement","useLayoutEffect","noPendingQueryStateSelector","selected","isUninitialized","isFetching","isLoading","data","status","pending","reactHooksModuleName","createApi","batch","hooks","useDispatch","useSelector","useStore","createSelector","createSelector2","unstable__sideEffectsInRender","rest","name","init","api","serializeQueryArgs","context","anyApi","buildQueryHooks","buildMutationHook","usePrefetch","moduleOptions","usePossiblyImmediateEffect","cb","useQuerySubscription","arg","refetchOnReconnect","refetchOnFocus","refetchOnMountOrArgChange","skip","pollingInterval","skipPollingIfUnfocused","initiate","endpoints","dispatch","subscriptionSelectorsRef","returnedValue","internalActions","internal_getRTKQSubscriptions","stableArg","endpointDefinitions","stableSubscriptionOptions","lastRenderHadSubscription","promiseRef","queryCacheKey","requestId","currentRenderHasSubscription","isRequestSubscribed","subscriptionRemoved","lastPromise","unsubscribe","lastSubscriptionOptions","subscriptionOptions","updateSubscriptionOptions","promise","forceRefetch","refetch","Error","useLazyQuerySubscription","setArg","useState","subscriptionOptionsRef","trigger","useCallback","arg2","preferCacheValue","useQueryState","selectFromResult","select","lastValue","selectDefaultResult","_","lastResult","queryStatePreSelector","memoizeOptions","resultEqualityCheck","querySelector","devModeChecks","identityFunctionCheck","currentState","state","store","newLastValue","getState","useLazyQuery","options","queryStateResults","info","lastArg","useQuery","querySubscriptionResults","isSuccess","isError","error","useDebugValue","fixedCacheKey","setPromise","reset","triggerMutation","promise2","mutationSelector","originalArgs","removeMutationResult","finalState","defaultOptions","stableDefaultOptions","util","prefetch","hasData","currentData","buildHooks","injectEndpoint","definition","type","e","isMutationDefinition","useMutation","reactHooksModule","QueryStatus","QueryStatus2","flatten","arr","concat","isPlainObject2","copyWithStructuralSharing","oldObj","newObj","Array","isArray","newKeys","oldKeys","isSameObject","length","mergeObj","HandledError","constructor","meta","this","onFocus","onFocusLost","onOnline","onOffline","initialized","setupListeners","customHandler","handleFocus","handleOnline","handleOffline","handleVisibilityChange","visibilityState","addEventListener","removeEventListener","defaultHandler","isQueryDefinition","calculateProvidedBy","description","result","queryArg","assertTagTypes","map","expandTagDescription","isNotNullish","v","countObjectKeys","obj","count","_key","forceQueryFnSymbol","isUpsertQuery","defaultTransformResponse","baseQueryReturnValue","calculateProvidedByThunk","action","assertTagType","payload","baseQueryMeta","updateQuerySubstateIfExists","update","substate","getMutationCacheKey","id","updateMutationSubstateIfExists","initialState","buildSlice","reducerPath","queryThunk","mutationThunk","definitions","apiUid","extractRehydrationInfo","hasRehydrationInfo","config","resetApiState","querySlice","reducers","removeQueryResult","reducer","draft","prepare","queryResultPatched","patches","extraReducers","builder","addCase","upserting","startedTimeStamp","fulfilled","merge","fulfilledTimeStamp","newData","draftSubstateData","structuralSharing","rejected","condition","addMatcher","queries","entry","entries","mutationSlice","cacheKey","track","mutations","invalidationSlice","updateProvidedBy","providedTags","tagTypeSubscriptions","values","idSubscriptions","foundAt","indexOf","splice","subscribedQueries","includes","push","actions","provided","incomingTags","cacheKeys","caseReducers","subscriptionSlice","d","a","unsubscribeQueryResult","internalSubscriptionsSlice","subscriptionsUpdated","configSlice","online","navigator","onLine","focused","middlewareRegistered","combinedReducer","subscriptions","match","skipToken","for","initialSubState","defaultQuerySubState","defaultMutationSubState","buildCreateApi","modules","optionsWithDefaults","keepUnusedDataFor","invalidationBehavior","queryArgsApi","finalSerializeQueryArgs","endpointSQA","queryArgsApi2","initialResult","tagTypes","fn","injectEndpoints","inject","evaluatedEndpoints","query","x","mutation","overrideExisting","m","initializedModules","enhanceEndpoints","addTagTypes","eT","partialDefinition","buildCacheCollectionHandler","internalState","canTriggerUnsubscribe","anySubscriptionsRemainingForKey","currentSubscriptions","k","isObjectEmpty","currentRemovalTimeouts","handleUnsubscribe","api2","Infinity","finalKeepUnusedDataFor","Math","max","min","currentTimeout","clearTimeout","setTimeout","mwApi","internalState2","timeout","queryState","buildInvalidationByTagsHandler","refetchQuery","isThunkActionWithTags","isQueryEnd","pendingTagInvalidations","invalidateTags","newTags","rootState","hasPendingRequests","tags","toInvalidate","selectInvalidatedBy","valuesArray","from","querySubState","subscriptionSubState","buildPollingHandler","currentPolls","startNextPoll","lowestPollingInterval","findLowestPollingInterval","Number","isFinite","currentPoll","nextPollTimestamp","Date","now","updatePollingInterval","cleanupPollForKey","existingPoll","subscribers","POSITIVE_INFINITY","clearPolls","neverResolvedError","buildCacheLifecycleHandler","isQueryThunk","isMutationThunk","isFulfilledThunk","lifecycleMap","handleNewKey","onCacheEntryAdded","lifecycle","cacheEntryRemoved","Promise","resolve","cacheDataLoaded","race","valueResolved","then","catch","selector","extra","__","extra2","lifecycleApi","getCacheEntry","updateCachedData","updateRecipe","updateQueryData","runningHandler","stateBefore","getCacheKey","oldState","cacheKey2","buildQueryLifecycleHandler","isPendingThunk","isRejectedThunk","isFullfilledThunk","onQueryStarted","queryFulfilled","reject","rejectedWithValue","isUnhandledError","buildDevCheckHandler","buildBatchedActionsHandler","subscriptionsPrefix","previousSubscriptions","updateSyncTimer","getSubscriptions","subscriptionSelectors","getSubscriptionCount","parse","didMutate","mutableState","subscribe","mutated","actuallyMutateSubscriptions","actionShouldContinue","newSubscriptions","next","isSubscriptionSliceAction","startsWith","isAdditionalSubscriptionAction","buildMiddleware","input","isThisApiSliceAction","handlerBuilders","middleware","initialized2","builderArgs","handlers","build","batchedActionsHandler","windowEventsHandler","refetchValidQueries","some","sub","every","buildWindowEventHandler","mwApiWithNext","internalProbeResult","res","handler","override","coreModuleName","coreModule","baseQuery","tag","patchQueryData","upsertQueryData","buildMatchThunkActions","executeEndpoint","async","signal","abort","rejectWithValue","fulfillWithValue","transformResponse","baseQueryApi","endpoint","forced","isForcedQuery","forceQueryFn","extraOptions","queryFn","catchedError","transformErrorResponse","requestState","baseFetchOnMountOrArgChange","fulfilledVal","refetchVal","getPendingMeta","queryThunkArgs","currentArg","previousArg","endpointState","dispatchConditionRejection","matchesEndpoint","force","hasTheForce","maxAge","hasMaxAge","ifOlderThan","queryAction","force2","options2","isPrefetch","latestStateValue","lastFulfilledTs","updateProvided","newValue","ret","inversePatches","undo","op","path","providesTags","thunk","matchPending","matchFulfilled","matchRejected","buildThunks","sliceActions","middlewareActions","buildQuerySelector","buildMutationSelector","selectCachedArgsForQuery","selectSkippedQuery","selectSkippedMutation","serializedArgs","selectInternalState","withRequestFlags","mutationId","apiState","Set","invalidateSubscriptions","invalidate","add","queryName","filter","buildSelectors","buildInitiateQuery","buildInitiateMutation","getRunningMutationThunk","getRunningMutationsThunk","getRunningQueriesThunk","getRunningQueryThunk","runningQueries","Map","runningMutations","thunkResult","stateAfter","middlewareWarning","skippedSynchronously","runningQuery","selectFromState","statePromise","all","unwrap","running","delete","returnValuePromise","fallback","_endpointName","fixedCacheKeyOrRequestId","buildInitiate"],"sourceRoot":""}