Upload 243 files

frontend/node_modules/@reduxjs/toolkit/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Mark Erikson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

frontend/node_modules/@reduxjs/toolkit/README.md

@@ -0,0 +1,110 @@
+# Redux Toolkit
+
+![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/reduxjs/redux-toolkit/tests.yml?style=flat-square)
+[![npm version](https://img.shields.io/npm/v/@reduxjs/toolkit.svg?style=flat-square)](https://www.npmjs.com/package/@reduxjs/toolkit)
+[![npm downloads](https://img.shields.io/npm/dm/@reduxjs/toolkit.svg?style=flat-square&label=RTK+downloads)](https://www.npmjs.com/package/@reduxjs/toolkit)
+
+**The official, opinionated, batteries-included toolset for efficient Redux development**
+
+## Installation
+
+### Create a React Redux App
+
+The recommended way to start new apps with React and Redux Toolkit is by using [our official Redux Toolkit + TS template for Vite](https://github.com/reduxjs/redux-templates), or by creating a new Next.js project using [Next's `with-redux` template](https://github.com/vercel/next.js/tree/canary/examples/with-redux).
+
+Both of these already have Redux Toolkit and React-Redux configured appropriately for that build tool, and come with a small example app that demonstrates how to use several of Redux Toolkit's features.
+
+```bash
+# Vite with our Redux+TS template
+# (using the `degit` tool to clone and extract the template)
+npx degit reduxjs/redux-templates/packages/vite-template-redux my-app
+
+# Next.js using the `with-redux` template
+npx create-next-app --example with-redux my-app
+```
+
+We do not currently have official React Native templates, but recommend these templates for standard React Native and for Expo:
+
+- https://github.com/rahsheen/react-native-template-redux-typescript
+- https://github.com/rahsheen/expo-template-redux-typescript
+
+### An Existing App
+
+Redux Toolkit is available as a package on NPM for use with a module bundler or in a Node application:
+
+```bash
+# NPM
+npm install @reduxjs/toolkit
+
+# Yarn
+yarn add @reduxjs/toolkit
+```
+
+The package includes a precompiled ESM build that can be used as a [`<script type="module">` tag](https://unpkg.com/@reduxjs/toolkit/dist/redux-toolkit.browser.mjs) directly in the browser.
+
+## Documentation
+
+The Redux Toolkit docs are available at **https://redux-toolkit.js.org**, including API references and usage guides for all of the APIs included in Redux Toolkit.
+
+The Redux core docs at https://redux.js.org includes the full Redux tutorials, as well usage guides on general Redux patterns.
+
+## Purpose
+
+The **Redux Toolkit** package is intended to be the standard way to write Redux logic. It was originally created to help address three common concerns about Redux:
+
+- "Configuring a Redux store is too complicated"
+- "I have to add a lot of packages to get Redux to do anything useful"
+- "Redux requires too much boilerplate code"
+
+We can't solve every use case, but in the spirit of [`create-react-app`](https://github.com/facebook/create-react-app), we can try to provide some tools that abstract over the setup process and handle the most common use cases, as well as include some useful utilities that will let the user simplify their application code.
+
+Because of that, this package is deliberately limited in scope. It does _not_ address concepts like "reusable encapsulated Redux modules", folder or file structures, managing entity relationships in the store, and so on.
+
+Redux Toolkit also includes a powerful data fetching and caching capability that we've dubbed "RTK Query". It's included in the package as a separate set of entry points. It's optional, but can eliminate the need to hand-write data fetching logic yourself.
+
+## What's Included
+
+Redux Toolkit includes these APIs:
+
+- `configureStore()`: wraps `createStore` to provide simplified configuration options and good defaults. It can automatically combine your slice reducers, add whatever Redux middleware you supply, includes `redux-thunk` by default, and enables use of the Redux DevTools Extension.
+- `createReducer()`: lets you supply a lookup table of action types to case reducer functions, rather than writing switch statements. In addition, it automatically uses the [`immer` library](https://github.com/mweststrate/immer) to let you write simpler immutable updates with normal mutative code, like `state.todos[3].completed = true`.
+- `createAction()`: generates an action creator function for the given action type string. The function itself has `toString()` defined, so that it can be used in place of the type constant.
+- `createSlice()`: combines `createReducer()` + `createAction()`. Accepts an object of reducer functions, a slice name, and an initial state value, and automatically generates a slice reducer with corresponding action creators and action types.
+- `combineSlices()`: combines multiple slices into a single reducer, and allows "lazy loading" of slices after initialisation.
+- `createListenerMiddleware()`: lets you define "listener" entries that contain an "effect" callback with additional logic, and a way to specify when that callback should run based on dispatched actions or state changes. A lightweight alternative to Redux async middleware like sagas and observables.
+- `createAsyncThunk()`: accepts an action type string and a function that returns a promise, and generates a thunk that dispatches `pending/resolved/rejected` action types based on that promise
+- `createEntityAdapter()`: generates a set of reusable reducers and selectors to manage normalized data in the store
+- The `createSelector()` utility from the [Reselect](https://github.com/reduxjs/reselect) library, re-exported for ease of use.
+
+For details, see [the Redux Toolkit API Reference section in the docs](https://redux-toolkit.js.org/api/configureStore).
+
+## RTK Query
+
+**RTK Query** is provided as an optional addon within the `@reduxjs/toolkit` package. It is purpose-built to solve the use case of data fetching and caching, supplying a compact, but powerful toolset to define an API interface layer for your app. It is intended to simplify common cases for loading data in a web application, eliminating the need to hand-write data fetching & caching logic yourself.
+
+RTK Query is built on top of the Redux Toolkit core for its implementation, using [Redux](https://redux.js.org/) internally for its architecture. Although knowledge of Redux and RTK are not required to use RTK Query, you should explore all of the additional global store management capabilities they provide, as well as installing the [Redux DevTools browser extension](https://github.com/reduxjs/redux-devtools), which works flawlessly with RTK Query to traverse and replay a timeline of your request & cache behavior.
+
+RTK Query is included within the installation of the core Redux Toolkit package. It is available via either of the two entry points below:
+
+```ts no-transpile
+import { createApi } from '@reduxjs/toolkit/query'
+
+/* React-specific entry point that automatically generates
+   hooks corresponding to the defined endpoints */
+import { createApi } from '@reduxjs/toolkit/query/react'
+```
+
+### What's included
+
+RTK Query includes these APIs:
+
+- `createApi()`: The core of RTK Query's functionality. It allows you to define a set of endpoints describe how to retrieve data from a series of endpoints, including configuration of how to fetch and transform that data. In most cases, you should use this once per app, with "one API slice per base URL" as a rule of thumb.
+- `fetchBaseQuery()`: A small wrapper around fetch that aims to simplify requests. Intended as the recommended baseQuery to be used in createApi for the majority of users.
+- `<ApiProvider />`: Can be used as a Provider if you do not already have a Redux store.
+- `setupListeners()`: A utility used to enable refetchOnMount and refetchOnReconnect behaviors.
+
+See the [**RTK Query Overview**](https://redux-toolkit.js.org/rtk-query/overview) page for more details on what RTK Query is, what problems it solves, and how to use it.
+
+## Contributing
+
+Please refer to our [contributing guide](/CONTRIBUTING.md) to learn about our development process, how to propose bugfixes and improvements, and how to build and test your changes to Redux Toolkit.

frontend/node_modules/@reduxjs/toolkit/dist/cjs/index.js

@@ -0,0 +1,6 @@
+'use strict'
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./redux-toolkit.production.min.cjs')
+} else {
+  module.exports = require('./redux-toolkit.development.cjs')
+}

frontend/node_modules/@reduxjs/toolkit/dist/cjs/redux-toolkit.development.cjs

@@ -0,0 +1,2362 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ReducerType: () => ReducerType,
+  SHOULD_AUTOBATCH: () => SHOULD_AUTOBATCH,
+  TaskAbortError: () => TaskAbortError,
+  Tuple: () => Tuple,
+  addListener: () => addListener,
+  asyncThunkCreator: () => asyncThunkCreator,
+  autoBatchEnhancer: () => autoBatchEnhancer,
+  buildCreateSlice: () => buildCreateSlice,
+  clearAllListeners: () => clearAllListeners,
+  combineSlices: () => combineSlices,
+  configureStore: () => configureStore,
+  createAction: () => createAction,
+  createActionCreatorInvariantMiddleware: () => createActionCreatorInvariantMiddleware,
+  createAsyncThunk: () => createAsyncThunk,
+  createDraftSafeSelector: () => createDraftSafeSelector,
+  createDraftSafeSelectorCreator: () => createDraftSafeSelectorCreator,
+  createDynamicMiddleware: () => createDynamicMiddleware,
+  createEntityAdapter: () => createEntityAdapter,
+  createImmutableStateInvariantMiddleware: () => createImmutableStateInvariantMiddleware,
+  createListenerMiddleware: () => createListenerMiddleware,
+  createNextState: () => import_immer6.produce,
+  createReducer: () => createReducer,
+  createSelector: () => import_reselect2.createSelector,
+  createSelectorCreator: () => import_reselect2.createSelectorCreator,
+  createSerializableStateInvariantMiddleware: () => createSerializableStateInvariantMiddleware,
+  createSlice: () => createSlice,
+  current: () => import_immer6.current,
+  findNonSerializableValue: () => findNonSerializableValue,
+  formatProdErrorMessage: () => formatProdErrorMessage,
+  freeze: () => import_immer6.freeze,
+  isActionCreator: () => isActionCreator,
+  isAllOf: () => isAllOf,
+  isAnyOf: () => isAnyOf,
+  isAsyncThunkAction: () => isAsyncThunkAction,
+  isDraft: () => import_immer6.isDraft,
+  isFluxStandardAction: () => isFSA,
+  isFulfilled: () => isFulfilled,
+  isImmutableDefault: () => isImmutableDefault,
+  isPending: () => isPending,
+  isPlain: () => isPlain,
+  isRejected: () => isRejected,
+  isRejectedWithValue: () => isRejectedWithValue,
+  lruMemoize: () => import_reselect2.lruMemoize,
+  miniSerializeError: () => miniSerializeError,
+  nanoid: () => nanoid,
+  original: () => import_immer6.original,
+  prepareAutoBatched: () => prepareAutoBatched,
+  removeListener: () => removeListener,
+  unwrapResult: () => unwrapResult,
+  weakMapMemoize: () => import_reselect2.weakMapMemoize
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("redux"), module.exports);
+var import_immer6 = require("immer");
+var import_reselect2 = require("reselect");
+
+// src/createDraftSafeSelector.ts
+var import_immer = require("immer");
+var import_reselect = require("reselect");
+var createDraftSafeSelectorCreator = (...args) => {
+  const createSelector2 = (0, import_reselect.createSelectorCreator)(...args);
+  const createDraftSafeSelector2 = Object.assign((...args2) => {
+    const selector = createSelector2(...args2);
+    const wrappedSelector = (value, ...rest) => selector((0, import_immer.isDraft)(value) ? (0, import_immer.current)(value) : value, ...rest);
+    Object.assign(wrappedSelector, selector);
+    return wrappedSelector;
+  }, {
+    withTypes: () => createDraftSafeSelector2
+  });
+  return createDraftSafeSelector2;
+};
+var createDraftSafeSelector = /* @__PURE__ */ createDraftSafeSelectorCreator(import_reselect.weakMapMemoize);
+
+// src/configureStore.ts
+var import_redux4 = require("redux");
+
+// src/devtoolsExtension.ts
+var import_redux = require("redux");
+var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
+  if (arguments.length === 0) return void 0;
+  if (typeof arguments[0] === "object") return import_redux.compose;
+  return import_redux.compose.apply(null, arguments);
+};
+var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {
+  return function(noop3) {
+    return noop3;
+  };
+};
+
+// src/getDefaultMiddleware.ts
+var import_redux_thunk = require("redux-thunk");
+
+// src/createAction.ts
+var import_redux2 = require("redux");
+
+// src/tsHelpers.ts
+var hasMatchFunction = (v) => {
+  return v && typeof v.match === "function";
+};
+
+// src/createAction.ts
+function createAction(type, prepareAction) {
+  function actionCreator(...args) {
+    if (prepareAction) {
+      let prepared = prepareAction(...args);
+      if (!prepared) {
+        throw new Error(false ? _formatProdErrorMessage(0) : "prepareAction did not return an object");
+      }
+      return {
+        type,
+        payload: prepared.payload,
+        ..."meta" in prepared && {
+          meta: prepared.meta
+        },
+        ..."error" in prepared && {
+          error: prepared.error
+        }
+      };
+    }
+    return {
+      type,
+      payload: args[0]
+    };
+  }
+  actionCreator.toString = () => `${type}`;
+  actionCreator.type = type;
+  actionCreator.match = (action) => (0, import_redux2.isAction)(action) && action.type === type;
+  return actionCreator;
+}
+function isActionCreator(action) {
+  return typeof action === "function" && "type" in action && // hasMatchFunction only wants Matchers but I don't see the point in rewriting it
+  hasMatchFunction(action);
+}
+function isFSA(action) {
+  return (0, import_redux2.isAction)(action) && Object.keys(action).every(isValidKey);
+}
+function isValidKey(key) {
+  return ["type", "payload", "error", "meta"].indexOf(key) > -1;
+}
+
+// src/actionCreatorInvariantMiddleware.ts
+function getMessage(type) {
+  const splitType = type ? `${type}`.split("/") : [];
+  const actionName = splitType[splitType.length - 1] || "actionCreator";
+  return `Detected an action creator with type "${type || "unknown"}" being dispatched. 
+Make sure you're calling the action creator before dispatching, i.e. \`dispatch(${actionName}())\` instead of \`dispatch(${actionName})\`. This is necessary even if the action has no payload.`;
+}
+function createActionCreatorInvariantMiddleware(options = {}) {
+  if (false) {
+    return () => (next) => (action) => next(action);
+  }
+  const {
+    isActionCreator: isActionCreator2 = isActionCreator
+  } = options;
+  return () => (next) => (action) => {
+    if (isActionCreator2(action)) {
+      console.warn(getMessage(action.type));
+    }
+    return next(action);
+  };
+}
+
+// src/utils.ts
+var import_immer2 = require("immer");
+function getTimeMeasureUtils(maxDelay, fnName) {
+  let elapsed = 0;
+  return {
+    measureTime(fn) {
+      const started = Date.now();
+      try {
+        return fn();
+      } finally {
+        const finished = Date.now();
+        elapsed += finished - started;
+      }
+    },
+    warnIfExceeded() {
+      if (elapsed > maxDelay) {
+        console.warn(`${fnName} took ${elapsed}ms, which is more than the warning threshold of ${maxDelay}ms. 
+If your state or actions are very large, you may want to disable the middleware as it might cause too much of a slowdown in development mode. See https://redux-toolkit.js.org/api/getDefaultMiddleware for instructions.
+It is disabled in production builds, so you don't need to worry about that.`);
+      }
+    }
+  };
+}
+var Tuple = class _Tuple extends Array {
+  constructor(...items) {
+    super(...items);
+    Object.setPrototypeOf(this, _Tuple.prototype);
+  }
+  static get [Symbol.species]() {
+    return _Tuple;
+  }
+  concat(...arr) {
+    return super.concat.apply(this, arr);
+  }
+  prepend(...arr) {
+    if (arr.length === 1 && Array.isArray(arr[0])) {
+      return new _Tuple(...arr[0].concat(this));
+    }
+    return new _Tuple(...arr.concat(this));
+  }
+};
+function freezeDraftable(val) {
+  return (0, import_immer2.isDraftable)(val) ? (0, import_immer2.produce)(val, () => {
+  }) : val;
+}
+function getOrInsertComputed(map, key, compute) {
+  if (map.has(key)) return map.get(key);
+  return map.set(key, compute(key)).get(key);
+}
+
+// src/immutableStateInvariantMiddleware.ts
+function isImmutableDefault(value) {
+  return typeof value !== "object" || value == null || Object.isFrozen(value);
+}
+function trackForMutations(isImmutable, ignorePaths, obj) {
+  const trackedProperties = trackProperties(isImmutable, ignorePaths, obj);
+  return {
+    detectMutations() {
+      return detectMutations(isImmutable, ignorePaths, trackedProperties, obj);
+    }
+  };
+}
+function trackProperties(isImmutable, ignorePaths = [], obj, path = "", checkedObjects = /* @__PURE__ */ new Set()) {
+  const tracked = {
+    value: obj
+  };
+  if (!isImmutable(obj) && !checkedObjects.has(obj)) {
+    checkedObjects.add(obj);
+    tracked.children = {};
+    for (const key in obj) {
+      const childPath = path ? path + "." + key : key;
+      if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) {
+        continue;
+      }
+      tracked.children[key] = trackProperties(isImmutable, ignorePaths, obj[key], childPath);
+    }
+  }
+  return tracked;
+}
+function detectMutations(isImmutable, ignoredPaths = [], trackedProperty, obj, sameParentRef = false, path = "") {
+  const prevObj = trackedProperty ? trackedProperty.value : void 0;
+  const sameRef = prevObj === obj;
+  if (sameParentRef && !sameRef && !Number.isNaN(obj)) {
+    return {
+      wasMutated: true,
+      path
+    };
+  }
+  if (isImmutable(prevObj) || isImmutable(obj)) {
+    return {
+      wasMutated: false
+    };
+  }
+  const keysToDetect = {};
+  for (let key in trackedProperty.children) {
+    keysToDetect[key] = true;
+  }
+  for (let key in obj) {
+    keysToDetect[key] = true;
+  }
+  const hasIgnoredPaths = ignoredPaths.length > 0;
+  for (let key in keysToDetect) {
+    const nestedPath = path ? path + "." + key : key;
+    if (hasIgnoredPaths) {
+      const hasMatches = ignoredPaths.some((ignored) => {
+        if (ignored instanceof RegExp) {
+          return ignored.test(nestedPath);
+        }
+        return nestedPath === ignored;
+      });
+      if (hasMatches) {
+        continue;
+      }
+    }
+    const result = detectMutations(isImmutable, ignoredPaths, trackedProperty.children[key], obj[key], sameRef, nestedPath);
+    if (result.wasMutated) {
+      return result;
+    }
+  }
+  return {
+    wasMutated: false
+  };
+}
+function createImmutableStateInvariantMiddleware(options = {}) {
+  if (false) {
+    return () => (next) => (action) => next(action);
+  } else {
+    let stringify2 = function(obj, serializer, indent, decycler) {
+      return JSON.stringify(obj, getSerialize2(serializer, decycler), indent);
+    }, getSerialize2 = function(serializer, decycler) {
+      let stack = [], keys = [];
+      if (!decycler) decycler = function(_, value) {
+        if (stack[0] === value) return "[Circular ~]";
+        return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+      };
+      return function(key, value) {
+        if (stack.length > 0) {
+          var thisPos = stack.indexOf(this);
+          ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+          ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+          if (~stack.indexOf(value)) value = decycler.call(this, key, value);
+        } else stack.push(value);
+        return serializer == null ? value : serializer.call(this, key, value);
+      };
+    };
+    var stringify = stringify2, getSerialize = getSerialize2;
+    let {
+      isImmutable = isImmutableDefault,
+      ignoredPaths,
+      warnAfter = 32
+    } = options;
+    const track = trackForMutations.bind(null, isImmutable, ignoredPaths);
+    return ({
+      getState
+    }) => {
+      let state = getState();
+      let tracker = track(state);
+      let result;
+      return (next) => (action) => {
+        const measureUtils = getTimeMeasureUtils(warnAfter, "ImmutableStateInvariantMiddleware");
+        measureUtils.measureTime(() => {
+          state = getState();
+          result = tracker.detectMutations();
+          tracker = track(state);
+          if (result.wasMutated) {
+            throw new Error(false ? _formatProdErrorMessage(19) : `A state mutation was detected between dispatches, in the path '${result.path || ""}'.  This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);
+          }
+        });
+        const dispatchedAction = next(action);
+        measureUtils.measureTime(() => {
+          state = getState();
+          result = tracker.detectMutations();
+          tracker = track(state);
+          if (result.wasMutated) {
+            throw new Error(false ? _formatProdErrorMessage2(20) : `A state mutation was detected inside a dispatch, in the path: ${result.path || ""}. Take a look at the reducer(s) handling the action ${stringify2(action)}. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);
+          }
+        });
+        measureUtils.warnIfExceeded();
+        return dispatchedAction;
+      };
+    };
+  }
+}
+
+// src/serializableStateInvariantMiddleware.ts
+var import_redux3 = require("redux");
+function isPlain(val) {
+  const type = typeof val;
+  return val == null || type === "string" || type === "boolean" || type === "number" || Array.isArray(val) || (0, import_redux3.isPlainObject)(val);
+}
+function findNonSerializableValue(value, path = "", isSerializable = isPlain, getEntries, ignoredPaths = [], cache) {
+  let foundNestedSerializable;
+  if (!isSerializable(value)) {
+    return {
+      keyPath: path || "<root>",
+      value
+    };
+  }
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (cache?.has(value)) return false;
+  const entries = getEntries != null ? getEntries(value) : Object.entries(value);
+  const hasIgnoredPaths = ignoredPaths.length > 0;
+  for (const [key, nestedValue] of entries) {
+    const nestedPath = path ? path + "." + key : key;
+    if (hasIgnoredPaths) {
+      const hasMatches = ignoredPaths.some((ignored) => {
+        if (ignored instanceof RegExp) {
+          return ignored.test(nestedPath);
+        }
+        return nestedPath === ignored;
+      });
+      if (hasMatches) {
+        continue;
+      }
+    }
+    if (!isSerializable(nestedValue)) {
+      return {
+        keyPath: nestedPath,
+        value: nestedValue
+      };
+    }
+    if (typeof nestedValue === "object") {
+      foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries, ignoredPaths, cache);
+      if (foundNestedSerializable) {
+        return foundNestedSerializable;
+      }
+    }
+  }
+  if (cache && isNestedFrozen(value)) cache.add(value);
+  return false;
+}
+function isNestedFrozen(value) {
+  if (!Object.isFrozen(value)) return false;
+  for (const nestedValue of Object.values(value)) {
+    if (typeof nestedValue !== "object" || nestedValue === null) continue;
+    if (!isNestedFrozen(nestedValue)) return false;
+  }
+  return true;
+}
+function createSerializableStateInvariantMiddleware(options = {}) {
+  if (false) {
+    return () => (next) => (action) => next(action);
+  } else {
+    const {
+      isSerializable = isPlain,
+      getEntries,
+      ignoredActions = [],
+      ignoredActionPaths = ["meta.arg", "meta.baseQueryMeta"],
+      ignoredPaths = [],
+      warnAfter = 32,
+      ignoreState = false,
+      ignoreActions = false,
+      disableCache = false
+    } = options;
+    const cache = !disableCache && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0;
+    return (storeAPI) => (next) => (action) => {
+      if (!(0, import_redux3.isAction)(action)) {
+        return next(action);
+      }
+      const result = next(action);
+      const measureUtils = getTimeMeasureUtils(warnAfter, "SerializableStateInvariantMiddleware");
+      if (!ignoreActions && !(ignoredActions.length && ignoredActions.indexOf(action.type) !== -1)) {
+        measureUtils.measureTime(() => {
+          const foundActionNonSerializableValue = findNonSerializableValue(action, "", isSerializable, getEntries, ignoredActionPaths, cache);
+          if (foundActionNonSerializableValue) {
+            const {
+              keyPath,
+              value
+            } = foundActionNonSerializableValue;
+            console.error(`A non-serializable value was detected in an action, in the path: \`${keyPath}\`. Value:`, value, "\nTake a look at the logic that dispatched this action: ", action, "\n(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)", "\n(To allow non-serializable values see: https://redux-toolkit.js.org/usage/usage-guide#working-with-non-serializable-data)");
+          }
+        });
+      }
+      if (!ignoreState) {
+        measureUtils.measureTime(() => {
+          const state = storeAPI.getState();
+          const foundStateNonSerializableValue = findNonSerializableValue(state, "", isSerializable, getEntries, ignoredPaths, cache);
+          if (foundStateNonSerializableValue) {
+            const {
+              keyPath,
+              value
+            } = foundStateNonSerializableValue;
+            console.error(`A non-serializable value was detected in the state, in the path: \`${keyPath}\`. Value:`, value, `
+Take a look at the reducer(s) handling this action type: ${action.type}.
+(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)`);
+          }
+        });
+        measureUtils.warnIfExceeded();
+      }
+      return result;
+    };
+  }
+}
+
+// src/getDefaultMiddleware.ts
+function isBoolean(x) {
+  return typeof x === "boolean";
+}
+var buildGetDefaultMiddleware = () => function getDefaultMiddleware(options) {
+  const {
+    thunk = true,
+    immutableCheck = true,
+    serializableCheck = true,
+    actionCreatorCheck = true
+  } = options ?? {};
+  let middlewareArray = new Tuple();
+  if (thunk) {
+    if (isBoolean(thunk)) {
+      middlewareArray.push(import_redux_thunk.thunk);
+    } else {
+      middlewareArray.push((0, import_redux_thunk.withExtraArgument)(thunk.extraArgument));
+    }
+  }
+  if (true) {
+    if (immutableCheck) {
+      let immutableOptions = {};
+      if (!isBoolean(immutableCheck)) {
+        immutableOptions = immutableCheck;
+      }
+      middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions));
+    }
+    if (serializableCheck) {
+      let serializableOptions = {};
+      if (!isBoolean(serializableCheck)) {
+        serializableOptions = serializableCheck;
+      }
+      middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions));
+    }
+    if (actionCreatorCheck) {
+      let actionCreatorOptions = {};
+      if (!isBoolean(actionCreatorCheck)) {
+        actionCreatorOptions = actionCreatorCheck;
+      }
+      middlewareArray.unshift(createActionCreatorInvariantMiddleware(actionCreatorOptions));
+    }
+  }
+  return middlewareArray;
+};
+
+// src/autoBatchEnhancer.ts
+var SHOULD_AUTOBATCH = "RTK_autoBatch";
+var prepareAutoBatched = () => (payload) => ({
+  payload,
+  meta: {
+    [SHOULD_AUTOBATCH]: true
+  }
+});
+var createQueueWithTimer = (timeout) => {
+  return (notify) => {
+    setTimeout(notify, timeout);
+  };
+};
+var autoBatchEnhancer = (options = {
+  type: "raf"
+}) => (next) => (...args) => {
+  const store = next(...args);
+  let notifying = true;
+  let shouldNotifyAtEndOfTick = false;
+  let notificationQueued = false;
+  const listeners = /* @__PURE__ */ new Set();
+  const queueCallback = options.type === "tick" ? queueMicrotask : options.type === "raf" ? (
+    // requestAnimationFrame won't exist in SSR environments. Fall back to a vague approximation just to keep from erroring.
+    typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10)
+  ) : options.type === "callback" ? options.queueNotification : createQueueWithTimer(options.timeout);
+  const notifyListeners = () => {
+    notificationQueued = false;
+    if (shouldNotifyAtEndOfTick) {
+      shouldNotifyAtEndOfTick = false;
+      listeners.forEach((l) => l());
+    }
+  };
+  return Object.assign({}, store, {
+    // Override the base `store.subscribe` method to keep original listeners
+    // from running if we're delaying notifications
+    subscribe(listener2) {
+      const wrappedListener = () => notifying && listener2();
+      const unsubscribe = store.subscribe(wrappedListener);
+      listeners.add(listener2);
+      return () => {
+        unsubscribe();
+        listeners.delete(listener2);
+      };
+    },
+    // Override the base `store.dispatch` method so that we can check actions
+    // for the `shouldAutoBatch` flag and determine if batching is active
+    dispatch(action) {
+      try {
+        notifying = !action?.meta?.[SHOULD_AUTOBATCH];
+        shouldNotifyAtEndOfTick = !notifying;
+        if (shouldNotifyAtEndOfTick) {
+          if (!notificationQueued) {
+            notificationQueued = true;
+            queueCallback(notifyListeners);
+          }
+        }
+        return store.dispatch(action);
+      } finally {
+        notifying = true;
+      }
+    }
+  });
+};
+
+// src/getDefaultEnhancers.ts
+var buildGetDefaultEnhancers = (middlewareEnhancer) => function getDefaultEnhancers(options) {
+  const {
+    autoBatch = true
+  } = options ?? {};
+  let enhancerArray = new Tuple(middlewareEnhancer);
+  if (autoBatch) {
+    enhancerArray.push(autoBatchEnhancer(typeof autoBatch === "object" ? autoBatch : void 0));
+  }
+  return enhancerArray;
+};
+
+// src/configureStore.ts
+function configureStore(options) {
+  const getDefaultMiddleware = buildGetDefaultMiddleware();
+  const {
+    reducer = void 0,
+    middleware,
+    devTools = true,
+    duplicateMiddlewareCheck = true,
+    preloadedState = void 0,
+    enhancers = void 0
+  } = options || {};
+  let rootReducer;
+  if (typeof reducer === "function") {
+    rootReducer = reducer;
+  } else if ((0, import_redux4.isPlainObject)(reducer)) {
+    rootReducer = (0, import_redux4.combineReducers)(reducer);
+  } else {
+    throw new Error(false ? _formatProdErrorMessage(1) : "`reducer` is a required argument, and must be a function or an object of functions that can be passed to combineReducers");
+  }
+  if (middleware && typeof middleware !== "function") {
+    throw new Error(false ? _formatProdErrorMessage2(2) : "`middleware` field must be a callback");
+  }
+  let finalMiddleware;
+  if (typeof middleware === "function") {
+    finalMiddleware = middleware(getDefaultMiddleware);
+    if (!Array.isArray(finalMiddleware)) {
+      throw new Error(false ? _formatProdErrorMessage3(3) : "when using a middleware builder function, an array of middleware must be returned");
+    }
+  } else {
+    finalMiddleware = getDefaultMiddleware();
+  }
+  if (finalMiddleware.some((item) => typeof item !== "function")) {
+    throw new Error(false ? _formatProdErrorMessage4(4) : "each middleware provided to configureStore must be a function");
+  }
+  if (duplicateMiddlewareCheck) {
+    let middlewareReferences = /* @__PURE__ */ new Set();
+    finalMiddleware.forEach((middleware2) => {
+      if (middlewareReferences.has(middleware2)) {
+        throw new Error(false ? _formatProdErrorMessage5(42) : "Duplicate middleware references found when creating the store. Ensure that each middleware is only included once.");
+      }
+      middlewareReferences.add(middleware2);
+    });
+  }
+  let finalCompose = import_redux4.compose;
+  if (devTools) {
+    finalCompose = composeWithDevTools({
+      // Enable capture of stack traces for dispatched Redux actions
+      trace: true,
+      ...typeof devTools === "object" && devTools
+    });
+  }
+  const middlewareEnhancer = (0, import_redux4.applyMiddleware)(...finalMiddleware);
+  const getDefaultEnhancers = buildGetDefaultEnhancers(middlewareEnhancer);
+  if (enhancers && typeof enhancers !== "function") {
+    throw new Error(false ? _formatProdErrorMessage6(5) : "`enhancers` field must be a callback");
+  }
+  let storeEnhancers = typeof enhancers === "function" ? enhancers(getDefaultEnhancers) : getDefaultEnhancers();
+  if (!Array.isArray(storeEnhancers)) {
+    throw new Error(false ? _formatProdErrorMessage7(6) : "`enhancers` callback must return an array");
+  }
+  if (storeEnhancers.some((item) => typeof item !== "function")) {
+    throw new Error(false ? _formatProdErrorMessage8(7) : "each enhancer provided to configureStore must be a function");
+  }
+  if (finalMiddleware.length && !storeEnhancers.includes(middlewareEnhancer)) {
+    console.error("middlewares were provided, but middleware enhancer was not included in final enhancers - make sure to call `getDefaultEnhancers`");
+  }
+  const composedEnhancer = finalCompose(...storeEnhancers);
+  return (0, import_redux4.createStore)(rootReducer, preloadedState, composedEnhancer);
+}
+
+// src/createReducer.ts
+var import_immer3 = require("immer");
+
+// src/mapBuilders.ts
+function executeReducerBuilderCallback(builderCallback) {
+  const actionsMap = {};
+  const actionMatchers = [];
+  let defaultCaseReducer;
+  const builder = {
+    addCase(typeOrActionCreator, reducer) {
+      if (true) {
+        if (actionMatchers.length > 0) {
+          throw new Error(false ? _formatProdErrorMessage(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        }
+        if (defaultCaseReducer) {
+          throw new Error(false ? _formatProdErrorMessage2(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
+      if (!type) {
+        throw new Error(false ? _formatProdErrorMessage3(28) : "`builder.addCase` cannot be called with an empty action type");
+      }
+      if (type in actionsMap) {
+        throw new Error(false ? _formatProdErrorMessage4(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
+      }
+      actionsMap[type] = reducer;
+      return builder;
+    },
+    addMatcher(matcher, reducer) {
+      if (true) {
+        if (defaultCaseReducer) {
+          throw new Error(false ? _formatProdErrorMessage5(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      actionMatchers.push({
+        matcher,
+        reducer
+      });
+      return builder;
+    },
+    addDefaultCase(reducer) {
+      if (true) {
+        if (defaultCaseReducer) {
+          throw new Error(false ? _formatProdErrorMessage6(31) : "`builder.addDefaultCase` can only be called once");
+        }
+      }
+      defaultCaseReducer = reducer;
+      return builder;
+    }
+  };
+  builderCallback(builder);
+  return [actionsMap, actionMatchers, defaultCaseReducer];
+}
+
+// src/createReducer.ts
+function isStateFunction(x) {
+  return typeof x === "function";
+}
+function createReducer(initialState, mapOrBuilderCallback) {
+  if (true) {
+    if (typeof mapOrBuilderCallback === "object") {
+      throw new Error(false ? _formatProdErrorMessage(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
+    }
+  }
+  let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
+  let getInitialState;
+  if (isStateFunction(initialState)) {
+    getInitialState = () => freezeDraftable(initialState());
+  } else {
+    const frozenInitialState = freezeDraftable(initialState);
+    getInitialState = () => frozenInitialState;
+  }
+  function reducer(state = getInitialState(), action) {
+    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
+      matcher
+    }) => matcher(action)).map(({
+      reducer: reducer2
+    }) => reducer2)];
+    if (caseReducers.filter((cr) => !!cr).length === 0) {
+      caseReducers = [finalDefaultCaseReducer];
+    }
+    return caseReducers.reduce((previousState, caseReducer) => {
+      if (caseReducer) {
+        if ((0, import_immer3.isDraft)(previousState)) {
+          const draft = previousState;
+          const result = caseReducer(draft, action);
+          if (result === void 0) {
+            return previousState;
+          }
+          return result;
+        } else if (!(0, import_immer3.isDraftable)(previousState)) {
+          const result = caseReducer(previousState, action);
+          if (result === void 0) {
+            if (previousState === null) {
+              return previousState;
+            }
+            throw Error("A case reducer on a non-draftable value must not return undefined");
+          }
+          return result;
+        } else {
+          return (0, import_immer3.produce)(previousState, (draft) => {
+            return caseReducer(draft, action);
+          });
+        }
+      }
+      return previousState;
+    }, state);
+  }
+  reducer.getInitialState = getInitialState;
+  return reducer;
+}
+
+// src/matchers.ts
+var matches = (matcher, action) => {
+  if (hasMatchFunction(matcher)) {
+    return matcher.match(action);
+  } else {
+    return matcher(action);
+  }
+};
+function isAnyOf(...matchers) {
+  return (action) => {
+    return matchers.some((matcher) => matches(matcher, action));
+  };
+}
+function isAllOf(...matchers) {
+  return (action) => {
+    return matchers.every((matcher) => matches(matcher, action));
+  };
+}
+function hasExpectedRequestMetadata(action, validStatus) {
+  if (!action || !action.meta) return false;
+  const hasValidRequestId = typeof action.meta.requestId === "string";
+  const hasValidRequestStatus = validStatus.indexOf(action.meta.requestStatus) > -1;
+  return hasValidRequestId && hasValidRequestStatus;
+}
+function isAsyncThunkArray(a) {
+  return typeof a[0] === "function" && "pending" in a[0] && "fulfilled" in a[0] && "rejected" in a[0];
+}
+function isPending(...asyncThunks) {
+  if (asyncThunks.length === 0) {
+    return (action) => hasExpectedRequestMetadata(action, ["pending"]);
+  }
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isPending()(asyncThunks[0]);
+  }
+  return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.pending));
+}
+function isRejected(...asyncThunks) {
+  if (asyncThunks.length === 0) {
+    return (action) => hasExpectedRequestMetadata(action, ["rejected"]);
+  }
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isRejected()(asyncThunks[0]);
+  }
+  return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.rejected));
+}
+function isRejectedWithValue(...asyncThunks) {
+  const hasFlag = (action) => {
+    return action && action.meta && action.meta.rejectedWithValue;
+  };
+  if (asyncThunks.length === 0) {
+    return isAllOf(isRejected(...asyncThunks), hasFlag);
+  }
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isRejectedWithValue()(asyncThunks[0]);
+  }
+  return isAllOf(isRejected(...asyncThunks), hasFlag);
+}
+function isFulfilled(...asyncThunks) {
+  if (asyncThunks.length === 0) {
+    return (action) => hasExpectedRequestMetadata(action, ["fulfilled"]);
+  }
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isFulfilled()(asyncThunks[0]);
+  }
+  return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.fulfilled));
+}
+function isAsyncThunkAction(...asyncThunks) {
+  if (asyncThunks.length === 0) {
+    return (action) => hasExpectedRequestMetadata(action, ["pending", "fulfilled", "rejected"]);
+  }
+  if (!isAsyncThunkArray(asyncThunks)) {
+    return isAsyncThunkAction()(asyncThunks[0]);
+  }
+  return isAnyOf(...asyncThunks.flatMap((asyncThunk) => [asyncThunk.pending, asyncThunk.rejected, asyncThunk.fulfilled]));
+}
+
+// src/nanoid.ts
+var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
+var nanoid = (size = 21) => {
+  let id = "";
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[Math.random() * 64 | 0];
+  }
+  return id;
+};
+
+// src/createAsyncThunk.ts
+var commonProperties = ["name", "message", "stack", "code"];
+var RejectWithValue = class {
+  constructor(payload, meta) {
+    this.payload = payload;
+    this.meta = meta;
+  }
+  /*
+  type-only property to distinguish between RejectWithValue and FulfillWithMeta
+  does not exist at runtime
+  */
+  _type;
+};
+var FulfillWithMeta = class {
+  constructor(payload, meta) {
+    this.payload = payload;
+    this.meta = meta;
+  }
+  /*
+  type-only property to distinguish between RejectWithValue and FulfillWithMeta
+  does not exist at runtime
+  */
+  _type;
+};
+var miniSerializeError = (value) => {
+  if (typeof value === "object" && value !== null) {
+    const simpleError = {};
+    for (const property of commonProperties) {
+      if (typeof value[property] === "string") {
+        simpleError[property] = value[property];
+      }
+    }
+    return simpleError;
+  }
+  return {
+    message: String(value)
+  };
+};
+var externalAbortMessage = "External signal was aborted";
+var createAsyncThunk = /* @__PURE__ */ (() => {
+  function createAsyncThunk2(typePrefix, payloadCreator, options) {
+    const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
+      payload,
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        requestStatus: "fulfilled"
+      }
+    }));
+    const pending = createAction(typePrefix + "/pending", (requestId, arg, meta) => ({
+      payload: void 0,
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        requestStatus: "pending"
+      }
+    }));
+    const rejected = createAction(typePrefix + "/rejected", (error, requestId, arg, payload, meta) => ({
+      payload,
+      error: (options && options.serializeError || miniSerializeError)(error || "Rejected"),
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        rejectedWithValue: !!payload,
+        requestStatus: "rejected",
+        aborted: error?.name === "AbortError",
+        condition: error?.name === "ConditionError"
+      }
+    }));
+    function actionCreator(arg, {
+      signal
+    } = {}) {
+      return (dispatch, getState, extra) => {
+        const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
+        const abortController = new AbortController();
+        let abortHandler;
+        let abortReason;
+        function abort(reason) {
+          abortReason = reason;
+          abortController.abort();
+        }
+        if (signal) {
+          if (signal.aborted) {
+            abort(externalAbortMessage);
+          } else {
+            signal.addEventListener("abort", () => abort(externalAbortMessage), {
+              once: true
+            });
+          }
+        }
+        const promise = async function() {
+          let finalAction;
+          try {
+            let conditionResult = options?.condition?.(arg, {
+              getState,
+              extra
+            });
+            if (isThenable(conditionResult)) {
+              conditionResult = await conditionResult;
+            }
+            if (conditionResult === false || abortController.signal.aborted) {
+              throw {
+                name: "ConditionError",
+                message: "Aborted due to condition callback returning false."
+              };
+            }
+            const abortedPromise = new Promise((_, reject) => {
+              abortHandler = () => {
+                reject({
+                  name: "AbortError",
+                  message: abortReason || "Aborted"
+                });
+              };
+              abortController.signal.addEventListener("abort", abortHandler);
+            });
+            dispatch(pending(requestId, arg, options?.getPendingMeta?.({
+              requestId,
+              arg
+            }, {
+              getState,
+              extra
+            })));
+            finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {
+              dispatch,
+              getState,
+              extra,
+              requestId,
+              signal: abortController.signal,
+              abort,
+              rejectWithValue: (value, meta) => {
+                return new RejectWithValue(value, meta);
+              },
+              fulfillWithValue: (value, meta) => {
+                return new FulfillWithMeta(value, meta);
+              }
+            })).then((result) => {
+              if (result instanceof RejectWithValue) {
+                throw result;
+              }
+              if (result instanceof FulfillWithMeta) {
+                return fulfilled(result.payload, requestId, arg, result.meta);
+              }
+              return fulfilled(result, requestId, arg);
+            })]);
+          } catch (err) {
+            finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
+          } finally {
+            if (abortHandler) {
+              abortController.signal.removeEventListener("abort", abortHandler);
+            }
+          }
+          const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
+          if (!skipDispatch) {
+            dispatch(finalAction);
+          }
+          return finalAction;
+        }();
+        return Object.assign(promise, {
+          abort,
+          requestId,
+          arg,
+          unwrap() {
+            return promise.then(unwrapResult);
+          }
+        });
+      };
+    }
+    return Object.assign(actionCreator, {
+      pending,
+      rejected,
+      fulfilled,
+      settled: isAnyOf(rejected, fulfilled),
+      typePrefix
+    });
+  }
+  createAsyncThunk2.withTypes = () => createAsyncThunk2;
+  return createAsyncThunk2;
+})();
+function unwrapResult(action) {
+  if (action.meta && action.meta.rejectedWithValue) {
+    throw action.payload;
+  }
+  if (action.error) {
+    throw action.error;
+  }
+  return action.payload;
+}
+function isThenable(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+
+// src/createSlice.ts
+var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+var asyncThunkCreator = {
+  [asyncThunkSymbol]: createAsyncThunk
+};
+var ReducerType = /* @__PURE__ */ ((ReducerType2) => {
+  ReducerType2["reducer"] = "reducer";
+  ReducerType2["reducerWithPrepare"] = "reducerWithPrepare";
+  ReducerType2["asyncThunk"] = "asyncThunk";
+  return ReducerType2;
+})(ReducerType || {});
+function getType(slice, actionKey) {
+  return `${slice}/${actionKey}`;
+}
+function buildCreateSlice({
+  creators
+} = {}) {
+  const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
+  return function createSlice2(options) {
+    const {
+      name,
+      reducerPath = name
+    } = options;
+    if (!name) {
+      throw new Error(false ? _formatProdErrorMessage(11) : "`name` is a required option for createSlice");
+    }
+    if (typeof process !== "undefined" && true) {
+      if (options.initialState === void 0) {
+        console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+      }
+    }
+    const reducers = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
+    const reducerNames = Object.keys(reducers);
+    const context = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    };
+    const contextMethods = {
+      addCase(typeOrActionCreator, reducer2) {
+        const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
+        if (!type) {
+          throw new Error(false ? _formatProdErrorMessage2(12) : "`context.addCase` cannot be called with an empty action type");
+        }
+        if (type in context.sliceCaseReducersByType) {
+          throw new Error(false ? _formatProdErrorMessage3(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
+        }
+        context.sliceCaseReducersByType[type] = reducer2;
+        return contextMethods;
+      },
+      addMatcher(matcher, reducer2) {
+        context.sliceMatchers.push({
+          matcher,
+          reducer: reducer2
+        });
+        return contextMethods;
+      },
+      exposeAction(name2, actionCreator) {
+        context.actionCreators[name2] = actionCreator;
+        return contextMethods;
+      },
+      exposeCaseReducer(name2, reducer2) {
+        context.sliceCaseReducersByName[name2] = reducer2;
+        return contextMethods;
+      }
+    };
+    reducerNames.forEach((reducerName) => {
+      const reducerDefinition = reducers[reducerName];
+      const reducerDetails = {
+        reducerName,
+        type: getType(name, reducerName),
+        createNotation: typeof options.reducers === "function"
+      };
+      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
+        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
+      } else {
+        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
+      }
+    });
+    function buildReducer() {
+      if (true) {
+        if (typeof options.extraReducers === "object") {
+          throw new Error(false ? _formatProdErrorMessage4(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
+        }
+      }
+      const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
+      const finalCaseReducers = {
+        ...extraReducers,
+        ...context.sliceCaseReducersByType
+      };
+      return createReducer(options.initialState, (builder) => {
+        for (let key in finalCaseReducers) {
+          builder.addCase(key, finalCaseReducers[key]);
+        }
+        for (let sM of context.sliceMatchers) {
+          builder.addMatcher(sM.matcher, sM.reducer);
+        }
+        for (let m of actionMatchers) {
+          builder.addMatcher(m.matcher, m.reducer);
+        }
+        if (defaultCaseReducer) {
+          builder.addDefaultCase(defaultCaseReducer);
+        }
+      });
+    }
+    const selectSelf = (state) => state;
+    const injectedSelectorCache = /* @__PURE__ */ new Map();
+    const injectedStateCache = /* @__PURE__ */ new WeakMap();
+    let _reducer;
+    function reducer(state, action) {
+      if (!_reducer) _reducer = buildReducer();
+      return _reducer(state, action);
+    }
+    function getInitialState() {
+      if (!_reducer) _reducer = buildReducer();
+      return _reducer.getInitialState();
+    }
+    function makeSelectorProps(reducerPath2, injected = false) {
+      function selectSlice(state) {
+        let sliceState = state[reducerPath2];
+        if (typeof sliceState === "undefined") {
+          if (injected) {
+            sliceState = getOrInsertComputed(injectedStateCache, selectSlice, getInitialState);
+          } else if (true) {
+            throw new Error(false ? _formatProdErrorMessage5(15) : "selectSlice returned undefined for an uninjected slice reducer");
+          }
+        }
+        return sliceState;
+      }
+      function getSelectors(selectState = selectSelf) {
+        const selectorCache = getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap());
+        return getOrInsertComputed(selectorCache, selectState, () => {
+          const map = {};
+          for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
+            map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
+          }
+          return map;
+        });
+      }
+      return {
+        reducerPath: reducerPath2,
+        getSelectors,
+        get selectors() {
+          return getSelectors(selectSlice);
+        },
+        selectSlice
+      };
+    }
+    const slice = {
+      name,
+      reducer,
+      actions: context.actionCreators,
+      caseReducers: context.sliceCaseReducersByName,
+      getInitialState,
+      ...makeSelectorProps(reducerPath),
+      injectInto(injectable, {
+        reducerPath: pathOpt,
+        ...config
+      } = {}) {
+        const newReducerPath = pathOpt ?? reducerPath;
+        injectable.inject({
+          reducerPath: newReducerPath,
+          reducer
+        }, config);
+        return {
+          ...slice,
+          ...makeSelectorProps(newReducerPath, true)
+        };
+      }
+    };
+    return slice;
+  };
+}
+function wrapSelector(selector, selectState, getInitialState, injected) {
+  function wrapper(rootState, ...args) {
+    let sliceState = selectState(rootState);
+    if (typeof sliceState === "undefined") {
+      if (injected) {
+        sliceState = getInitialState();
+      } else if (true) {
+        throw new Error(false ? _formatProdErrorMessage6(16) : "selectState returned undefined for an uninjected slice reducer");
+      }
+    }
+    return selector(sliceState, ...args);
+  }
+  wrapper.unwrapped = selector;
+  return wrapper;
+}
+var createSlice = /* @__PURE__ */ buildCreateSlice();
+function buildReducerCreators() {
+  function asyncThunk(payloadCreator, config) {
+    return {
+      _reducerDefinitionType: "asyncThunk" /* asyncThunk */,
+      payloadCreator,
+      ...config
+    };
+  }
+  asyncThunk.withTypes = () => asyncThunk;
+  return {
+    reducer(caseReducer) {
+      return Object.assign({
+        // hack so the wrapping function has the same name as the original
+        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
+        [caseReducer.name](...args) {
+          return caseReducer(...args);
+        }
+      }[caseReducer.name], {
+        _reducerDefinitionType: "reducer" /* reducer */
+      });
+    },
+    preparedReducer(prepare, reducer) {
+      return {
+        _reducerDefinitionType: "reducerWithPrepare" /* reducerWithPrepare */,
+        prepare,
+        reducer
+      };
+    },
+    asyncThunk
+  };
+}
+function handleNormalReducerDefinition({
+  type,
+  reducerName,
+  createNotation
+}, maybeReducerWithPrepare, context) {
+  let caseReducer;
+  let prepareCallback;
+  if ("reducer" in maybeReducerWithPrepare) {
+    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
+      throw new Error(false ? _formatProdErrorMessage7(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+    }
+    caseReducer = maybeReducerWithPrepare.reducer;
+    prepareCallback = maybeReducerWithPrepare.prepare;
+  } else {
+    caseReducer = maybeReducerWithPrepare;
+  }
+  context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
+}
+function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
+  return reducerDefinition._reducerDefinitionType === "asyncThunk" /* asyncThunk */;
+}
+function isCaseReducerWithPrepareDefinition(reducerDefinition) {
+  return reducerDefinition._reducerDefinitionType === "reducerWithPrepare" /* reducerWithPrepare */;
+}
+function handleThunkCaseReducerDefinition({
+  type,
+  reducerName
+}, reducerDefinition, context, cAT) {
+  if (!cAT) {
+    throw new Error(false ? _formatProdErrorMessage8(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
+  }
+  const {
+    payloadCreator,
+    fulfilled,
+    pending,
+    rejected,
+    settled,
+    options
+  } = reducerDefinition;
+  const thunk = cAT(type, payloadCreator, options);
+  context.exposeAction(reducerName, thunk);
+  if (fulfilled) {
+    context.addCase(thunk.fulfilled, fulfilled);
+  }
+  if (pending) {
+    context.addCase(thunk.pending, pending);
+  }
+  if (rejected) {
+    context.addCase(thunk.rejected, rejected);
+  }
+  if (settled) {
+    context.addMatcher(thunk.settled, settled);
+  }
+  context.exposeCaseReducer(reducerName, {
+    fulfilled: fulfilled || noop,
+    pending: pending || noop,
+    rejected: rejected || noop,
+    settled: settled || noop
+  });
+}
+function noop() {
+}
+
+// src/entities/entity_state.ts
+function getInitialEntityState() {
+  return {
+    ids: [],
+    entities: {}
+  };
+}
+function createInitialStateFactory(stateAdapter) {
+  function getInitialState(additionalState = {}, entities) {
+    const state = Object.assign(getInitialEntityState(), additionalState);
+    return entities ? stateAdapter.setAll(state, entities) : state;
+  }
+  return {
+    getInitialState
+  };
+}
+
+// src/entities/state_selectors.ts
+function createSelectorsFactory() {
+  function getSelectors(selectState, options = {}) {
+    const {
+      createSelector: createSelector2 = createDraftSafeSelector
+    } = options;
+    const selectIds = (state) => state.ids;
+    const selectEntities = (state) => state.entities;
+    const selectAll = createSelector2(selectIds, selectEntities, (ids, entities) => ids.map((id) => entities[id]));
+    const selectId = (_, id) => id;
+    const selectById = (entities, id) => entities[id];
+    const selectTotal = createSelector2(selectIds, (ids) => ids.length);
+    if (!selectState) {
+      return {
+        selectIds,
+        selectEntities,
+        selectAll,
+        selectTotal,
+        selectById: createSelector2(selectEntities, selectId, selectById)
+      };
+    }
+    const selectGlobalizedEntities = createSelector2(selectState, selectEntities);
+    return {
+      selectIds: createSelector2(selectState, selectIds),
+      selectEntities: selectGlobalizedEntities,
+      selectAll: createSelector2(selectState, selectAll),
+      selectTotal: createSelector2(selectState, selectTotal),
+      selectById: createSelector2(selectGlobalizedEntities, selectId, selectById)
+    };
+  }
+  return {
+    getSelectors
+  };
+}
+
+// src/entities/state_adapter.ts
+var import_immer4 = require("immer");
+var isDraftTyped = import_immer4.isDraft;
+function createSingleArgumentStateOperator(mutator) {
+  const operator = createStateOperator((_, state) => mutator(state));
+  return function operation(state) {
+    return operator(state, void 0);
+  };
+}
+function createStateOperator(mutator) {
+  return function operation(state, arg) {
+    function isPayloadActionArgument(arg2) {
+      return isFSA(arg2);
+    }
+    const runMutator = (draft) => {
+      if (isPayloadActionArgument(arg)) {
+        mutator(arg.payload, draft);
+      } else {
+        mutator(arg, draft);
+      }
+    };
+    if (isDraftTyped(state)) {
+      runMutator(state);
+      return state;
+    }
+    return (0, import_immer4.produce)(state, runMutator);
+  };
+}
+
+// src/entities/utils.ts
+var import_immer5 = require("immer");
+function selectIdValue(entity, selectId) {
+  const key = selectId(entity);
+  if (key === void 0) {
+    console.warn("The entity passed to the `selectId` implementation returned undefined.", "You should probably provide your own `selectId` implementation.", "The entity that was passed:", entity, "The `selectId` implementation:", selectId.toString());
+  }
+  return key;
+}
+function ensureEntitiesArray(entities) {
+  if (!Array.isArray(entities)) {
+    entities = Object.values(entities);
+  }
+  return entities;
+}
+function getCurrent(value) {
+  return (0, import_immer5.isDraft)(value) ? (0, import_immer5.current)(value) : value;
+}
+function splitAddedUpdatedEntities(newEntities, selectId, state) {
+  newEntities = ensureEntitiesArray(newEntities);
+  const existingIdsArray = getCurrent(state.ids);
+  const existingIds = new Set(existingIdsArray);
+  const added = [];
+  const addedIds = /* @__PURE__ */ new Set([]);
+  const updated = [];
+  for (const entity of newEntities) {
+    const id = selectIdValue(entity, selectId);
+    if (existingIds.has(id) || addedIds.has(id)) {
+      updated.push({
+        id,
+        changes: entity
+      });
+    } else {
+      addedIds.add(id);
+      added.push(entity);
+    }
+  }
+  return [added, updated, existingIdsArray];
+}
+
+// src/entities/unsorted_state_adapter.ts
+function createUnsortedStateAdapter(selectId) {
+  function addOneMutably(entity, state) {
+    const key = selectIdValue(entity, selectId);
+    if (key in state.entities) {
+      return;
+    }
+    state.ids.push(key);
+    state.entities[key] = entity;
+  }
+  function addManyMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    for (const entity of newEntities) {
+      addOneMutably(entity, state);
+    }
+  }
+  function setOneMutably(entity, state) {
+    const key = selectIdValue(entity, selectId);
+    if (!(key in state.entities)) {
+      state.ids.push(key);
+    }
+    ;
+    state.entities[key] = entity;
+  }
+  function setManyMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    for (const entity of newEntities) {
+      setOneMutably(entity, state);
+    }
+  }
+  function setAllMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    state.ids = [];
+    state.entities = {};
+    addManyMutably(newEntities, state);
+  }
+  function removeOneMutably(key, state) {
+    return removeManyMutably([key], state);
+  }
+  function removeManyMutably(keys, state) {
+    let didMutate = false;
+    keys.forEach((key) => {
+      if (key in state.entities) {
+        delete state.entities[key];
+        didMutate = true;
+      }
+    });
+    if (didMutate) {
+      state.ids = state.ids.filter((id) => id in state.entities);
+    }
+  }
+  function removeAllMutably(state) {
+    Object.assign(state, {
+      ids: [],
+      entities: {}
+    });
+  }
+  function takeNewKey(keys, update, state) {
+    const original3 = state.entities[update.id];
+    if (original3 === void 0) {
+      return false;
+    }
+    const updated = Object.assign({}, original3, update.changes);
+    const newKey = selectIdValue(updated, selectId);
+    const hasNewKey = newKey !== update.id;
+    if (hasNewKey) {
+      keys[update.id] = newKey;
+      delete state.entities[update.id];
+    }
+    ;
+    state.entities[newKey] = updated;
+    return hasNewKey;
+  }
+  function updateOneMutably(update, state) {
+    return updateManyMutably([update], state);
+  }
+  function updateManyMutably(updates, state) {
+    const newKeys = {};
+    const updatesPerEntity = {};
+    updates.forEach((update) => {
+      if (update.id in state.entities) {
+        updatesPerEntity[update.id] = {
+          id: update.id,
+          // Spreads ignore falsy values, so this works even if there isn't
+          // an existing update already at this key
+          changes: {
+            ...updatesPerEntity[update.id]?.changes,
+            ...update.changes
+          }
+        };
+      }
+    });
+    updates = Object.values(updatesPerEntity);
+    const didMutateEntities = updates.length > 0;
+    if (didMutateEntities) {
+      const didMutateIds = updates.filter((update) => takeNewKey(newKeys, update, state)).length > 0;
+      if (didMutateIds) {
+        state.ids = Object.values(state.entities).map((e) => selectIdValue(e, selectId));
+      }
+    }
+  }
+  function upsertOneMutably(entity, state) {
+    return upsertManyMutably([entity], state);
+  }
+  function upsertManyMutably(newEntities, state) {
+    const [added, updated] = splitAddedUpdatedEntities(newEntities, selectId, state);
+    addManyMutably(added, state);
+    updateManyMutably(updated, state);
+  }
+  return {
+    removeAll: createSingleArgumentStateOperator(removeAllMutably),
+    addOne: createStateOperator(addOneMutably),
+    addMany: createStateOperator(addManyMutably),
+    setOne: createStateOperator(setOneMutably),
+    setMany: createStateOperator(setManyMutably),
+    setAll: createStateOperator(setAllMutably),
+    updateOne: createStateOperator(updateOneMutably),
+    updateMany: createStateOperator(updateManyMutably),
+    upsertOne: createStateOperator(upsertOneMutably),
+    upsertMany: createStateOperator(upsertManyMutably),
+    removeOne: createStateOperator(removeOneMutably),
+    removeMany: createStateOperator(removeManyMutably)
+  };
+}
+
+// src/entities/sorted_state_adapter.ts
+function findInsertIndex(sortedItems, item, comparisonFunction) {
+  let lowIndex = 0;
+  let highIndex = sortedItems.length;
+  while (lowIndex < highIndex) {
+    let middleIndex = lowIndex + highIndex >>> 1;
+    const currentItem = sortedItems[middleIndex];
+    const res = comparisonFunction(item, currentItem);
+    if (res >= 0) {
+      lowIndex = middleIndex + 1;
+    } else {
+      highIndex = middleIndex;
+    }
+  }
+  return lowIndex;
+}
+function insert(sortedItems, item, comparisonFunction) {
+  const insertAtIndex = findInsertIndex(sortedItems, item, comparisonFunction);
+  sortedItems.splice(insertAtIndex, 0, item);
+  return sortedItems;
+}
+function createSortedStateAdapter(selectId, comparer) {
+  const {
+    removeOne,
+    removeMany,
+    removeAll
+  } = createUnsortedStateAdapter(selectId);
+  function addOneMutably(entity, state) {
+    return addManyMutably([entity], state);
+  }
+  function addManyMutably(newEntities, state, existingIds) {
+    newEntities = ensureEntitiesArray(newEntities);
+    const existingKeys = new Set(existingIds ?? getCurrent(state.ids));
+    const models = newEntities.filter((model) => !existingKeys.has(selectIdValue(model, selectId)));
+    if (models.length !== 0) {
+      mergeFunction(state, models);
+    }
+  }
+  function setOneMutably(entity, state) {
+    return setManyMutably([entity], state);
+  }
+  function setManyMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    if (newEntities.length !== 0) {
+      for (const item of newEntities) {
+        delete state.entities[selectId(item)];
+      }
+      mergeFunction(state, newEntities);
+    }
+  }
+  function setAllMutably(newEntities, state) {
+    newEntities = ensureEntitiesArray(newEntities);
+    state.entities = {};
+    state.ids = [];
+    addManyMutably(newEntities, state, []);
+  }
+  function updateOneMutably(update, state) {
+    return updateManyMutably([update], state);
+  }
+  function updateManyMutably(updates, state) {
+    let appliedUpdates = false;
+    let replacedIds = false;
+    for (let update of updates) {
+      const entity = state.entities[update.id];
+      if (!entity) {
+        continue;
+      }
+      appliedUpdates = true;
+      Object.assign(entity, update.changes);
+      const newId = selectId(entity);
+      if (update.id !== newId) {
+        replacedIds = true;
+        delete state.entities[update.id];
+        const oldIndex = state.ids.indexOf(update.id);
+        state.ids[oldIndex] = newId;
+        state.entities[newId] = entity;
+      }
+    }
+    if (appliedUpdates) {
+      mergeFunction(state, [], appliedUpdates, replacedIds);
+    }
+  }
+  function upsertOneMutably(entity, state) {
+    return upsertManyMutably([entity], state);
+  }
+  function upsertManyMutably(newEntities, state) {
+    const [added, updated, existingIdsArray] = splitAddedUpdatedEntities(newEntities, selectId, state);
+    if (added.length) {
+      addManyMutably(added, state, existingIdsArray);
+    }
+    if (updated.length) {
+      updateManyMutably(updated, state);
+    }
+  }
+  function areArraysEqual(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] === b[i]) {
+        continue;
+      }
+      return false;
+    }
+    return true;
+  }
+  const mergeFunction = (state, addedItems, appliedUpdates, replacedIds) => {
+    const currentEntities = getCurrent(state.entities);
+    const currentIds = getCurrent(state.ids);
+    const stateEntities = state.entities;
+    let ids = currentIds;
+    if (replacedIds) {
+      ids = new Set(currentIds);
+    }
+    let sortedEntities = [];
+    for (const id of ids) {
+      const entity = currentEntities[id];
+      if (entity) {
+        sortedEntities.push(entity);
+      }
+    }
+    const wasPreviouslyEmpty = sortedEntities.length === 0;
+    for (const item of addedItems) {
+      stateEntities[selectId(item)] = item;
+      if (!wasPreviouslyEmpty) {
+        insert(sortedEntities, item, comparer);
+      }
+    }
+    if (wasPreviouslyEmpty) {
+      sortedEntities = addedItems.slice().sort(comparer);
+    } else if (appliedUpdates) {
+      sortedEntities.sort(comparer);
+    }
+    const newSortedIds = sortedEntities.map(selectId);
+    if (!areArraysEqual(currentIds, newSortedIds)) {
+      state.ids = newSortedIds;
+    }
+  };
+  return {
+    removeOne,
+    removeMany,
+    removeAll,
+    addOne: createStateOperator(addOneMutably),
+    updateOne: createStateOperator(updateOneMutably),
+    upsertOne: createStateOperator(upsertOneMutably),
+    setOne: createStateOperator(setOneMutably),
+    setMany: createStateOperator(setManyMutably),
+    setAll: createStateOperator(setAllMutably),
+    addMany: createStateOperator(addManyMutably),
+    updateMany: createStateOperator(updateManyMutably),
+    upsertMany: createStateOperator(upsertManyMutably)
+  };
+}
+
+// src/entities/create_adapter.ts
+function createEntityAdapter(options = {}) {
+  const {
+    selectId,
+    sortComparer
+  } = {
+    sortComparer: false,
+    selectId: (instance) => instance.id,
+    ...options
+  };
+  const stateAdapter = sortComparer ? createSortedStateAdapter(selectId, sortComparer) : createUnsortedStateAdapter(selectId);
+  const stateFactory = createInitialStateFactory(stateAdapter);
+  const selectorsFactory = createSelectorsFactory();
+  return {
+    selectId,
+    sortComparer,
+    ...stateFactory,
+    ...selectorsFactory,
+    ...stateAdapter
+  };
+}
+
+// src/listenerMiddleware/index.ts
+var import_redux5 = require("redux");
+
+// src/listenerMiddleware/exceptions.ts
+var task = "task";
+var listener = "listener";
+var completed = "completed";
+var cancelled = "cancelled";
+var taskCancelled = `task-${cancelled}`;
+var taskCompleted = `task-${completed}`;
+var listenerCancelled = `${listener}-${cancelled}`;
+var listenerCompleted = `${listener}-${completed}`;
+var TaskAbortError = class {
+  constructor(code) {
+    this.code = code;
+    this.message = `${task} ${cancelled} (reason: ${code})`;
+  }
+  name = "TaskAbortError";
+  message;
+};
+
+// src/listenerMiddleware/utils.ts
+var assertFunction = (func, expected) => {
+  if (typeof func !== "function") {
+    throw new TypeError(false ? _formatProdErrorMessage(32) : `${expected} is not a function`);
+  }
+};
+var noop2 = () => {
+};
+var catchRejection = (promise, onError = noop2) => {
+  promise.catch(onError);
+  return promise;
+};
+var addAbortSignalListener = (abortSignal, callback) => {
+  abortSignal.addEventListener("abort", callback, {
+    once: true
+  });
+  return () => abortSignal.removeEventListener("abort", callback);
+};
+var abortControllerWithReason = (abortController, reason) => {
+  const signal = abortController.signal;
+  if (signal.aborted) {
+    return;
+  }
+  if (!("reason" in signal)) {
+    Object.defineProperty(signal, "reason", {
+      enumerable: true,
+      value: reason,
+      configurable: true,
+      writable: true
+    });
+  }
+  ;
+  abortController.abort(reason);
+};
+
+// src/listenerMiddleware/task.ts
+var validateActive = (signal) => {
+  if (signal.aborted) {
+    const {
+      reason
+    } = signal;
+    throw new TaskAbortError(reason);
+  }
+};
+function raceWithSignal(signal, promise) {
+  let cleanup = noop2;
+  return new Promise((resolve, reject) => {
+    const notifyRejection = () => reject(new TaskAbortError(signal.reason));
+    if (signal.aborted) {
+      notifyRejection();
+      return;
+    }
+    cleanup = addAbortSignalListener(signal, notifyRejection);
+    promise.finally(() => cleanup()).then(resolve, reject);
+  }).finally(() => {
+    cleanup = noop2;
+  });
+}
+var runTask = async (task2, cleanUp) => {
+  try {
+    await Promise.resolve();
+    const value = await task2();
+    return {
+      status: "ok",
+      value
+    };
+  } catch (error) {
+    return {
+      status: error instanceof TaskAbortError ? "cancelled" : "rejected",
+      error
+    };
+  } finally {
+    cleanUp?.();
+  }
+};
+var createPause = (signal) => {
+  return (promise) => {
+    return catchRejection(raceWithSignal(signal, promise).then((output) => {
+      validateActive(signal);
+      return output;
+    }));
+  };
+};
+var createDelay = (signal) => {
+  const pause = createPause(signal);
+  return (timeoutMs) => {
+    return pause(new Promise((resolve) => setTimeout(resolve, timeoutMs)));
+  };
+};
+
+// src/listenerMiddleware/index.ts
+var {
+  assign
+} = Object;
+var INTERNAL_NIL_TOKEN = {};
+var alm = "listenerMiddleware";
+var createFork = (parentAbortSignal, parentBlockingPromises) => {
+  const linkControllers = (controller) => addAbortSignalListener(parentAbortSignal, () => abortControllerWithReason(controller, parentAbortSignal.reason));
+  return (taskExecutor, opts) => {
+    assertFunction(taskExecutor, "taskExecutor");
+    const childAbortController = new AbortController();
+    linkControllers(childAbortController);
+    const result = runTask(async () => {
+      validateActive(parentAbortSignal);
+      validateActive(childAbortController.signal);
+      const result2 = await taskExecutor({
+        pause: createPause(childAbortController.signal),
+        delay: createDelay(childAbortController.signal),
+        signal: childAbortController.signal
+      });
+      validateActive(childAbortController.signal);
+      return result2;
+    }, () => abortControllerWithReason(childAbortController, taskCompleted));
+    if (opts?.autoJoin) {
+      parentBlockingPromises.push(result.catch(noop2));
+    }
+    return {
+      result: createPause(parentAbortSignal)(result),
+      cancel() {
+        abortControllerWithReason(childAbortController, taskCancelled);
+      }
+    };
+  };
+};
+var createTakePattern = (startListening, signal) => {
+  const take = async (predicate, timeout) => {
+    validateActive(signal);
+    let unsubscribe = () => {
+    };
+    const tuplePromise = new Promise((resolve, reject) => {
+      let stopListening = startListening({
+        predicate,
+        effect: (action, listenerApi) => {
+          listenerApi.unsubscribe();
+          resolve([action, listenerApi.getState(), listenerApi.getOriginalState()]);
+        }
+      });
+      unsubscribe = () => {
+        stopListening();
+        reject();
+      };
+    });
+    const promises = [tuplePromise];
+    if (timeout != null) {
+      promises.push(new Promise((resolve) => setTimeout(resolve, timeout, null)));
+    }
+    try {
+      const output = await raceWithSignal(signal, Promise.race(promises));
+      validateActive(signal);
+      return output;
+    } finally {
+      unsubscribe();
+    }
+  };
+  return (predicate, timeout) => catchRejection(take(predicate, timeout));
+};
+var getListenerEntryPropsFrom = (options) => {
+  let {
+    type,
+    actionCreator,
+    matcher,
+    predicate,
+    effect
+  } = options;
+  if (type) {
+    predicate = createAction(type).match;
+  } else if (actionCreator) {
+    type = actionCreator.type;
+    predicate = actionCreator.match;
+  } else if (matcher) {
+    predicate = matcher;
+  } else if (predicate) {
+  } else {
+    throw new Error(false ? _formatProdErrorMessage(21) : "Creating or removing a listener requires one of the known fields for matching an action");
+  }
+  assertFunction(effect, "options.listener");
+  return {
+    predicate,
+    type,
+    effect
+  };
+};
+var createListenerEntry = /* @__PURE__ */ assign((options) => {
+  const {
+    type,
+    predicate,
+    effect
+  } = getListenerEntryPropsFrom(options);
+  const entry = {
+    id: nanoid(),
+    effect,
+    type,
+    predicate,
+    pending: /* @__PURE__ */ new Set(),
+    unsubscribe: () => {
+      throw new Error(false ? _formatProdErrorMessage2(22) : "Unsubscribe not initialized");
+    }
+  };
+  return entry;
+}, {
+  withTypes: () => createListenerEntry
+});
+var findListenerEntry = (listenerMap, options) => {
+  const {
+    type,
+    effect,
+    predicate
+  } = getListenerEntryPropsFrom(options);
+  return Array.from(listenerMap.values()).find((entry) => {
+    const matchPredicateOrType = typeof type === "string" ? entry.type === type : entry.predicate === predicate;
+    return matchPredicateOrType && entry.effect === effect;
+  });
+};
+var cancelActiveListeners = (entry) => {
+  entry.pending.forEach((controller) => {
+    abortControllerWithReason(controller, listenerCancelled);
+  });
+};
+var createClearListenerMiddleware = (listenerMap) => {
+  return () => {
+    listenerMap.forEach(cancelActiveListeners);
+    listenerMap.clear();
+  };
+};
+var safelyNotifyError = (errorHandler, errorToNotify, errorInfo) => {
+  try {
+    errorHandler(errorToNotify, errorInfo);
+  } catch (errorHandlerError) {
+    setTimeout(() => {
+      throw errorHandlerError;
+    }, 0);
+  }
+};
+var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), {
+  withTypes: () => addListener
+});
+var clearAllListeners = /* @__PURE__ */ createAction(`${alm}/removeAll`);
+var removeListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/remove`), {
+  withTypes: () => removeListener
+});
+var defaultErrorHandler = (...args) => {
+  console.error(`${alm}/error`, ...args);
+};
+var createListenerMiddleware = (middlewareOptions = {}) => {
+  const listenerMap = /* @__PURE__ */ new Map();
+  const {
+    extra,
+    onError = defaultErrorHandler
+  } = middlewareOptions;
+  assertFunction(onError, "onError");
+  const insertEntry = (entry) => {
+    entry.unsubscribe = () => listenerMap.delete(entry.id);
+    listenerMap.set(entry.id, entry);
+    return (cancelOptions) => {
+      entry.unsubscribe();
+      if (cancelOptions?.cancelActive) {
+        cancelActiveListeners(entry);
+      }
+    };
+  };
+  const startListening = (options) => {
+    const entry = findListenerEntry(listenerMap, options) ?? createListenerEntry(options);
+    return insertEntry(entry);
+  };
+  assign(startListening, {
+    withTypes: () => startListening
+  });
+  const stopListening = (options) => {
+    const entry = findListenerEntry(listenerMap, options);
+    if (entry) {
+      entry.unsubscribe();
+      if (options.cancelActive) {
+        cancelActiveListeners(entry);
+      }
+    }
+    return !!entry;
+  };
+  assign(stopListening, {
+    withTypes: () => stopListening
+  });
+  const notifyListener = async (entry, action, api, getOriginalState) => {
+    const internalTaskController = new AbortController();
+    const take = createTakePattern(startListening, internalTaskController.signal);
+    const autoJoinPromises = [];
+    try {
+      entry.pending.add(internalTaskController);
+      await Promise.resolve(entry.effect(
+        action,
+        // Use assign() rather than ... to avoid extra helper functions added to bundle
+        assign({}, api, {
+          getOriginalState,
+          condition: (predicate, timeout) => take(predicate, timeout).then(Boolean),
+          take,
+          delay: createDelay(internalTaskController.signal),
+          pause: createPause(internalTaskController.signal),
+          extra,
+          signal: internalTaskController.signal,
+          fork: createFork(internalTaskController.signal, autoJoinPromises),
+          unsubscribe: entry.unsubscribe,
+          subscribe: () => {
+            listenerMap.set(entry.id, entry);
+          },
+          cancelActiveListeners: () => {
+            entry.pending.forEach((controller, _, set) => {
+              if (controller !== internalTaskController) {
+                abortControllerWithReason(controller, listenerCancelled);
+                set.delete(controller);
+              }
+            });
+          },
+          cancel: () => {
+            abortControllerWithReason(internalTaskController, listenerCancelled);
+            entry.pending.delete(internalTaskController);
+          },
+          throwIfCancelled: () => {
+            validateActive(internalTaskController.signal);
+          }
+        })
+      ));
+    } catch (listenerError) {
+      if (!(listenerError instanceof TaskAbortError)) {
+        safelyNotifyError(onError, listenerError, {
+          raisedBy: "effect"
+        });
+      }
+    } finally {
+      await Promise.all(autoJoinPromises);
+      abortControllerWithReason(internalTaskController, listenerCompleted);
+      entry.pending.delete(internalTaskController);
+    }
+  };
+  const clearListenerMiddleware = createClearListenerMiddleware(listenerMap);
+  const middleware = (api) => (next) => (action) => {
+    if (!(0, import_redux5.isAction)(action)) {
+      return next(action);
+    }
+    if (addListener.match(action)) {
+      return startListening(action.payload);
+    }
+    if (clearAllListeners.match(action)) {
+      clearListenerMiddleware();
+      return;
+    }
+    if (removeListener.match(action)) {
+      return stopListening(action.payload);
+    }
+    let originalState = api.getState();
+    const getOriginalState = () => {
+      if (originalState === INTERNAL_NIL_TOKEN) {
+        throw new Error(false ? _formatProdErrorMessage3(23) : `${alm}: getOriginalState can only be called synchronously`);
+      }
+      return originalState;
+    };
+    let result;
+    try {
+      result = next(action);
+      if (listenerMap.size > 0) {
+        const currentState = api.getState();
+        const listenerEntries = Array.from(listenerMap.values());
+        for (const entry of listenerEntries) {
+          let runListener = false;
+          try {
+            runListener = entry.predicate(action, currentState, originalState);
+          } catch (predicateError) {
+            runListener = false;
+            safelyNotifyError(onError, predicateError, {
+              raisedBy: "predicate"
+            });
+          }
+          if (!runListener) {
+            continue;
+          }
+          notifyListener(entry, action, api, getOriginalState);
+        }
+      }
+    } finally {
+      originalState = INTERNAL_NIL_TOKEN;
+    }
+    return result;
+  };
+  return {
+    middleware,
+    startListening,
+    stopListening,
+    clearListeners: clearListenerMiddleware
+  };
+};
+
+// src/dynamicMiddleware/index.ts
+var import_redux6 = require("redux");
+var createMiddlewareEntry = (middleware) => ({
+  middleware,
+  applied: /* @__PURE__ */ new Map()
+});
+var matchInstance = (instanceId) => (action) => action?.meta?.instanceId === instanceId;
+var createDynamicMiddleware = () => {
+  const instanceId = nanoid();
+  const middlewareMap = /* @__PURE__ */ new Map();
+  const withMiddleware = Object.assign(createAction("dynamicMiddleware/add", (...middlewares) => ({
+    payload: middlewares,
+    meta: {
+      instanceId
+    }
+  })), {
+    withTypes: () => withMiddleware
+  });
+  const addMiddleware = Object.assign(function addMiddleware2(...middlewares) {
+    middlewares.forEach((middleware2) => {
+      getOrInsertComputed(middlewareMap, middleware2, createMiddlewareEntry);
+    });
+  }, {
+    withTypes: () => addMiddleware
+  });
+  const getFinalMiddleware = (api) => {
+    const appliedMiddleware = Array.from(middlewareMap.values()).map((entry) => getOrInsertComputed(entry.applied, api, entry.middleware));
+    return (0, import_redux6.compose)(...appliedMiddleware);
+  };
+  const isWithMiddleware = isAllOf(withMiddleware, matchInstance(instanceId));
+  const middleware = (api) => (next) => (action) => {
+    if (isWithMiddleware(action)) {
+      addMiddleware(...action.payload);
+      return api.dispatch;
+    }
+    return getFinalMiddleware(api)(next)(action);
+  };
+  return {
+    middleware,
+    addMiddleware,
+    withMiddleware,
+    instanceId
+  };
+};
+
+// src/combineSlices.ts
+var import_redux7 = require("redux");
+var isSliceLike = (maybeSliceLike) => "reducerPath" in maybeSliceLike && typeof maybeSliceLike.reducerPath === "string";
+var getReducers = (slices) => slices.flatMap((sliceOrMap) => isSliceLike(sliceOrMap) ? [[sliceOrMap.reducerPath, sliceOrMap.reducer]] : Object.entries(sliceOrMap));
+var ORIGINAL_STATE = Symbol.for("rtk-state-proxy-original");
+var isStateProxy = (value) => !!value && !!value[ORIGINAL_STATE];
+var stateProxyMap = /* @__PURE__ */ new WeakMap();
+var createStateProxy = (state, reducerMap, initialStateCache) => getOrInsertComputed(stateProxyMap, state, () => new Proxy(state, {
+  get: (target, prop, receiver) => {
+    if (prop === ORIGINAL_STATE) return target;
+    const result = Reflect.get(target, prop, receiver);
+    if (typeof result === "undefined") {
+      const cached = initialStateCache[prop];
+      if (typeof cached !== "undefined") return cached;
+      const reducer = reducerMap[prop];
+      if (reducer) {
+        const reducerResult = reducer(void 0, {
+          type: nanoid()
+        });
+        if (typeof reducerResult === "undefined") {
+          throw new Error(false ? _formatProdErrorMessage(24) : `The slice reducer for key "${prop.toString()}" returned undefined when called for selector(). If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);
+        }
+        initialStateCache[prop] = reducerResult;
+        return reducerResult;
+      }
+    }
+    return result;
+  }
+}));
+var original = (state) => {
+  if (!isStateProxy(state)) {
+    throw new Error(false ? _formatProdErrorMessage2(25) : "original must be used on state Proxy");
+  }
+  return state[ORIGINAL_STATE];
+};
+var emptyObject = {};
+var noopReducer = (state = emptyObject) => state;
+function combineSlices(...slices) {
+  const reducerMap = Object.fromEntries(getReducers(slices));
+  const getReducer = () => Object.keys(reducerMap).length ? (0, import_redux7.combineReducers)(reducerMap) : noopReducer;
+  let reducer = getReducer();
+  function combinedReducer(state, action) {
+    return reducer(state, action);
+  }
+  combinedReducer.withLazyLoadedSlices = () => combinedReducer;
+  const initialStateCache = {};
+  const inject = (slice, config = {}) => {
+    const {
+      reducerPath,
+      reducer: reducerToInject
+    } = slice;
+    const currentReducer = reducerMap[reducerPath];
+    if (!config.overrideExisting && currentReducer && currentReducer !== reducerToInject) {
+      if (typeof process !== "undefined" && true) {
+        console.error(`called \`inject\` to override already-existing reducer ${reducerPath} without specifying \`overrideExisting: true\``);
+      }
+      return combinedReducer;
+    }
+    if (config.overrideExisting && currentReducer !== reducerToInject) {
+      delete initialStateCache[reducerPath];
+    }
+    reducerMap[reducerPath] = reducerToInject;
+    reducer = getReducer();
+    return combinedReducer;
+  };
+  const selector = Object.assign(function makeSelector(selectorFn, selectState) {
+    return function selector2(state, ...args) {
+      return selectorFn(createStateProxy(selectState ? selectState(state, ...args) : state, reducerMap, initialStateCache), ...args);
+    };
+  }, {
+    original
+  });
+  return Object.assign(combinedReducer, {
+    inject,
+    selector
+  });
+}
+
+// src/formatProdErrorMessage.ts
+function formatProdErrorMessage(code) {
+  return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReducerType,
+  SHOULD_AUTOBATCH,
+  TaskAbortError,
+  Tuple,
+  addListener,
+  asyncThunkCreator,
+  autoBatchEnhancer,
+  buildCreateSlice,
+  clearAllListeners,
+  combineSlices,
+  configureStore,
+  createAction,
+  createActionCreatorInvariantMiddleware,
+  createAsyncThunk,
+  createDraftSafeSelector,
+  createDraftSafeSelectorCreator,
+  createDynamicMiddleware,
+  createEntityAdapter,
+  createImmutableStateInvariantMiddleware,
+  createListenerMiddleware,
+  createNextState,
+  createReducer,
+  createSelector,
+  createSelectorCreator,
+  createSerializableStateInvariantMiddleware,
+  createSlice,
+  current,
+  findNonSerializableValue,
+  formatProdErrorMessage,
+  freeze,
+  isActionCreator,
+  isAllOf,
+  isAnyOf,
+  isAsyncThunkAction,
+  isDraft,
+  isFluxStandardAction,
+  isFulfilled,
+  isImmutableDefault,
+  isPending,
+  isPlain,
+  isRejected,
+  isRejectedWithValue,
+  lruMemoize,
+  miniSerializeError,
+  nanoid,
+  original,
+  prepareAutoBatched,
+  removeListener,
+  unwrapResult,
+  weakMapMemoize,
+  ...require("redux")
+});
+//# sourceMappingURL=redux-toolkit.development.cjs.map

frontend/node_modules/@reduxjs/toolkit/dist/cjs/redux-toolkit.production.min.cjs

@@ -0,0 +1,3 @@
+"use strict";var Pe=Object.defineProperty;var jt=Object.getOwnPropertyDescriptor;var Ft=Object.getOwnPropertyNames;var Vt=Object.prototype.hasOwnProperty;var _t=(e,t)=>{for(var r in t)Pe(e,r,{get:t[r],enumerable:!0})},Me=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Ft(t))!Vt.call(e,o)&&o!==r&&Pe(e,o,{get:()=>t[o],enumerable:!(n=jt(t,o))||n.enumerable});return e},w=(e,t,r)=>(Me(e,t,"default"),r&&Me(r,t,"default"));var Lt=e=>Me(Pe({},"__esModule",{value:!0}),e);var C={};_t(C,{ReducerType:()=>We,SHOULD_AUTOBATCH:()=>ce,TaskAbortError:()=>I,Tuple:()=>F,addListener:()=>Re,asyncThunkCreator:()=>lt,autoBatchEnhancer:()=>de,buildCreateSlice:()=>ze,clearAllListeners:()=>qe,combineSlices:()=>Nt,configureStore:()=>st,createAction:()=>b,createActionCreatorInvariantMiddleware:()=>Qe,createAsyncThunk:()=>ye,createDraftSafeSelector:()=>ne,createDraftSafeSelectorCreator:()=>be,createDynamicMiddleware:()=>Dt,createEntityAdapter:()=>Tt,createImmutableStateInvariantMiddleware:()=>Ze,createListenerMiddleware:()=>It,createNextState:()=>N.produce,createReducer:()=>le,createSelector:()=>W.createSelector,createSelectorCreator:()=>W.createSelectorCreator,createSerializableStateInvariantMiddleware:()=>nt,createSlice:()=>pt,current:()=>N.current,findNonSerializableValue:()=>Ne,formatProdErrorMessage:()=>x,freeze:()=>N.freeze,isActionCreator:()=>oe,isAllOf:()=>B,isAnyOf:()=>V,isAsyncThunkAction:()=>_e,isDraft:()=>N.isDraft,isFluxStandardAction:()=>ae,isFulfilled:()=>Ve,isImmutableDefault:()=>Ye,isPending:()=>je,isPlain:()=>Oe,isRejected:()=>$,isRejectedWithValue:()=>Fe,lruMemoize:()=>W.lruMemoize,miniSerializeError:()=>Le,nanoid:()=>O,original:()=>N.original,prepareAutoBatched:()=>at,removeListener:()=>we,unwrapResult:()=>Ue,weakMapMemoize:()=>W.weakMapMemoize});module.exports=Lt(C);w(C,require("redux"),module.exports);var N=require("immer"),W=require("reselect");var ee=require("immer"),te=require("reselect"),be=(...e)=>{let t=(0,te.createSelectorCreator)(...e),r=Object.assign((...n)=>{let o=t(...n),a=(s,...y)=>o((0,ee.isDraft)(s)?(0,ee.current)(s):s,...y);return Object.assign(a,o),a},{withTypes:()=>r});return r},ne=be(te.weakMapMemoize);var D=require("redux");var Ie=require("redux"),Je=typeof window<"u"&&window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__?window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__:function(){if(arguments.length!==0)return typeof arguments[0]=="object"?Ie.compose:Ie.compose.apply(null,arguments)},xn=typeof window<"u"&&window.__REDUX_DEVTOOLS_EXTENSION__?window.__REDUX_DEVTOOLS_EXTENSION__:function(){return function(e){return e}};var se=require("redux-thunk");var ve=require("redux");var re=e=>e&&typeof e.match=="function";function b(e,t){function r(...n){if(t){let o=t(...n);if(!o)throw new Error(x(0));return{type:e,payload:o.payload,..."meta"in o&&{meta:o.meta},..."error"in o&&{error:o.error}}}return{type:e,payload:n[0]}}return r.toString=()=>`${e}`,r.type=e,r.match=n=>(0,ve.isAction)(n)&&n.type===e,r}function oe(e){return typeof e=="function"&&"type"in e&&re(e)}function ae(e){return(0,ve.isAction)(e)&&Object.keys(e).every(Ut)}function Ut(e){return["type","payload","error","meta"].indexOf(e)>-1}function Wt(e){let t=e?`${e}`.split("/"):[],r=t[t.length-1]||"actionCreator";return`Detected an action creator with type "${e||"unknown"}" being dispatched. 
+Make sure you're calling the action creator before dispatching, i.e. \`dispatch(${r}())\` instead of \`dispatch(${r})\`. This is necessary even if the action has no payload.`}function Qe(e={}){return()=>r=>n=>r(n)}var ie=require("immer");var F=class e extends Array{constructor(...t){super(...t),Object.setPrototypeOf(this,e.prototype)}static get[Symbol.species](){return e}concat(...t){return super.concat.apply(this,t)}prepend(...t){return t.length===1&&Array.isArray(t[0])?new e(...t[0].concat(this)):new e(...t.concat(this))}};function De(e){return(0,ie.isDraftable)(e)?(0,ie.produce)(e,()=>{}):e}function v(e,t,r){return e.has(t)?e.get(t):e.set(t,r(t)).get(t)}function Ye(e){return typeof e!="object"||e==null||Object.isFrozen(e)}function Ze(e={}){if(1)return()=>n=>o=>n(o);var t,r}var et=require("redux");function Oe(e){let t=typeof e;return e==null||t==="string"||t==="boolean"||t==="number"||Array.isArray(e)||(0,et.isPlainObject)(e)}function Ne(e,t="",r=Oe,n,o=[],a){let s;if(!r(e))return{keyPath:t||"<root>",value:e};if(typeof e!="object"||e===null||a?.has(e))return!1;let y=n!=null?n(e):Object.entries(e),c=o.length>0;for(let[l,i]of y){let d=t?t+"."+l:l;if(!(c&&o.some(g=>g instanceof RegExp?g.test(d):d===g))){if(!r(i))return{keyPath:d,value:i};if(typeof i=="object"&&(s=Ne(i,d,r,n,o,a),s))return s}}return a&&tt(e)&&a.add(e),!1}function tt(e){if(!Object.isFrozen(e))return!1;for(let t of Object.values(e))if(!(typeof t!="object"||t===null)&&!tt(t))return!1;return!0}function nt(e={}){return()=>t=>r=>t(r)}function zt(e){return typeof e=="boolean"}var rt=()=>function(t){let{thunk:r=!0,immutableCheck:n=!0,serializableCheck:o=!0,actionCreatorCheck:a=!0}=t??{},s=new F;return r&&(zt(r)?s.push(se.thunk):s.push((0,se.withExtraArgument)(r.extraArgument))),s};var ce="RTK_autoBatch",at=()=>e=>({payload:e,meta:{[ce]:!0}}),ot=e=>t=>{setTimeout(t,e)},de=(e={type:"raf"})=>t=>(...r)=>{let n=t(...r),o=!0,a=!1,s=!1,y=new Set,c=e.type==="tick"?queueMicrotask:e.type==="raf"?typeof window<"u"&&window.requestAnimationFrame?window.requestAnimationFrame:ot(10):e.type==="callback"?e.queueNotification:ot(e.timeout),l=()=>{s=!1,a&&(a=!1,y.forEach(i=>i()))};return Object.assign({},n,{subscribe(i){let d=()=>o&&i(),T=n.subscribe(d);return y.add(i),()=>{T(),y.delete(i)}},dispatch(i){try{return o=!i?.meta?.[ce],a=!o,a&&(s||(s=!0,c(l))),n.dispatch(i)}finally{o=!0}}})};var it=e=>function(r){let{autoBatch:n=!0}=r??{},o=new F(e);return n&&o.push(de(typeof n=="object"?n:void 0)),o};function st(e){let t=rt(),{reducer:r=void 0,middleware:n,devTools:o=!0,duplicateMiddlewareCheck:a=!0,preloadedState:s=void 0,enhancers:y=void 0}=e||{},c;if(typeof r=="function")c=r;else if((0,D.isPlainObject)(r))c=(0,D.combineReducers)(r);else throw new Error(x(1));let l;typeof n=="function"?l=n(t):l=t();let i=D.compose;o&&(i=Je({trace:!1,...typeof o=="object"&&o}));let d=(0,D.applyMiddleware)(...l),T=it(d),g=typeof y=="function"?y(T):T(),p=i(...g);return(0,D.createStore)(c,s,p)}var G=require("immer");function ue(e){let t={},r=[],n,o={addCase(a,s){let y=typeof a=="string"?a:a.type;if(!y)throw new Error(x(28));if(y in t)throw new Error(x(29));return t[y]=s,o},addMatcher(a,s){return r.push({matcher:a,reducer:s}),o},addDefaultCase(a){return n=a,o}};return e(o),[t,r,n]}function Gt(e){return typeof e=="function"}function le(e,t){let[r,n,o]=ue(t),a;if(Gt(e))a=()=>De(e());else{let y=De(e);a=()=>y}function s(y=a(),c){let l=[r[c.type],...n.filter(({matcher:i})=>i(c)).map(({reducer:i})=>i)];return l.filter(i=>!!i).length===0&&(l=[o]),l.reduce((i,d)=>{if(d)if((0,G.isDraft)(i)){let g=d(i,c);return g===void 0?i:g}else{if((0,G.isDraftable)(i))return(0,G.produce)(i,T=>d(T,c));{let T=d(i,c);if(T===void 0){if(i===null)return i;throw Error("A case reducer on a non-draftable value must not return undefined")}return T}}return i},y)}return s.getInitialState=a,s}var ct=(e,t)=>re(e)?e.match(t):e(t);function V(...e){return t=>e.some(r=>ct(r,t))}function B(...e){return t=>e.every(r=>ct(r,t))}function pe(e,t){if(!e||!e.meta)return!1;let r=typeof e.meta.requestId=="string",n=t.indexOf(e.meta.requestStatus)>-1;return r&&n}function X(e){return typeof e[0]=="function"&&"pending"in e[0]&&"fulfilled"in e[0]&&"rejected"in e[0]}function je(...e){return e.length===0?t=>pe(t,["pending"]):X(e)?V(...e.map(t=>t.pending)):je()(e[0])}function $(...e){return e.length===0?t=>pe(t,["rejected"]):X(e)?V(...e.map(t=>t.rejected)):$()(e[0])}function Fe(...e){let t=r=>r&&r.meta&&r.meta.rejectedWithValue;return e.length===0?B($(...e),t):X(e)?B($(...e),t):Fe()(e[0])}function Ve(...e){return e.length===0?t=>pe(t,["fulfilled"]):X(e)?V(...e.map(t=>t.fulfilled)):Ve()(e[0])}function _e(...e){return e.length===0?t=>pe(t,["pending","fulfilled","rejected"]):X(e)?V(...e.flatMap(t=>[t.pending,t.rejected,t.fulfilled])):_e()(e[0])}var Bt="ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW",O=(e=21)=>{let t="",r=e;for(;r--;)t+=Bt[Math.random()*64|0];return t};var Kt=["name","message","stack","code"],J=class{constructor(t,r){this.payload=t;this.meta=r}_type},fe=class{constructor(t,r){this.payload=t;this.meta=r}_type},Le=e=>{if(typeof e=="object"&&e!==null){let t={};for(let r of Kt)typeof e[r]=="string"&&(t[r]=e[r]);return t}return{message:String(e)}},dt="External signal was aborted",ye=(()=>{function e(t,r,n){let o=b(t+"/fulfilled",(c,l,i,d)=>({payload:c,meta:{...d||{},arg:i,requestId:l,requestStatus:"fulfilled"}})),a=b(t+"/pending",(c,l,i)=>({payload:void 0,meta:{...i||{},arg:l,requestId:c,requestStatus:"pending"}})),s=b(t+"/rejected",(c,l,i,d,T)=>({payload:d,error:(n&&n.serializeError||Le)(c||"Rejected"),meta:{...T||{},arg:i,requestId:l,rejectedWithValue:!!d,requestStatus:"rejected",aborted:c?.name==="AbortError",condition:c?.name==="ConditionError"}}));function y(c,{signal:l}={}){return(i,d,T)=>{let g=n?.idGenerator?n.idGenerator(c):O(),p=new AbortController,h,u;function f(A){u=A,p.abort()}l&&(l.aborted?f(dt):l.addEventListener("abort",()=>f(dt),{once:!0}));let k=async function(){let A;try{let S=n?.condition?.(c,{getState:d,extra:T});if(Ht(S)&&(S=await S),S===!1||p.signal.aborted)throw{name:"ConditionError",message:"Aborted due to condition callback returning false."};let P=new Promise((E,R)=>{h=()=>{R({name:"AbortError",message:u||"Aborted"})},p.signal.addEventListener("abort",h)});i(a(g,c,n?.getPendingMeta?.({requestId:g,arg:c},{getState:d,extra:T}))),A=await Promise.race([P,Promise.resolve(r(c,{dispatch:i,getState:d,extra:T,requestId:g,signal:p.signal,abort:f,rejectWithValue:(E,R)=>new J(E,R),fulfillWithValue:(E,R)=>new fe(E,R)})).then(E=>{if(E instanceof J)throw E;return E instanceof fe?o(E.payload,g,c,E.meta):o(E,g,c)})])}catch(S){A=S instanceof J?s(null,g,c,S.payload,S.meta):s(S,g,c)}finally{h&&p.signal.removeEventListener("abort",h)}return n&&!n.dispatchConditionRejection&&s.match(A)&&A.meta.condition||i(A),A}();return Object.assign(k,{abort:f,requestId:g,arg:c,unwrap(){return k.then(Ue)}})}}return Object.assign(y,{pending:a,rejected:s,fulfilled:o,settled:V(s,o),typePrefix:t})}return e.withTypes=()=>e,e})();function Ue(e){if(e.meta&&e.meta.rejectedWithValue)throw e.payload;if(e.error)throw e.error;return e.payload}function Ht(e){return e!==null&&typeof e=="object"&&typeof e.then=="function"}var ut=Symbol.for("rtk-slice-createasyncthunk"),lt={[ut]:ye},We=(n=>(n.reducer="reducer",n.reducerWithPrepare="reducerWithPrepare",n.asyncThunk="asyncThunk",n))(We||{});function qt(e,t){return`${e}/${t}`}function ze({creators:e}={}){let t=e?.asyncThunk?.[ut];return function(n){let{name:o,reducerPath:a=o}=n;if(!o)throw new Error(x(11));typeof process<"u";let s=(typeof n.reducers=="function"?n.reducers(Xt()):n.reducers)||{},y=Object.keys(s),c={sliceCaseReducersByName:{},sliceCaseReducersByType:{},actionCreators:{},sliceMatchers:[]},l={addCase(A,m){let S=typeof A=="string"?A:A.type;if(!S)throw new Error(x(12));if(S in c.sliceCaseReducersByType)throw new Error(x(13));return c.sliceCaseReducersByType[S]=m,l},addMatcher(A,m){return c.sliceMatchers.push({matcher:A,reducer:m}),l},exposeAction(A,m){return c.actionCreators[A]=m,l},exposeCaseReducer(A,m){return c.sliceCaseReducersByName[A]=m,l}};y.forEach(A=>{let m=s[A],S={reducerName:A,type:qt(o,A),createNotation:typeof n.reducers=="function"};Qt(m)?Zt(S,m,l,t):Jt(S,m,l)});function i(){let[A={},m=[],S=void 0]=typeof n.extraReducers=="function"?ue(n.extraReducers):[n.extraReducers],P={...A,...c.sliceCaseReducersByType};return le(n.initialState,E=>{for(let R in P)E.addCase(R,P[R]);for(let R of c.sliceMatchers)E.addMatcher(R.matcher,R.reducer);for(let R of m)E.addMatcher(R.matcher,R.reducer);S&&E.addDefaultCase(S)})}let d=A=>A,T=new Map,g=new WeakMap,p;function h(A,m){return p||(p=i()),p(A,m)}function u(){return p||(p=i()),p.getInitialState()}function f(A,m=!1){function S(E){let R=E[A];return typeof R>"u"&&m&&(R=v(g,S,u)),R}function P(E=d){let R=v(T,m,()=>new WeakMap);return v(R,E,()=>{let q={};for(let[Z,z]of Object.entries(n.selectors??{}))q[Z]=$t(z,E,()=>v(g,E,u),m);return q})}return{reducerPath:A,getSelectors:P,get selectors(){return P(S)},selectSlice:S}}let k={name:o,reducer:h,actions:c.actionCreators,caseReducers:c.sliceCaseReducersByName,getInitialState:u,...f(a),injectInto(A,{reducerPath:m,...S}={}){let P=m??a;return A.inject({reducerPath:P,reducer:h},S),{...k,...f(P,!0)}}};return k}}function $t(e,t,r,n){function o(a,...s){let y=t(a);return typeof y>"u"&&n&&(y=r()),e(y,...s)}return o.unwrapped=e,o}var pt=ze();function Xt(){function e(t,r){return{_reducerDefinitionType:"asyncThunk",payloadCreator:t,...r}}return e.withTypes=()=>e,{reducer(t){return Object.assign({[t.name](...r){return t(...r)}}[t.name],{_reducerDefinitionType:"reducer"})},preparedReducer(t,r){return{_reducerDefinitionType:"reducerWithPrepare",prepare:t,reducer:r}},asyncThunk:e}}function Jt({type:e,reducerName:t,createNotation:r},n,o){let a,s;if("reducer"in n){if(r&&!Yt(n))throw new Error(x(17));a=n.reducer,s=n.prepare}else a=n;o.addCase(e,a).exposeCaseReducer(t,a).exposeAction(t,s?b(e,s):b(e))}function Qt(e){return e._reducerDefinitionType==="asyncThunk"}function Yt(e){return e._reducerDefinitionType==="reducerWithPrepare"}function Zt({type:e,reducerName:t},r,n,o){if(!o)throw new Error(x(18));let{payloadCreator:a,fulfilled:s,pending:y,rejected:c,settled:l,options:i}=r,d=o(e,a,i);n.exposeAction(t,d),s&&n.addCase(d.fulfilled,s),y&&n.addCase(d.pending,y),c&&n.addCase(d.rejected,c),l&&n.addMatcher(d.settled,l),n.exposeCaseReducer(t,{fulfilled:s||he,pending:y||he,rejected:c||he,settled:l||he})}function he(){}function en(){return{ids:[],entities:{}}}function ft(e){function t(r={},n){let o=Object.assign(en(),r);return n?e.setAll(o,n):o}return{getInitialState:t}}function yt(){function e(t,r={}){let{createSelector:n=ne}=r,o=d=>d.ids,a=d=>d.entities,s=n(o,a,(d,T)=>d.map(g=>T[g])),y=(d,T)=>T,c=(d,T)=>d[T],l=n(o,d=>d.length);if(!t)return{selectIds:o,selectEntities:a,selectAll:s,selectTotal:l,selectById:n(a,y,c)};let i=n(t,a);return{selectIds:n(t,o),selectEntities:i,selectAll:n(t,s),selectTotal:n(t,l),selectById:n(i,y,c)}}return{getSelectors:e}}var Ae=require("immer");var tn=Ae.isDraft;function ht(e){let t=M((r,n)=>e(n));return function(n){return t(n,void 0)}}function M(e){return function(r,n){function o(s){return ae(s)}let a=s=>{o(n)?e(n.payload,s):e(n,s)};return tn(r)?(a(r),r):(0,Ae.produce)(r,a)}}var Te=require("immer");function _(e,t){return t(e)}function j(e){return Array.isArray(e)||(e=Object.values(e)),e}function Q(e){return(0,Te.isDraft)(e)?(0,Te.current)(e):e}function me(e,t,r){e=j(e);let n=Q(r.ids),o=new Set(n),a=[],s=new Set([]),y=[];for(let c of e){let l=_(c,t);o.has(l)||s.has(l)?y.push({id:l,changes:c}):(s.add(l),a.push(c))}return[a,y,n]}function ge(e){function t(p,h){let u=_(p,e);u in h.entities||(h.ids.push(u),h.entities[u]=p)}function r(p,h){p=j(p);for(let u of p)t(u,h)}function n(p,h){let u=_(p,e);u in h.entities||h.ids.push(u),h.entities[u]=p}function o(p,h){p=j(p);for(let u of p)n(u,h)}function a(p,h){p=j(p),h.ids=[],h.entities={},r(p,h)}function s(p,h){return y([p],h)}function y(p,h){let u=!1;p.forEach(f=>{f in h.entities&&(delete h.entities[f],u=!0)}),u&&(h.ids=h.ids.filter(f=>f in h.entities))}function c(p){Object.assign(p,{ids:[],entities:{}})}function l(p,h,u){let f=u.entities[h.id];if(f===void 0)return!1;let k=Object.assign({},f,h.changes),A=_(k,e),m=A!==h.id;return m&&(p[h.id]=A,delete u.entities[h.id]),u.entities[A]=k,m}function i(p,h){return d([p],h)}function d(p,h){let u={},f={};p.forEach(A=>{A.id in h.entities&&(f[A.id]={id:A.id,changes:{...f[A.id]?.changes,...A.changes}})}),p=Object.values(f),p.length>0&&p.filter(m=>l(u,m,h)).length>0&&(h.ids=Object.values(h.entities).map(m=>_(m,e)))}function T(p,h){return g([p],h)}function g(p,h){let[u,f]=me(p,e,h);r(u,h),d(f,h)}return{removeAll:ht(c),addOne:M(t),addMany:M(r),setOne:M(n),setMany:M(o),setAll:M(a),updateOne:M(i),updateMany:M(d),upsertOne:M(T),upsertMany:M(g),removeOne:M(s),removeMany:M(y)}}function nn(e,t,r){let n=0,o=e.length;for(;n<o;){let a=n+o>>>1,s=e[a];r(t,s)>=0?n=a+1:o=a}return n}function rn(e,t,r){let n=nn(e,t,r);return e.splice(n,0,t),e}function At(e,t){let{removeOne:r,removeMany:n,removeAll:o}=ge(e);function a(u,f){return s([u],f)}function s(u,f,k){u=j(u);let A=new Set(k??Q(f.ids)),m=u.filter(S=>!A.has(_(S,e)));m.length!==0&&h(f,m)}function y(u,f){return c([u],f)}function c(u,f){if(u=j(u),u.length!==0){for(let k of u)delete f.entities[e(k)];h(f,u)}}function l(u,f){u=j(u),f.entities={},f.ids=[],s(u,f,[])}function i(u,f){return d([u],f)}function d(u,f){let k=!1,A=!1;for(let m of u){let S=f.entities[m.id];if(!S)continue;k=!0,Object.assign(S,m.changes);let P=e(S);if(m.id!==P){A=!0,delete f.entities[m.id];let E=f.ids.indexOf(m.id);f.ids[E]=P,f.entities[P]=S}}k&&h(f,[],k,A)}function T(u,f){return g([u],f)}function g(u,f){let[k,A,m]=me(u,e,f);k.length&&s(k,f,m),A.length&&d(A,f)}function p(u,f){if(u.length!==f.length)return!1;for(let k=0;k<u.length;k++)if(u[k]!==f[k])return!1;return!0}let h=(u,f,k,A)=>{let m=Q(u.entities),S=Q(u.ids),P=u.entities,E=S;A&&(E=new Set(S));let R=[];for(let z of E){let Xe=m[z];Xe&&R.push(Xe)}let q=R.length===0;for(let z of f)P[e(z)]=z,q||rn(R,z,t);q?R=f.slice().sort(t):k&&R.sort(t);let Z=R.map(e);p(S,Z)||(u.ids=Z)};return{removeOne:r,removeMany:n,removeAll:o,addOne:M(a),updateOne:M(i),upsertOne:M(T),setOne:M(y),setMany:M(c),setAll:M(l),addMany:M(s),updateMany:M(d),upsertMany:M(g)}}function Tt(e={}){let{selectId:t,sortComparer:r}={sortComparer:!1,selectId:s=>s.id,...e},n=r?At(t,r):ge(t),o=ft(n),a=yt();return{selectId:t,sortComparer:r,...o,...a,...n}}var Mt=require("redux");var on="task",mt="listener",gt="completed",Ge="cancelled",St=`task-${Ge}`,kt=`task-${gt}`,Se=`${mt}-${Ge}`,xt=`${mt}-${gt}`,I=class{constructor(t){this.code=t;this.message=`${on} ${Ge} (reason: ${t})`}name="TaskAbortError";message};var ke=(e,t)=>{if(typeof e!="function")throw new TypeError(x(32))},K=()=>{},xe=(e,t=K)=>(e.catch(t),e),Ce=(e,t)=>(e.addEventListener("abort",t,{once:!0}),()=>e.removeEventListener("abort",t)),L=(e,t)=>{let r=e.signal;r.aborted||("reason"in r||Object.defineProperty(r,"reason",{enumerable:!0,value:t,configurable:!0,writable:!0}),e.abort(t))};var U=e=>{if(e.aborted){let{reason:t}=e;throw new I(t)}};function Be(e,t){let r=K;return new Promise((n,o)=>{let a=()=>o(new I(e.reason));if(e.aborted){a();return}r=Ce(e,a),t.finally(()=>r()).then(n,o)}).finally(()=>{r=K})}var Ct=async(e,t)=>{try{return await Promise.resolve(),{status:"ok",value:await e()}}catch(r){return{status:r instanceof I?"cancelled":"rejected",error:r}}finally{t?.()}},Y=e=>t=>xe(Be(e,t).then(r=>(U(e),r))),Ke=e=>{let t=Y(e);return r=>t(new Promise(n=>setTimeout(n,r)))};var{assign:H}=Object,Et={},Ee="listenerMiddleware",an=(e,t)=>{let r=n=>Ce(e,()=>L(n,e.reason));return(n,o)=>{ke(n,"taskExecutor");let a=new AbortController;r(a);let s=Ct(async()=>{U(e),U(a.signal);let y=await n({pause:Y(a.signal),delay:Ke(a.signal),signal:a.signal});return U(a.signal),y},()=>L(a,kt));return o?.autoJoin&&t.push(s.catch(K)),{result:Y(e)(s),cancel(){L(a,St)}}}},sn=(e,t)=>{let r=async(n,o)=>{U(t);let a=()=>{},y=[new Promise((c,l)=>{let i=e({predicate:n,effect:(d,T)=>{T.unsubscribe(),c([d,T.getState(),T.getOriginalState()])}});a=()=>{i(),l()}})];o!=null&&y.push(new Promise(c=>setTimeout(c,o,null)));try{let c=await Be(t,Promise.race(y));return U(t),c}finally{a()}};return(n,o)=>xe(r(n,o))},Pt=e=>{let{type:t,actionCreator:r,matcher:n,predicate:o,effect:a}=e;if(t)o=b(t).match;else if(r)t=r.type,o=r.match;else if(n)o=n;else if(!o)throw new Error(x(21));return ke(a,"options.listener"),{predicate:o,type:t,effect:a}},bt=H(e=>{let{type:t,predicate:r,effect:n}=Pt(e);return{id:O(),effect:n,type:t,predicate:r,pending:new Set,unsubscribe:()=>{throw new Error(x(22))}}},{withTypes:()=>bt}),Rt=(e,t)=>{let{type:r,effect:n,predicate:o}=Pt(t);return Array.from(e.values()).find(a=>(typeof r=="string"?a.type===r:a.predicate===o)&&a.effect===n)},He=e=>{e.pending.forEach(t=>{L(t,Se)})},cn=e=>()=>{e.forEach(He),e.clear()},wt=(e,t,r)=>{try{e(t,r)}catch(n){setTimeout(()=>{throw n},0)}},Re=H(b(`${Ee}/add`),{withTypes:()=>Re}),qe=b(`${Ee}/removeAll`),we=H(b(`${Ee}/remove`),{withTypes:()=>we}),dn=(...e)=>{console.error(`${Ee}/error`,...e)},It=(e={})=>{let t=new Map,{extra:r,onError:n=dn}=e;ke(n,"onError");let o=i=>(i.unsubscribe=()=>t.delete(i.id),t.set(i.id,i),d=>{i.unsubscribe(),d?.cancelActive&&He(i)}),a=i=>{let d=Rt(t,i)??bt(i);return o(d)};H(a,{withTypes:()=>a});let s=i=>{let d=Rt(t,i);return d&&(d.unsubscribe(),i.cancelActive&&He(d)),!!d};H(s,{withTypes:()=>s});let y=async(i,d,T,g)=>{let p=new AbortController,h=sn(a,p.signal),u=[];try{i.pending.add(p),await Promise.resolve(i.effect(d,H({},T,{getOriginalState:g,condition:(f,k)=>h(f,k).then(Boolean),take:h,delay:Ke(p.signal),pause:Y(p.signal),extra:r,signal:p.signal,fork:an(p.signal,u),unsubscribe:i.unsubscribe,subscribe:()=>{t.set(i.id,i)},cancelActiveListeners:()=>{i.pending.forEach((f,k,A)=>{f!==p&&(L(f,Se),A.delete(f))})},cancel:()=>{L(p,Se),i.pending.delete(p)},throwIfCancelled:()=>{U(p.signal)}})))}catch(f){f instanceof I||wt(n,f,{raisedBy:"effect"})}finally{await Promise.all(u),L(p,xt),i.pending.delete(p)}},c=cn(t);return{middleware:i=>d=>T=>{if(!(0,Mt.isAction)(T))return d(T);if(Re.match(T))return a(T.payload);if(qe.match(T)){c();return}if(we.match(T))return s(T.payload);let g=i.getState(),p=()=>{if(g===Et)throw new Error(x(23));return g},h;try{if(h=d(T),t.size>0){let u=i.getState(),f=Array.from(t.values());for(let k of f){let A=!1;try{A=k.predicate(T,u,g)}catch(m){A=!1,wt(n,m,{raisedBy:"predicate"})}A&&y(k,T,i,p)}}}finally{g=Et}return h},startListening:a,stopListening:s,clearListeners:c}};var vt=require("redux");var un=e=>({middleware:e,applied:new Map}),ln=e=>t=>t?.meta?.instanceId===e,Dt=()=>{let e=O(),t=new Map,r=Object.assign(b("dynamicMiddleware/add",(...y)=>({payload:y,meta:{instanceId:e}})),{withTypes:()=>r}),n=Object.assign(function(...c){c.forEach(l=>{v(t,l,un)})},{withTypes:()=>n}),o=y=>{let c=Array.from(t.values()).map(l=>v(l.applied,y,l.middleware));return(0,vt.compose)(...c)},a=B(r,ln(e));return{middleware:y=>c=>l=>a(l)?(n(...l.payload),y.dispatch):o(y)(c)(l),addMiddleware:n,withMiddleware:r,instanceId:e}};var Ot=require("redux");var pn=e=>"reducerPath"in e&&typeof e.reducerPath=="string",fn=e=>e.flatMap(t=>pn(t)?[[t.reducerPath,t.reducer]]:Object.entries(t)),$e=Symbol.for("rtk-state-proxy-original"),yn=e=>!!e&&!!e[$e],hn=new WeakMap,An=(e,t,r)=>v(hn,e,()=>new Proxy(e,{get:(n,o,a)=>{if(o===$e)return n;let s=Reflect.get(n,o,a);if(typeof s>"u"){let y=r[o];if(typeof y<"u")return y;let c=t[o];if(c){let l=c(void 0,{type:O()});if(typeof l>"u")throw new Error(x(24));return r[o]=l,l}}return s}})),Tn=e=>{if(!yn(e))throw new Error(x(25));return e[$e]},mn={},gn=(e=mn)=>e;function Nt(...e){let t=Object.fromEntries(fn(e)),r=()=>Object.keys(t).length?(0,Ot.combineReducers)(t):gn,n=r();function o(c,l){return n(c,l)}o.withLazyLoadedSlices=()=>o;let a={},s=(c,l={})=>{let{reducerPath:i,reducer:d}=c,T=t[i];return!l.overrideExisting&&T&&T!==d?(typeof process<"u",o):(l.overrideExisting&&T!==d&&delete a[i],t[i]=d,n=r(),o)},y=Object.assign(function(l,i){return function(T,...g){return l(An(i?i(T,...g):T,t,a),...g)}},{original:Tn});return Object.assign(o,{inject:s,selector:y})}function x(e){return`Minified Redux Toolkit error #${e}; visit https://redux-toolkit.js.org/Errors?code=${e} for the full message or use the non-minified dev environment for full errors. `}0&&(module.exports={ReducerType,SHOULD_AUTOBATCH,TaskAbortError,Tuple,addListener,asyncThunkCreator,autoBatchEnhancer,buildCreateSlice,clearAllListeners,combineSlices,configureStore,createAction,createActionCreatorInvariantMiddleware,createAsyncThunk,createDraftSafeSelector,createDraftSafeSelectorCreator,createDynamicMiddleware,createEntityAdapter,createImmutableStateInvariantMiddleware,createListenerMiddleware,createNextState,createReducer,createSelector,createSelectorCreator,createSerializableStateInvariantMiddleware,createSlice,current,findNonSerializableValue,formatProdErrorMessage,freeze,isActionCreator,isAllOf,isAnyOf,isAsyncThunkAction,isDraft,isFluxStandardAction,isFulfilled,isImmutableDefault,isPending,isPlain,isRejected,isRejectedWithValue,lruMemoize,miniSerializeError,nanoid,original,prepareAutoBatched,removeListener,unwrapResult,weakMapMemoize,...require("redux")});
+//# sourceMappingURL=redux-toolkit.production.min.cjs.map

frontend/node_modules/@reduxjs/toolkit/dist/query/cjs/index.js

@@ -0,0 +1,6 @@
+'use strict'
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./rtk-query.production.min.cjs')
+} else {
+  module.exports = require('./rtk-query.development.cjs')
+}

frontend/node_modules/@reduxjs/toolkit/dist/query/cjs/rtk-query.production.min.cjs

@@ -0,0 +1,2 @@
+"use strict";var Ce=Object.defineProperty;var Bt=Object.getOwnPropertyDescriptor;var Mt=Object.getOwnPropertyNames;var wt=Object.prototype.hasOwnProperty;var Ct=(e,t)=>{for(var p in t)Ce(e,p,{get:t[p],enumerable:!0})},Ft=(e,t,p,m)=>{if(t&&typeof t=="object"||typeof t=="function")for(let y of Mt(t))!wt.call(e,y)&&y!==p&&Ce(e,y,{get:()=>t[y],enumerable:!(m=Bt(t,y))||m.enumerable});return e};var vt=e=>Ft(Ce({},"__esModule",{value:!0}),e);var Wt={};Ct(Wt,{NamedSchemaError:()=>oe,QueryStatus:()=>De,_NEVER:()=>ft,buildCreateApi:()=>Me,copyWithStructuralSharing:()=>me,coreModule:()=>we,coreModuleName:()=>Se,createApi:()=>It,defaultSerializeQueryArgs:()=>Re,fakeBaseQuery:()=>mt,fetchBaseQuery:()=>Je,retry:()=>Ye,setupListeners:()=>Xe,skipToken:()=>Ae});module.exports=vt(Wt);var De=(y=>(y.uninitialized="uninitialized",y.pending="pending",y.fulfilled="fulfilled",y.rejected="rejected",y))(De||{});function Fe(e){return{status:e,isUninitialized:e==="uninitialized",isLoading:e==="pending",isSuccess:e==="fulfilled",isError:e==="rejected"}}var i=require("@reduxjs/toolkit");var Le=i.isPlainObject;function me(e,t){if(e===t||!(Le(e)&&Le(t)||Array.isArray(e)&&Array.isArray(t)))return t;let p=Object.keys(t),m=Object.keys(e),y=p.length===m.length,D=Array.isArray(t)?[]:{};for(let h of p)D[h]=me(e[h],t[h]),y&&(y=e[h]===D[h]);return y?e:D}function J(e){let t=0;for(let p in e)t++;return t}var ve=e=>[].concat(...e);function je(e){return new RegExp("(^|:)//").test(e)}function He(){return typeof document>"u"?!0:document.visibilityState!=="hidden"}function re(e){return e!=null}function _e(){return typeof navigator>"u"||navigator.onLine===void 0?!0:navigator.onLine}var Ot=e=>e.replace(/\/$/,""),Nt=e=>e.replace(/^\//,"");function Ve(e,t){if(!e)return t;if(!t)return e;if(je(t))return t;let p=e.endsWith("/")||!t.startsWith("?")?"/":"";return e=Ot(e),t=Nt(t),`${e}${p}${t}`}function ze(e,t,p){return e.has(t)?e.get(t):e.set(t,p).get(t)}var We=(...e)=>fetch(...e),qt=e=>e.status>=200&&e.status<=299,Kt=e=>/ion\/(vnd\.api\+)?json/.test(e.get("content-type")||"");function $e(e){if(!(0,i.isPlainObject)(e))return e;let t={...e};for(let[p,m]of Object.entries(t))m===void 0&&delete t[p];return t}function Je({baseUrl:e,prepareHeaders:t=A=>A,fetchFn:p=We,paramsSerializer:m,isJsonContentType:y=Kt,jsonContentType:D="application/json",jsonReplacer:h,timeout:B,responseHandler:C,validateStatus:R,...I}={}){return typeof fetch>"u"&&p===We&&console.warn("Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments."),async(S,o,g)=>{let{getState:M,extra:c,endpoint:s,forced:x,type:l}=o,d,{url:Q,headers:b=new Headers(I.headers),params:E=void 0,responseHandler:k=C??"json",validateStatus:T=R??qt,timeout:u=B,...n}=typeof S=="string"?{url:S}:S,r,a=o.signal;u&&(r=new AbortController,o.signal.addEventListener("abort",r.abort),a=r.signal);let f={...I,signal:a,...n};b=new Headers($e(b)),f.headers=await t(b,{getState:M,arg:S,extra:c,endpoint:s,forced:x,type:l,extraOptions:g})||b;let P=q=>typeof q=="object"&&((0,i.isPlainObject)(q)||Array.isArray(q)||typeof q.toJSON=="function");if(!f.headers.has("content-type")&&P(f.body)&&f.headers.set("content-type",D),P(f.body)&&y(f.headers)&&(f.body=JSON.stringify(f.body,h)),E){let q=~Q.indexOf("?")?"&":"?",v=m?m(E):new URLSearchParams($e(E));Q+=q+v}Q=Ve(e,Q);let O=new Request(Q,f);d={request:new Request(Q,f)};let F,w=!1,U=r&&setTimeout(()=>{w=!0,r.abort()},u);try{F=await p(O)}catch(q){return{error:{status:w?"TIMEOUT_ERROR":"FETCH_ERROR",error:String(q)},meta:d}}finally{U&&clearTimeout(U),r?.signal.removeEventListener("abort",r.abort)}let H=F.clone();d.response=H;let W,j="";try{let q;if(await Promise.all([A(F,k).then(v=>W=v,v=>q=v),H.text().then(v=>j=v,()=>{})]),q)throw q}catch(q){return{error:{status:"PARSING_ERROR",originalStatus:F.status,data:j,error:String(q)},meta:d}}return T(F,W)?{data:W,meta:d}:{error:{status:F.status,data:W},meta:d}};async function A(S,o){if(typeof o=="function")return o(S);if(o==="content-type"&&(o=y(S.headers)?"json":"text"),o==="json"){let g=await S.text();return g.length?JSON.parse(g):null}return S.text()}}var G=class{constructor(t,p=void 0){this.value=t;this.meta=p}};async function Ut(e=0,t=5){let p=Math.min(e,t),m=~~((Math.random()+.4)*(300<<p));await new Promise(y=>setTimeout(D=>y(D),m))}function Lt(e,t){throw Object.assign(new G({error:e,meta:t}),{throwImmediately:!0})}var Ge={},jt=(e,t)=>async(p,m,y)=>{let D=[5,(t||Ge).maxRetries,(y||Ge).maxRetries].filter(I=>I!==void 0),[h]=D.slice(-1),C={maxRetries:h,backoff:Ut,retryCondition:(I,A,{attempt:S})=>S<=h,...t,...y},R=0;for(;;)try{let I=await e(p,m,y);if(I.error)throw new G(I);return I}catch(I){if(R++,I.throwImmediately){if(I instanceof G)return I.value;throw I}if(I instanceof G&&!C.retryCondition(I.value.error,p,{attempt:R,baseQueryApi:m,extraOptions:y}))return I.value;await C.backoff(R,C.maxRetries)}},Ye=Object.assign(jt,{fail:Lt});var ee=(0,i.createAction)("__rtkq/focused"),pe=(0,i.createAction)("__rtkq/unfocused"),te=(0,i.createAction)("__rtkq/online"),ce=(0,i.createAction)("__rtkq/offline"),Oe=!1;function Xe(e,t){function p(){let m=()=>e(ee()),y=()=>e(pe()),D=()=>e(te()),h=()=>e(ce()),B=()=>{window.document.visibilityState==="visible"?m():y()};return Oe||typeof window<"u"&&window.addEventListener&&(window.addEventListener("visibilitychange",B,!1),window.addEventListener("focus",m,!1),window.addEventListener("online",D,!1),window.addEventListener("offline",h,!1),Oe=!0),()=>{window.removeEventListener("focus",m),window.removeEventListener("visibilitychange",B),window.removeEventListener("online",D),window.removeEventListener("offline",h),Oe=!1}}return t?t(e,{onFocus:ee,onFocusLost:pe,onOffline:ce,onOnline:te}):p()}function ie(e){return e.type==="query"}function Ze(e){return e.type==="mutation"}function ae(e){return e.type==="infinitequery"}function le(e){return ie(e)||ae(e)}function ge(e,t,p,m,y,D){return Ht(e)?e(t,p,m,y).filter(re).map(be).map(D):Array.isArray(e)?e.map(be).map(D):[]}function Ht(e){return typeof e=="function"}function be(e){return typeof e=="string"?{type:e}:e}var Pe=require("immer");var An=require("@reduxjs/toolkit");function et(e,t){return e.catch(t)}var fe=Symbol("forceQueryFn"),Qe=e=>typeof e[fe]=="function";function tt({serializeQueryArgs:e,queryThunk:t,infiniteQueryThunk:p,mutationThunk:m,api:y,context:D}){let h=new Map,B=new Map,{unsubscribeQueryResult:C,removeMutationResult:R,updateSubscriptionOptions:I}=y.internalActions;return{buildInitiateQuery:s,buildInitiateInfiniteQuery:x,buildInitiateMutation:l,getRunningQueryThunk:A,getRunningMutationThunk:S,getRunningQueriesThunk:o,getRunningMutationsThunk:g};function A(d,Q){return b=>{let E=D.endpointDefinitions[d],k=e({queryArgs:Q,endpointDefinition:E,endpointName:d});return h.get(b)?.[k]}}function S(d,Q){return b=>B.get(b)?.[Q]}function o(){return d=>Object.values(h.get(d)||{}).filter(re)}function g(){return d=>Object.values(B.get(d)||{}).filter(re)}function M(d){}function c(d,Q){let b=(E,{subscribe:k=!0,forceRefetch:T,subscriptionOptions:u,[fe]:n,...r}={})=>(a,f)=>{let P=e({queryArgs:E,endpointDefinition:Q,endpointName:d}),O,N={...r,type:"query",subscribe:k,forceRefetch:T,subscriptionOptions:u,endpointName:d,originalArgs:E,queryCacheKey:P,[fe]:n};if(ie(Q))O=t(N);else{let{direction:_,initialPageParam:K}=r;O=p({...N,direction:_,initialPageParam:K})}let F=y.endpoints[d].select(E),w=a(O),U=F(f());let{requestId:H,abort:W}=w,j=U.requestId!==H,q=h.get(a)?.[P],v=()=>F(f()),V=Object.assign(n?w.then(v):j&&!q?Promise.resolve(U):Promise.all([q,w]).then(v),{arg:E,requestId:H,subscriptionOptions:u,queryCacheKey:P,abort:W,async unwrap(){let _=await V;if(_.isError)throw _.error;return _.data},refetch:()=>a(b(E,{subscribe:!1,forceRefetch:!0})),unsubscribe(){k&&a(C({queryCacheKey:P,requestId:H}))},updateSubscriptionOptions(_){V.subscriptionOptions=_,a(I({endpointName:d,requestId:H,queryCacheKey:P,options:_}))}});if(!q&&!j&&!n){let _=ze(h,a,{});_[P]=V,V.then(()=>{delete _[P],J(_)||h.delete(a)})}return V};return b}function s(d,Q){return c(d,Q)}function x(d,Q){return c(d,Q)}function l(d){return(Q,{track:b=!0,fixedCacheKey:E}={})=>(k,T)=>{let u=m({type:"mutation",endpointName:d,originalArgs:Q,track:b,fixedCacheKey:E}),n=k(u);let{requestId:r,abort:a,unwrap:f}=n,P=et(n.unwrap().then(w=>({data:w})),w=>({error:w})),O=()=>{k(R({requestId:r,fixedCacheKey:E}))},N=Object.assign(P,{arg:n.arg,requestId:r,abort:a,unwrap:f,reset:O}),F=B.get(k)||{};return B.set(k,F),F[r]=N,N.then(()=>{delete F[r],J(F)||B.delete(k)}),E&&(F[E]=N,N.then(()=>{F[E]===N&&(delete F[E],J(F)||B.delete(k))})),N}}}var nt=require("@standard-schema/utils"),oe=class extends nt.SchemaError{constructor(p,m,y,D){super(p);this.value=m;this.schemaName=y;this._bqMeta=D}};async function ne(e,t,p,m){let y=await e["~standard"].validate(t);if(y.issues)throw new oe(y.issues,t,p,m);return y.value}function _t(e){return e}var Te=(e={})=>({...e,[i.SHOULD_AUTOBATCH]:!0});function rt({reducerPath:e,baseQuery:t,context:{endpointDefinitions:p},serializeQueryArgs:m,api:y,assertTagType:D,selectors:h,onSchemaFailure:B,catchSchemaFailure:C,skipSchemaValidation:R}){let I=(n,r,a,f)=>(P,O)=>{let N=p[n],F=m({queryArgs:r,endpointDefinition:N,endpointName:n});if(P(y.internalActions.queryResultPatched({queryCacheKey:F,patches:a})),!f)return;let w=y.endpoints[n].select(r)(O()),U=ge(N.providesTags,w.data,void 0,r,{},D);P(y.internalActions.updateProvidedBy([{queryCacheKey:F,providedTags:U}]))};function A(n,r,a=0){let f=[r,...n];return a&&f.length>a?f.slice(0,-1):f}function S(n,r,a=0){let f=[...n,r];return a&&f.length>a?f.slice(1):f}let o=(n,r,a,f=!0)=>(P,O)=>{let F=y.endpoints[n].select(r)(O()),w={patches:[],inversePatches:[],undo:()=>P(y.util.patchQueryData(n,r,w.inversePatches,f))};if(F.status==="uninitialized")return w;let U;if("data"in F)if((0,Pe.isDraftable)(F.data)){let[H,W,j]=(0,Pe.produceWithPatches)(F.data,a);w.patches.push(...W),w.inversePatches.push(...j),U=H}else U=a(F.data),w.patches.push({op:"replace",path:[],value:U}),w.inversePatches.push({op:"replace",path:[],value:F.data});return w.patches.length===0||P(y.util.patchQueryData(n,r,w.patches,f)),w},g=(n,r,a)=>f=>f(y.endpoints[n].initiate(r,{subscribe:!1,forceRefetch:!0,[fe]:()=>({data:a})})),M=(n,r)=>n.query&&n[r]?n[r]:_t,c=async(n,{signal:r,abort:a,rejectWithValue:f,fulfillWithValue:P,dispatch:O,getState:N,extra:F})=>{let w=p[n.endpointName],{metaSchema:U,skipSchemaValidation:H=R}=w;try{let W=M(w,"transformResponse"),j={signal:r,abort:a,dispatch:O,getState:N,extra:F,endpoint:n.endpointName,type:n.type,forced:n.type==="query"?s(n,N()):void 0,queryCacheKey:n.type==="query"?n.queryCacheKey:void 0},q=n.type==="query"?n[fe]:void 0,v,V=async(K,L,z,ue)=>{if(L==null&&K.pages.length)return Promise.resolve({data:K});let X={queryArg:n.originalArgs,pageParam:L},ye=await _(X),$=ue?A:S;return{data:{pages:$(K.pages,ye.data,z),pageParams:$(K.pageParams,L,z)},meta:ye.meta}};async function _(K){let L,{extraOptions:z,argSchema:ue,rawResponseSchema:X,responseSchema:ye}=w;if(ue&&!H&&(K=await ne(ue,K,"argSchema",{})),q?L=q():w.query?L=await t(w.query(K),j,z):L=await w.queryFn(K,j,z,de=>t(de,j,z)),typeof process<"u",L.error)throw new G(L.error,L.meta);let{data:$}=L;X&&!H&&($=await ne(X,L.data,"rawResponseSchema",L.meta));let Z=await W($,L.meta,K);return ye&&!H&&(Z=await ne(ye,Z,"responseSchema",L.meta)),{...L,data:Z}}if(n.type==="query"&&"infiniteQueryOptions"in w){let{infiniteQueryOptions:K}=w,{maxPages:L=1/0}=K,z,ue={pages:[],pageParams:[]},X=h.selectQueryEntry(N(),n.queryCacheKey)?.data,$=s(n,N())&&!n.direction||!X?ue:X;if("direction"in n&&n.direction&&$.pages.length){let Z=n.direction==="backward",xe=(Z?Ne:Ee)(K,$,n.originalArgs);z=await V($,xe,L,Z)}else{let{initialPageParam:Z=K.initialPageParam}=n,de=X?.pageParams??[],xe=de[0]??Z,Ke=de.length;z=await V($,xe,L),q&&(z={data:z.data.pages[0]});for(let Ue=1;Ue<Ke;Ue++){let kt=Ee(K,z.data,n.originalArgs);z=await V(z.data,kt,L)}}v=z}else v=await _(n.originalArgs);return U&&!H&&v.meta&&(v.meta=await ne(U,v.meta,"metaSchema",v.meta)),P(v.data,Te({fulfilledTimeStamp:Date.now(),baseQueryMeta:v.meta}))}catch(W){let j=W;if(j instanceof G){let q=M(w,"transformErrorResponse"),{rawErrorResponseSchema:v,errorResponseSchema:V}=w,{value:_,meta:K}=j;try{v&&!H&&(_=await ne(v,_,"rawErrorResponseSchema",K)),U&&!H&&(K=await ne(U,K,"metaSchema",K));let L=await q(_,K,n.originalArgs);return V&&!H&&(L=await ne(V,L,"errorResponseSchema",K)),f(L,Te({baseQueryMeta:K}))}catch(L){j=L}}try{if(j instanceof oe){let q={endpoint:n.endpointName,arg:n.originalArgs,type:n.type,queryCacheKey:n.type==="query"?n.queryCacheKey:void 0};w.onSchemaFailure?.(j,q),B?.(j,q);let{catchSchemaFailure:v=C}=w;if(v)return f(v(j,q),Te({baseQueryMeta:j._bqMeta}))}}catch(q){j=q}throw typeof process<"u",console.error(j),j}};function s(n,r){let a=h.selectQueryEntry(r,n.queryCacheKey),f=h.selectConfig(r).refetchOnMountOrArgChange,P=a?.fulfilledTimeStamp,O=n.forceRefetch??(n.subscribe&&f);return O?O===!0||(Number(new Date)-Number(P))/1e3>=O:!1}let x=()=>(0,i.createAsyncThunk)(`${e}/executeQuery`,c,{getPendingMeta({arg:r}){let a=p[r.endpointName];return Te({startedTimeStamp:Date.now(),...ae(a)?{direction:r.direction}:{}})},condition(r,{getState:a}){let f=a(),P=h.selectQueryEntry(f,r.queryCacheKey),O=P?.fulfilledTimeStamp,N=r.originalArgs,F=P?.originalArgs,w=p[r.endpointName],U=r.direction;return Qe(r)?!0:P?.status==="pending"?!1:s(r,f)||ie(w)&&w?.forceRefetch?.({currentArg:N,previousArg:F,endpointState:P,state:f})?!0:!(O&&!U)},dispatchConditionRejection:!0}),l=x(),d=x(),Q=(0,i.createAsyncThunk)(`${e}/executeMutation`,c,{getPendingMeta(){return Te({startedTimeStamp:Date.now()})}}),b=n=>"force"in n,E=n=>"ifOlderThan"in n,k=(n,r,a)=>(f,P)=>{let O=b(a)&&a.force,N=E(a)&&a.ifOlderThan,F=(U=!0)=>{let H={forceRefetch:U,isPrefetch:!0};return y.endpoints[n].initiate(r,H)},w=y.endpoints[n].select(r)(P());if(O)f(F());else if(N){let U=w?.fulfilledTimeStamp;if(!U){f(F());return}(Number(new Date)-Number(new Date(U)))/1e3>=N&&f(F())}else f(F(!1))};function T(n){return r=>r?.meta?.arg?.endpointName===n}function u(n,r){return{matchPending:(0,i.isAllOf)((0,i.isPending)(n),T(r)),matchFulfilled:(0,i.isAllOf)((0,i.isFulfilled)(n),T(r)),matchRejected:(0,i.isAllOf)((0,i.isRejected)(n),T(r))}}return{queryThunk:l,mutationThunk:Q,infiniteQueryThunk:d,prefetch:k,updateQueryData:o,upsertQueryData:g,patchQueryData:I,buildMatchThunkActions:u}}function Ee(e,{pages:t,pageParams:p},m){let y=t.length-1;return e.getNextPageParam(t[y],t,p[y],p,m)}function Ne(e,{pages:t,pageParams:p},m){return e.getPreviousPageParam?.(t[0],t,p[0],p,m)}function Ie(e,t,p,m){return ge(p[e.meta.arg.endpointName][t],(0,i.isFulfilled)(e)?e.payload:void 0,(0,i.isRejectedWithValue)(e)?e.payload:void 0,e.meta.arg.originalArgs,"baseQueryMeta"in e.meta?e.meta.baseQueryMeta:void 0,m)}var at=require("immer"),he=require("immer");function ke(e,t,p){let m=e[t];m&&p(m)}function se(e){return("arg"in e?e.arg.fixedCacheKey:e.fixedCacheKey)??e.requestId}function it(e,t,p){let m=e[se(t)];m&&p(m)}var Be={};function ot({reducerPath:e,queryThunk:t,mutationThunk:p,serializeQueryArgs:m,context:{endpointDefinitions:y,apiUid:D,extractRehydrationInfo:h,hasRehydrationInfo:B},assertTagType:C,config:R}){let I=(0,i.createAction)(`${e}/resetApiState`);function A(T,u,n,r){T[u.queryCacheKey]??={status:"uninitialized",endpointName:u.endpointName},ke(T,u.queryCacheKey,a=>{a.status="pending",a.requestId=n&&a.requestId?a.requestId:r.requestId,u.originalArgs!==void 0&&(a.originalArgs=u.originalArgs),a.startedTimeStamp=r.startedTimeStamp;let f=y[r.arg.endpointName];ae(f)&&"direction"in u&&(a.direction=u.direction)})}function S(T,u,n,r){ke(T,u.arg.queryCacheKey,a=>{if(a.requestId!==u.requestId&&!r)return;let{merge:f}=y[u.arg.endpointName];if(a.status="fulfilled",f)if(a.data!==void 0){let{fulfilledTimeStamp:P,arg:O,baseQueryMeta:N,requestId:F}=u,w=(0,i.createNextState)(a.data,U=>f(U,n,{arg:O.originalArgs,baseQueryMeta:N,fulfilledTimeStamp:P,requestId:F}));a.data=w}else a.data=n;else a.data=y[u.arg.endpointName].structuralSharing??!0?me((0,at.isDraft)(a.data)?(0,he.original)(a.data):a.data,n):n;delete a.error,a.fulfilledTimeStamp=u.fulfilledTimeStamp})}let o=(0,i.createSlice)({name:`${e}/queries`,initialState:Be,reducers:{removeQueryResult:{reducer(T,{payload:{queryCacheKey:u}}){delete T[u]},prepare:(0,i.prepareAutoBatched)()},cacheEntriesUpserted:{reducer(T,u){for(let n of u.payload){let{queryDescription:r,value:a}=n;A(T,r,!0,{arg:r,requestId:u.meta.requestId,startedTimeStamp:u.meta.timestamp}),S(T,{arg:r,requestId:u.meta.requestId,fulfilledTimeStamp:u.meta.timestamp,baseQueryMeta:{}},a,!0)}},prepare:T=>({payload:T.map(r=>{let{endpointName:a,arg:f,value:P}=r,O=y[a];return{queryDescription:{type:"query",endpointName:a,originalArgs:r.arg,queryCacheKey:m({queryArgs:f,endpointDefinition:O,endpointName:a})},value:P}}),meta:{[i.SHOULD_AUTOBATCH]:!0,requestId:(0,i.nanoid)(),timestamp:Date.now()}})},queryResultPatched:{reducer(T,{payload:{queryCacheKey:u,patches:n}}){ke(T,u,r=>{r.data=(0,he.applyPatches)(r.data,n.concat())})},prepare:(0,i.prepareAutoBatched)()}},extraReducers(T){T.addCase(t.pending,(u,{meta:n,meta:{arg:r}})=>{let a=Qe(r);A(u,r,a,n)}).addCase(t.fulfilled,(u,{meta:n,payload:r})=>{let a=Qe(n.arg);S(u,n,r,a)}).addCase(t.rejected,(u,{meta:{condition:n,arg:r,requestId:a},error:f,payload:P})=>{ke(u,r.queryCacheKey,O=>{if(!n){if(O.requestId!==a)return;O.status="rejected",O.error=P??f}})}).addMatcher(B,(u,n)=>{let{queries:r}=h(n);for(let[a,f]of Object.entries(r))(f?.status==="fulfilled"||f?.status==="rejected")&&(u[a]=f)})}}),g=(0,i.createSlice)({name:`${e}/mutations`,initialState:Be,reducers:{removeMutationResult:{reducer(T,{payload:u}){let n=se(u);n in T&&delete T[n]},prepare:(0,i.prepareAutoBatched)()}},extraReducers(T){T.addCase(p.pending,(u,{meta:n,meta:{requestId:r,arg:a,startedTimeStamp:f}})=>{a.track&&(u[se(n)]={requestId:r,status:"pending",endpointName:a.endpointName,startedTimeStamp:f})}).addCase(p.fulfilled,(u,{payload:n,meta:r})=>{r.arg.track&&it(u,r,a=>{a.requestId===r.requestId&&(a.status="fulfilled",a.data=n,a.fulfilledTimeStamp=r.fulfilledTimeStamp)})}).addCase(p.rejected,(u,{payload:n,error:r,meta:a})=>{a.arg.track&&it(u,a,f=>{f.requestId===a.requestId&&(f.status="rejected",f.error=n??r)})}).addMatcher(B,(u,n)=>{let{mutations:r}=h(n);for(let[a,f]of Object.entries(r))(f?.status==="fulfilled"||f?.status==="rejected")&&a!==f?.requestId&&(u[a]=f)})}}),M={tags:{},keys:{}},c=(0,i.createSlice)({name:`${e}/invalidation`,initialState:M,reducers:{updateProvidedBy:{reducer(T,u){for(let{queryCacheKey:n,providedTags:r}of u.payload){s(T,n);for(let{type:a,id:f}of r){let P=(T.tags[a]??={})[f||"__internal_without_id"]??=[];P.includes(n)||P.push(n)}T.keys[n]=r}},prepare:(0,i.prepareAutoBatched)()}},extraReducers(T){T.addCase(o.actions.removeQueryResult,(u,{payload:{queryCacheKey:n}})=>{s(u,n)}).addMatcher(B,(u,n)=>{let{provided:r}=h(n);for(let[a,f]of Object.entries(r))for(let[P,O]of Object.entries(f)){let N=(u.tags[a]??={})[P||"__internal_without_id"]??=[];for(let F of O)N.includes(F)||N.push(F)}}).addMatcher((0,i.isAnyOf)((0,i.isFulfilled)(t),(0,i.isRejectedWithValue)(t)),(u,n)=>{x(u,[n])}).addMatcher(o.actions.cacheEntriesUpserted.match,(u,n)=>{let r=n.payload.map(({queryDescription:a,value:f})=>({type:"UNKNOWN",payload:f,meta:{requestStatus:"fulfilled",requestId:"UNKNOWN",arg:a}}));x(u,r)})}});function s(T,u){let n=T.keys[u]??[];for(let r of n){let a=r.type,f=r.id??"__internal_without_id",P=T.tags[a]?.[f];P&&(T.tags[a][f]=P.filter(O=>O!==u))}delete T.keys[u]}function x(T,u){let n=u.map(r=>{let a=Ie(r,"providesTags",y,C),{queryCacheKey:f}=r.meta.arg;return{queryCacheKey:f,providedTags:a}});c.caseReducers.updateProvidedBy(T,c.actions.updateProvidedBy(n))}let l=(0,i.createSlice)({name:`${e}/subscriptions`,initialState:Be,reducers:{updateSubscriptionOptions(T,u){},unsubscribeQueryResult(T,u){},internal_getRTKQSubscriptions(){}}}),d=(0,i.createSlice)({name:`${e}/internalSubscriptions`,initialState:Be,reducers:{subscriptionsUpdated:{reducer(T,u){return(0,he.applyPatches)(T,u.payload)},prepare:(0,i.prepareAutoBatched)()}}}),Q=(0,i.createSlice)({name:`${e}/config`,initialState:{online:_e(),focused:He(),middlewareRegistered:!1,...R},reducers:{middlewareRegistered(T,{payload:u}){T.middlewareRegistered=T.middlewareRegistered==="conflict"||D!==u?"conflict":!0}},extraReducers:T=>{T.addCase(te,u=>{u.online=!0}).addCase(ce,u=>{u.online=!1}).addCase(ee,u=>{u.focused=!0}).addCase(pe,u=>{u.focused=!1}).addMatcher(B,u=>({...u}))}}),b=(0,i.combineReducers)({queries:o.reducer,mutations:g.reducer,provided:c.reducer,subscriptions:d.reducer,config:Q.reducer}),E=(T,u)=>b(I.match(u)?void 0:T,u),k={...Q.actions,...o.actions,...l.actions,...d.actions,...g.actions,...c.actions,resetApiState:I};return{reducer:E,actions:k}}var Ae=Symbol.for("RTKQ/skipToken"),yt={status:"uninitialized"},st=(0,i.createNextState)(yt,()=>{}),ut=(0,i.createNextState)(yt,()=>{});function dt({serializeQueryArgs:e,reducerPath:t,createSelector:p}){let m=l=>st,y=l=>ut;return{buildQuerySelector:S,buildInfiniteQuerySelector:o,buildMutationSelector:g,selectInvalidatedBy:M,selectCachedArgsForQuery:c,selectApiState:h,selectQueries:B,selectMutations:R,selectQueryEntry:C,selectConfig:I};function D(l){return{...l,...Fe(l.status)}}function h(l){return l[t]}function B(l){return h(l)?.queries}function C(l,d){return B(l)?.[d]}function R(l){return h(l)?.mutations}function I(l){return h(l)?.config}function A(l,d,Q){return b=>{if(b===Ae)return p(m,Q);let E=e({queryArgs:b,endpointDefinition:d,endpointName:l});return p(T=>C(T,E)??st,Q)}}function S(l,d){return A(l,d,D)}function o(l,d){let{infiniteQueryOptions:Q}=d;function b(E){let k={...E,...Fe(E.status)},{isLoading:T,isError:u,direction:n}=k,r=n==="forward",a=n==="backward";return{...k,hasNextPage:s(Q,k.data,k.originalArgs),hasPreviousPage:x(Q,k.data,k.originalArgs),isFetchingNextPage:T&&r,isFetchingPreviousPage:T&&a,isFetchNextPageError:u&&r,isFetchPreviousPageError:u&&a}}return A(l,d,b)}function g(){return l=>{let d;return typeof l=="object"?d=se(l)??Ae:d=l,p(d===Ae?y:E=>h(E)?.mutations?.[d]??ut,D)}}function M(l,d){let Q=l[t],b=new Set;for(let E of d.filter(re).map(be)){let k=Q.provided.tags[E.type];if(!k)continue;let T=(E.id!==void 0?k[E.id]:ve(Object.values(k)))??[];for(let u of T)b.add(u)}return ve(Array.from(b.values()).map(E=>{let k=Q.queries[E];return k?[{queryCacheKey:E,endpointName:k.endpointName,originalArgs:k.originalArgs}]:[]}))}function c(l,d){return Object.values(B(l)).filter(Q=>Q?.endpointName===d&&Q.status!=="uninitialized").map(Q=>Q.originalArgs)}function s(l,d,Q){return d?Ee(l,d,Q)!=null:!1}function x(l,d,Q){return!d||!l.getPreviousPageParam?!1:Ne(l,d,Q)!=null}}var ct=require("@reduxjs/toolkit");var pt=WeakMap?new WeakMap:void 0,Re=({endpointName:e,queryArgs:t})=>{let p="",m=pt?.get(t);if(typeof m=="string")p=m;else{let y=JSON.stringify(t,(D,h)=>(h=typeof h=="bigint"?{$bigint:h.toString()}:h,h=(0,i.isPlainObject)(h)?Object.keys(h).sort().reduce((B,C)=>(B[C]=h[C],B),{}):h,h));(0,i.isPlainObject)(t)&&pt?.set(t,y),p=y}return`${e}(${p})`};var qe=require("reselect");function Me(...e){return function(p){let m=(0,qe.weakMapMemoize)(R=>p.extractRehydrationInfo?.(R,{reducerPath:p.reducerPath??"api"})),y={reducerPath:"api",keepUnusedDataFor:60,refetchOnMountOrArgChange:!1,refetchOnFocus:!1,refetchOnReconnect:!1,invalidationBehavior:"delayed",...p,extractRehydrationInfo:m,serializeQueryArgs(R){let I=Re;if("serializeQueryArgs"in R.endpointDefinition){let A=R.endpointDefinition.serializeQueryArgs;I=S=>{let o=A(S);return typeof o=="string"?o:Re({...S,queryArgs:o})}}else p.serializeQueryArgs&&(I=p.serializeQueryArgs);return I(R)},tagTypes:[...p.tagTypes||[]]},D={endpointDefinitions:{},batch(R){R()},apiUid:(0,i.nanoid)(),extractRehydrationInfo:m,hasRehydrationInfo:(0,qe.weakMapMemoize)(R=>m(R)!=null)},h={injectEndpoints:C,enhanceEndpoints({addTagTypes:R,endpoints:I}){if(R)for(let A of R)y.tagTypes.includes(A)||y.tagTypes.push(A);if(I)for(let[A,S]of Object.entries(I))typeof S=="function"?S(D.endpointDefinitions[A]):Object.assign(D.endpointDefinitions[A]||{},S);return h}},B=e.map(R=>R.init(h,y,D));function C(R){let I=R.endpoints({query:A=>({...A,type:"query"}),mutation:A=>({...A,type:"mutation"}),infiniteQuery:A=>({...A,type:"infinitequery"})});for(let[A,S]of Object.entries(I)){if(R.overrideExisting!==!0&&A in D.endpointDefinitions){if(R.overrideExisting==="throw")throw new Error((0,ct.formatProdErrorMessage)(39));typeof process<"u";continue}typeof process<"u",D.endpointDefinitions[A]=S;for(let o of B)o.injectEndpoint(A,S)}return h}return h.injectEndpoints({endpoints:p.endpoints})}}var lt=require("@reduxjs/toolkit"),ft=Symbol();function mt(){return function(){throw new Error((0,lt.formatProdErrorMessage)(33))}}var Pt=require("immer");function Y(e,...t){return Object.assign(e,...t)}var gt=require("immer");var Qt=({api:e,queryThunk:t,internalState:p})=>{let m=`${e.reducerPath}/subscriptions`,y=null,D=null,{updateSubscriptionOptions:h,unsubscribeQueryResult:B}=e.internalActions,C=(o,g)=>{if(h.match(g)){let{queryCacheKey:c,requestId:s,options:x}=g.payload;return o?.[c]?.[s]&&(o[c][s]=x),!0}if(B.match(g)){let{queryCacheKey:c,requestId:s}=g.payload;return o[c]&&delete o[c][s],!0}if(e.internalActions.removeQueryResult.match(g))return delete o[g.payload.queryCacheKey],!0;if(t.pending.match(g)){let{meta:{arg:c,requestId:s}}=g,x=o[c.queryCacheKey]??={};return x[`${s}_running`]={},c.subscribe&&(x[s]=c.subscriptionOptions??x[s]??{}),!0}let M=!1;if(t.fulfilled.match(g)||t.rejected.match(g)){let c=o[g.meta.arg.queryCacheKey]||{},s=`${g.meta.requestId}_running`;M||=!!c[s],delete c[s]}if(t.rejected.match(g)){let{meta:{condition:c,arg:s,requestId:x}}=g;if(c&&s.subscribe){let l=o[s.queryCacheKey]??={};l[x]=s.subscriptionOptions??l[x]??{},M=!0}}return M},R=()=>p.currentSubscriptions,S={getSubscriptions:R,getSubscriptionCount:o=>{let M=R()[o]??{};return J(M)},isRequestSubscribed:(o,g)=>!!R()?.[o]?.[g]};return(o,g)=>{if(y||(y=JSON.parse(JSON.stringify(p.currentSubscriptions))),e.util.resetApiState.match(o))return y=p.currentSubscriptions={},D=null,[!0,!1];if(e.internalActions.internal_getRTKQSubscriptions.match(o))return[!1,S];let M=C(p.currentSubscriptions,o),c=!0;if(M){D||(D=setTimeout(()=>{let l=JSON.parse(JSON.stringify(p.currentSubscriptions)),[,d]=(0,gt.produceWithPatches)(y,()=>l);g.next(e.internalActions.subscriptionsUpdated(d)),y=l,D=null},500));let s=typeof o.type=="string"&&!!o.type.startsWith(m),x=t.rejected.match(o)&&o.meta.condition&&!!o.meta.arg.subscribe;c=!s&&!x}return[c,!1]}};function Vt(e){for(let t in e)return!1;return!0}var zt=2147483647/1e3-1,Tt=({reducerPath:e,api:t,queryThunk:p,context:m,internalState:y,selectors:{selectQueryEntry:D,selectConfig:h}})=>{let{removeQueryResult:B,unsubscribeQueryResult:C,cacheEntriesUpserted:R}=t.internalActions,I=(0,i.isAnyOf)(C.match,p.fulfilled,p.rejected,R.match);function A(c){let s=y.currentSubscriptions[c];return!!s&&!Vt(s)}let S={},o=(c,s,x)=>{let l=s.getState(),d=h(l);if(I(c)){let Q;if(R.match(c))Q=c.payload.map(b=>b.queryDescription.queryCacheKey);else{let{queryCacheKey:b}=C.match(c)?c.payload:c.meta.arg;Q=[b]}g(Q,s,d)}if(t.util.resetApiState.match(c))for(let[Q,b]of Object.entries(S))b&&clearTimeout(b),delete S[Q];if(m.hasRehydrationInfo(c)){let{queries:Q}=m.extractRehydrationInfo(c);g(Object.keys(Q),s,d)}};function g(c,s,x){let l=s.getState();for(let d of c){let Q=D(l,d);M(d,Q?.endpointName,s,x)}}function M(c,s,x,l){let Q=m.endpointDefinitions[s]?.keepUnusedDataFor??l.keepUnusedDataFor;if(Q===1/0)return;let b=Math.max(0,Math.min(Q,zt));if(!A(c)){let E=S[c];E&&clearTimeout(E),S[c]=setTimeout(()=>{A(c)||x.dispatch(B({queryCacheKey:c})),delete S[c]},b*1e3)}}return o};var ht=new Error("Promise never resolved before cacheEntryRemoved."),At=({api:e,reducerPath:t,context:p,queryThunk:m,mutationThunk:y,internalState:D,selectors:{selectQueryEntry:h,selectApiState:B}})=>{let C=(0,i.isAsyncThunkAction)(m),R=(0,i.isAsyncThunkAction)(y),I=(0,i.isFulfilled)(m,y),A={};function S(s,x,l){let d=A[s];d?.valueResolved&&(d.valueResolved({data:x,meta:l}),delete d.valueResolved)}function o(s){let x=A[s];x&&(delete A[s],x.cacheEntryRemoved())}let g=(s,x,l)=>{let d=M(s);function Q(b,E,k,T){let u=h(l,E),n=h(x.getState(),E);!u&&n&&c(b,T,E,x,k)}if(m.pending.match(s))Q(s.meta.arg.endpointName,d,s.meta.requestId,s.meta.arg.originalArgs);else if(e.internalActions.cacheEntriesUpserted.match(s))for(let{queryDescription:b,value:E}of s.payload){let{endpointName:k,originalArgs:T,queryCacheKey:u}=b;Q(k,u,s.meta.requestId,T),S(u,E,{})}else if(y.pending.match(s))x.getState()[t].mutations[d]&&c(s.meta.arg.endpointName,s.meta.arg.originalArgs,d,x,s.meta.requestId);else if(I(s))S(d,s.payload,s.meta.baseQueryMeta);else if(e.internalActions.removeQueryResult.match(s)||e.internalActions.removeMutationResult.match(s))o(d);else if(e.util.resetApiState.match(s))for(let b of Object.keys(A))o(b)};function M(s){return C(s)?s.meta.arg.queryCacheKey:R(s)?s.meta.arg.fixedCacheKey??s.meta.requestId:e.internalActions.removeQueryResult.match(s)?s.payload.queryCacheKey:e.internalActions.removeMutationResult.match(s)?se(s.payload):""}function c(s,x,l,d,Q){let b=p.endpointDefinitions[s],E=b?.onCacheEntryAdded;if(!E)return;let k={},T=new Promise(P=>{k.cacheEntryRemoved=P}),u=Promise.race([new Promise(P=>{k.valueResolved=P}),T.then(()=>{throw ht})]);u.catch(()=>{}),A[l]=k;let n=e.endpoints[s].select(le(b)?x:l),r=d.dispatch((P,O,N)=>N),a={...d,getCacheEntry:()=>n(d.getState()),requestId:Q,extra:r,updateCachedData:le(b)?P=>d.dispatch(e.util.updateQueryData(s,x,P)):void 0,cacheDataLoaded:u,cacheEntryRemoved:T},f=E(x,a);Promise.resolve(f).catch(P=>{if(P!==ht)throw P})}return g};var Rt=({api:e,context:{apiUid:t},reducerPath:p})=>(m,y)=>{e.util.resetApiState.match(m)&&y.dispatch(e.internalActions.middlewareRegistered(t)),typeof process<"u"};var St=({reducerPath:e,context:t,context:{endpointDefinitions:p},mutationThunk:m,queryThunk:y,api:D,assertTagType:h,refetchQuery:B,internalState:C})=>{let{removeQueryResult:R}=D.internalActions,I=(0,i.isAnyOf)((0,i.isFulfilled)(m),(0,i.isRejectedWithValue)(m)),A=(0,i.isAnyOf)((0,i.isFulfilled)(m,y),(0,i.isRejected)(m,y)),S=[],o=(c,s)=>{I(c)?M(Ie(c,"invalidatesTags",p,h),s):A(c)?M([],s):D.util.invalidateTags.match(c)&&M(ge(c.payload,void 0,void 0,void 0,void 0,h),s)};function g(c){let{queries:s,mutations:x}=c;for(let l of[s,x])for(let d in l)if(l[d]?.status==="pending")return!0;return!1}function M(c,s){let x=s.getState(),l=x[e];if(S.push(...c),l.config.invalidationBehavior==="delayed"&&g(l))return;let d=S;if(S=[],d.length===0)return;let Q=D.util.selectInvalidatedBy(x,d);t.batch(()=>{let b=Array.from(Q.values());for(let{queryCacheKey:E}of b){let k=l.queries[E],T=C.currentSubscriptions[E]??{};k&&(J(T)===0?s.dispatch(R({queryCacheKey:E})):k.status!=="uninitialized"&&s.dispatch(B(k)))}})}return o};var xt=({reducerPath:e,queryThunk:t,api:p,refetchQuery:m,internalState:y})=>{let D={},h=(o,g)=>{(p.internalActions.updateSubscriptionOptions.match(o)||p.internalActions.unsubscribeQueryResult.match(o))&&R(o.payload,g),(t.pending.match(o)||t.rejected.match(o)&&o.meta.condition)&&R(o.meta.arg,g),(t.fulfilled.match(o)||t.rejected.match(o)&&!o.meta.condition)&&C(o.meta.arg,g),p.util.resetApiState.match(o)&&A()};function B(o,g){let c=g.getState()[e].queries[o],s=y.currentSubscriptions[o];if(!(!c||c.status==="uninitialized"))return s}function C({queryCacheKey:o},g){let M=g.getState()[e],c=M.queries[o],s=y.currentSubscriptions[o];if(!c||c.status==="uninitialized")return;let{lowestPollingInterval:x,skipPollingIfUnfocused:l}=S(s);if(!Number.isFinite(x))return;let d=D[o];d?.timeout&&(clearTimeout(d.timeout),d.timeout=void 0);let Q=Date.now()+x;D[o]={nextPollTimestamp:Q,pollingInterval:x,timeout:setTimeout(()=>{(M.config.focused||!l)&&g.dispatch(m(c)),C({queryCacheKey:o},g)},x)}}function R({queryCacheKey:o},g){let c=g.getState()[e].queries[o],s=y.currentSubscriptions[o];if(!c||c.status==="uninitialized")return;let{lowestPollingInterval:x}=S(s);if(!Number.isFinite(x)){I(o);return}let l=D[o],d=Date.now()+x;(!l||d<l.nextPollTimestamp)&&C({queryCacheKey:o},g)}function I(o){let g=D[o];g?.timeout&&clearTimeout(g.timeout),delete D[o]}function A(){for(let o of Object.keys(D))I(o)}function S(o={}){let g=!1,M=Number.POSITIVE_INFINITY;for(let c in o)o[c].pollingInterval&&(M=Math.min(o[c].pollingInterval,M),g=o[c].skipPollingIfUnfocused||g);return{lowestPollingInterval:M,skipPollingIfUnfocused:g}}return h};var Dt=({api:e,context:t,queryThunk:p,mutationThunk:m})=>{let y=(0,i.isPending)(p,m),D=(0,i.isRejected)(p,m),h=(0,i.isFulfilled)(p,m),B={};return(R,I)=>{if(y(R)){let{requestId:A,arg:{endpointName:S,originalArgs:o}}=R.meta,g=t.endpointDefinitions[S],M=g?.onQueryStarted;if(M){let c={},s=new Promise((Q,b)=>{c.resolve=Q,c.reject=b});s.catch(()=>{}),B[A]=c;let x=e.endpoints[S].select(le(g)?o:A),l=I.dispatch((Q,b,E)=>E),d={...I,getCacheEntry:()=>x(I.getState()),requestId:A,extra:l,updateCachedData:le(g)?Q=>I.dispatch(e.util.updateQueryData(S,o,Q)):void 0,queryFulfilled:s};M(o,d)}}else if(h(R)){let{requestId:A,baseQueryMeta:S}=R.meta;B[A]?.resolve({data:R.payload,meta:S}),delete B[A]}else if(D(R)){let{requestId:A,rejectedWithValue:S,baseQueryMeta:o}=R.meta;B[A]?.reject({error:R.payload??R.error,isUnhandledError:!S,meta:o}),delete B[A]}}};var bt=({reducerPath:e,context:t,api:p,refetchQuery:m,internalState:y})=>{let{removeQueryResult:D}=p.internalActions,h=(C,R)=>{ee.match(C)&&B(R,"refetchOnFocus"),te.match(C)&&B(R,"refetchOnReconnect")};function B(C,R){let I=C.getState()[e],A=I.queries,S=y.currentSubscriptions;t.batch(()=>{for(let o of Object.keys(S)){let g=A[o],M=S[o];if(!M||!g)continue;(Object.values(M).some(s=>s[R]===!0)||Object.values(M).every(s=>s[R]===void 0)&&I.config[R])&&(J(M)===0?C.dispatch(D({queryCacheKey:o})):g.status!=="uninitialized"&&C.dispatch(m(g)))}})}return h};function Et(e){let{reducerPath:t,queryThunk:p,api:m,context:y}=e,{apiUid:D}=y,h={invalidateTags:(0,i.createAction)(`${t}/invalidateTags`)},B=A=>A.type.startsWith(`${t}/`),C=[Rt,Tt,St,xt,At,Dt];return{middleware:A=>{let S=!1,g={...e,internalState:{currentSubscriptions:{}},refetchQuery:I,isThisApiSliceAction:B},M=C.map(x=>x(g)),c=Qt(g),s=bt(g);return x=>l=>{if(!(0,i.isAction)(l))return x(l);S||(S=!0,A.dispatch(m.internalActions.middlewareRegistered(D)));let d={...A,next:x},Q=A.getState(),[b,E]=c(l,d,Q),k;if(b?k=x(l):k=E,A.getState()[t]&&(s(l,d,Q),B(l)||y.hasRehydrationInfo(l)))for(let T of M)T(l,d,Q);return k}},actions:h};function I(A){return e.api.endpoints[A.endpointName].initiate(A.originalArgs,{subscribe:!1,forceRefetch:!0})}}var Se=Symbol(),we=({createSelector:e=i.createSelector}={})=>({name:Se,init(t,{baseQuery:p,tagTypes:m,reducerPath:y,serializeQueryArgs:D,keepUnusedDataFor:h,refetchOnMountOrArgChange:B,refetchOnFocus:C,refetchOnReconnect:R,invalidationBehavior:I,onSchemaFailure:A,catchSchemaFailure:S,skipSchemaValidation:o},g){(0,Pt.enablePatches)();let M=v=>(typeof process<"u",v);Object.assign(t,{reducerPath:y,endpoints:{},internalActions:{onOnline:te,onOffline:ce,onFocus:ee,onFocusLost:pe},util:{}});let c=dt({serializeQueryArgs:D,reducerPath:y,createSelector:e}),{selectInvalidatedBy:s,selectCachedArgsForQuery:x,buildQuerySelector:l,buildInfiniteQuerySelector:d,buildMutationSelector:Q}=c;Y(t.util,{selectInvalidatedBy:s,selectCachedArgsForQuery:x});let{queryThunk:b,infiniteQueryThunk:E,mutationThunk:k,patchQueryData:T,updateQueryData:u,upsertQueryData:n,prefetch:r,buildMatchThunkActions:a}=rt({baseQuery:p,reducerPath:y,context:g,api:t,serializeQueryArgs:D,assertTagType:M,selectors:c,onSchemaFailure:A,catchSchemaFailure:S,skipSchemaValidation:o}),{reducer:f,actions:P}=ot({context:g,queryThunk:b,infiniteQueryThunk:E,mutationThunk:k,serializeQueryArgs:D,reducerPath:y,assertTagType:M,config:{refetchOnFocus:C,refetchOnReconnect:R,refetchOnMountOrArgChange:B,keepUnusedDataFor:h,reducerPath:y,invalidationBehavior:I}});Y(t.util,{patchQueryData:T,updateQueryData:u,upsertQueryData:n,prefetch:r,resetApiState:P.resetApiState,upsertQueryEntries:P.cacheEntriesUpserted}),Y(t.internalActions,P);let{middleware:O,actions:N}=Et({reducerPath:y,context:g,queryThunk:b,mutationThunk:k,infiniteQueryThunk:E,api:t,assertTagType:M,selectors:c});Y(t.util,N),Y(t,{reducer:f,middleware:O});let{buildInitiateQuery:F,buildInitiateInfiniteQuery:w,buildInitiateMutation:U,getRunningMutationThunk:H,getRunningMutationsThunk:W,getRunningQueriesThunk:j,getRunningQueryThunk:q}=tt({queryThunk:b,mutationThunk:k,infiniteQueryThunk:E,api:t,serializeQueryArgs:D,context:g});return Y(t.util,{getRunningMutationThunk:H,getRunningMutationsThunk:W,getRunningQueryThunk:q,getRunningQueriesThunk:j}),{name:Se,injectEndpoint(v,V){let _=t,K=_.endpoints[v]??={};ie(V)&&Y(K,{name:v,select:l(v,V),initiate:F(v,V)},a(b,v)),Ze(V)&&Y(K,{name:v,select:Q(),initiate:U(v)},a(k,v)),ae(V)&&Y(K,{name:v,select:d(v,V),initiate:w(v,V)},a(b,v))}}}});var It=Me(we());0&&(module.exports={NamedSchemaError,QueryStatus,_NEVER,buildCreateApi,copyWithStructuralSharing,coreModule,coreModuleName,createApi,defaultSerializeQueryArgs,fakeBaseQuery,fetchBaseQuery,retry,setupListeners,skipToken});
+//# sourceMappingURL=rtk-query.production.min.cjs.map

frontend/node_modules/@reduxjs/toolkit/dist/query/react/cjs/index.js

@@ -0,0 +1,6 @@
+'use strict'
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./rtk-query-react.production.min.cjs')
+} else {
+  module.exports = require('./rtk-query-react.development.cjs')
+}

frontend/node_modules/@reduxjs/toolkit/dist/query/react/cjs/rtk-query-react.development.cjs

@@ -0,0 +1,759 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/query/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  ApiProvider: () => ApiProvider,
+  UNINITIALIZED_VALUE: () => UNINITIALIZED_VALUE,
+  createApi: () => createApi,
+  reactHooksModule: () => reactHooksModule,
+  reactHooksModuleName: () => reactHooksModuleName
+});
+module.exports = __toCommonJS(react_exports);
+var import_query3 = require("@reduxjs/toolkit/query");
+
+// src/query/react/module.ts
+var import_toolkit2 = require("@reduxjs/toolkit");
+var import_react_redux3 = require("react-redux");
+var import_reselect = require("reselect");
+
+// src/query/utils/capitalize.ts
+function capitalize(str) {
+  return str.replace(str[0], str[0].toUpperCase());
+}
+
+// src/query/utils/countObjectKeys.ts
+function countObjectKeys(obj) {
+  let count = 0;
+  for (const _key in obj) {
+    count++;
+  }
+  return count;
+}
+
+// src/query/endpointDefinitions.ts
+function isQueryDefinition(e) {
+  return e.type === "query" /* query */;
+}
+function isMutationDefinition(e) {
+  return e.type === "mutation" /* mutation */;
+}
+function isInfiniteQueryDefinition(e) {
+  return e.type === "infinitequery" /* infinitequery */;
+}
+
+// src/query/tsHelpers.ts
+function safeAssign(target, ...args) {
+  return Object.assign(target, ...args);
+}
+
+// src/query/react/buildHooks.ts
+var import_toolkit = require("@reduxjs/toolkit");
+var import_query = require("@reduxjs/toolkit/query");
+var import_react3 = require("react");
+var import_react_redux2 = require("react-redux");
+
+// src/query/react/constants.ts
+var UNINITIALIZED_VALUE = Symbol();
+
+// src/query/react/useSerializedStableValue.ts
+var import_react = require("react");
+function useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {
+  const incoming = (0, import_react.useMemo)(() => ({
+    queryArgs,
+    serialized: typeof queryArgs == "object" ? serialize({
+      queryArgs,
+      endpointDefinition,
+      endpointName
+    }) : queryArgs
+  }), [queryArgs, serialize, endpointDefinition, endpointName]);
+  const cache = (0, import_react.useRef)(incoming);
+  (0, import_react.useEffect)(() => {
+    if (cache.current.serialized !== incoming.serialized) {
+      cache.current = incoming;
+    }
+  }, [incoming]);
+  return cache.current.serialized === incoming.serialized ? cache.current.queryArgs : queryArgs;
+}
+
+// src/query/react/useShallowStableValue.ts
+var import_react2 = require("react");
+var import_react_redux = require("react-redux");
+function useShallowStableValue(value) {
+  const cache = (0, import_react2.useRef)(value);
+  (0, import_react2.useEffect)(() => {
+    if (!(0, import_react_redux.shallowEqual)(cache.current, value)) {
+      cache.current = value;
+    }
+  }, [value]);
+  return (0, import_react_redux.shallowEqual)(cache.current, value) ? cache.current : value;
+}
+
+// src/query/react/buildHooks.ts
+var canUseDOM = () => !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+var isDOM = /* @__PURE__ */ canUseDOM();
+var isRunningInReactNative = () => typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var isReactNative = /* @__PURE__ */ isRunningInReactNative();
+var getUseIsomorphicLayoutEffect = () => isDOM || isReactNative ? import_react3.useLayoutEffect : import_react3.useEffect;
+var useIsomorphicLayoutEffect = /* @__PURE__ */ getUseIsomorphicLayoutEffect();
+var noPendingQueryStateSelector = (selected) => {
+  if (selected.isUninitialized) {
+    return {
+      ...selected,
+      isUninitialized: false,
+      isFetching: true,
+      isLoading: selected.data !== void 0 ? false : true,
+      status: import_query.QueryStatus.pending
+    };
+  }
+  return selected;
+};
+function pick(obj, ...keys) {
+  const ret = {};
+  keys.forEach((key) => {
+    ret[key] = obj[key];
+  });
+  return ret;
+}
+var COMMON_HOOK_DEBUG_FIELDS = ["data", "status", "isLoading", "isSuccess", "isError", "error"];
+function buildHooks({
+  api,
+  moduleOptions: {
+    batch,
+    hooks: {
+      useDispatch,
+      useSelector,
+      useStore
+    },
+    unstable__sideEffectsInRender,
+    createSelector
+  },
+  serializeQueryArgs,
+  context
+}) {
+  const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : import_react3.useEffect;
+  return {
+    buildQueryHooks,
+    buildInfiniteQueryHooks,
+    buildMutationHook,
+    usePrefetch
+  };
+  function queryStatePreSelector(currentState, lastResult, queryArgs) {
+    if (lastResult?.endpointName && currentState.isUninitialized) {
+      const {
+        endpointName
+      } = lastResult;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      if (queryArgs !== import_query.skipToken && serializeQueryArgs({
+        queryArgs: lastResult.originalArgs,
+        endpointDefinition,
+        endpointName
+      }) === serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      })) lastResult = void 0;
+    }
+    let data = currentState.isSuccess ? currentState.data : lastResult?.data;
+    if (data === void 0) data = currentState.data;
+    const hasData = data !== void 0;
+    const isFetching = currentState.isLoading;
+    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
+    const isSuccess = currentState.isSuccess || hasData && (isFetching && !lastResult?.isError || currentState.isUninitialized);
+    return {
+      ...currentState,
+      data,
+      currentData: currentState.data,
+      isFetching,
+      isLoading,
+      isSuccess
+    };
+  }
+  function infiniteQueryStatePreSelector(currentState, lastResult, queryArgs) {
+    if (lastResult?.endpointName && currentState.isUninitialized) {
+      const {
+        endpointName
+      } = lastResult;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      if (queryArgs !== import_query.skipToken && serializeQueryArgs({
+        queryArgs: lastResult.originalArgs,
+        endpointDefinition,
+        endpointName
+      }) === serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      })) lastResult = void 0;
+    }
+    let data = currentState.isSuccess ? currentState.data : lastResult?.data;
+    if (data === void 0) data = currentState.data;
+    const hasData = data !== void 0;
+    const isFetching = currentState.isLoading;
+    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
+    const isSuccess = currentState.isSuccess || isFetching && hasData;
+    return {
+      ...currentState,
+      data,
+      currentData: currentState.data,
+      isFetching,
+      isLoading,
+      isSuccess
+    };
+  }
+  function usePrefetch(endpointName, defaultOptions) {
+    const dispatch = useDispatch();
+    const stableDefaultOptions = useShallowStableValue(defaultOptions);
+    return (0, import_react3.useCallback)((arg, options) => dispatch(api.util.prefetch(endpointName, arg, {
+      ...stableDefaultOptions,
+      ...options
+    })), [endpointName, dispatch, stableDefaultOptions]);
+  }
+  function useQuerySubscriptionCommonImpl(endpointName, arg, {
+    refetchOnReconnect,
+    refetchOnFocus,
+    refetchOnMountOrArgChange,
+    skip = false,
+    pollingInterval = 0,
+    skipPollingIfUnfocused = false,
+    ...rest
+  } = {}) {
+    const {
+      initiate
+    } = api.endpoints[endpointName];
+    const dispatch = useDispatch();
+    const subscriptionSelectorsRef = (0, import_react3.useRef)(void 0);
+    if (!subscriptionSelectorsRef.current) {
+      const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());
+      if (true) {
+        if (typeof returnedValue !== "object" || typeof returnedValue?.type === "string") {
+          throw new Error(false ? _formatProdErrorMessage(37) : `Warning: Middleware for RTK-Query API at reducerPath "${api.reducerPath}" has not been added to the store.
+    You must add the middleware for RTK-Query to function correctly!`);
+        }
+      }
+      subscriptionSelectorsRef.current = returnedValue;
+    }
+    const stableArg = useStableQueryArgs(
+      skip ? import_query.skipToken : arg,
+      // Even if the user provided a per-endpoint `serializeQueryArgs` with
+      // a consistent return value, _here_ we want to use the default behavior
+      // so we can tell if _anything_ actually changed. Otherwise, we can end up
+      // with a case where the query args did change but the serialization doesn't,
+      // and then we never try to initiate a refetch.
+      import_query.defaultSerializeQueryArgs,
+      context.endpointDefinitions[endpointName],
+      endpointName
+    );
+    const stableSubscriptionOptions = useShallowStableValue({
+      refetchOnReconnect,
+      refetchOnFocus,
+      pollingInterval,
+      skipPollingIfUnfocused
+    });
+    const initialPageParam = rest.initialPageParam;
+    const stableInitialPageParam = useShallowStableValue(initialPageParam);
+    const promiseRef = (0, import_react3.useRef)(void 0);
+    let {
+      queryCacheKey,
+      requestId
+    } = promiseRef.current || {};
+    let currentRenderHasSubscription = false;
+    if (queryCacheKey && requestId) {
+      currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);
+    }
+    const subscriptionRemoved = !currentRenderHasSubscription && promiseRef.current !== void 0;
+    usePossiblyImmediateEffect(() => {
+      if (subscriptionRemoved) {
+        promiseRef.current = void 0;
+      }
+    }, [subscriptionRemoved]);
+    usePossiblyImmediateEffect(() => {
+      const lastPromise = promiseRef.current;
+      if (typeof process !== "undefined" && false) {
+        console.log(subscriptionRemoved);
+      }
+      if (stableArg === import_query.skipToken) {
+        lastPromise?.unsubscribe();
+        promiseRef.current = void 0;
+        return;
+      }
+      const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;
+      if (!lastPromise || lastPromise.arg !== stableArg) {
+        lastPromise?.unsubscribe();
+        const promise = dispatch(initiate(stableArg, {
+          subscriptionOptions: stableSubscriptionOptions,
+          forceRefetch: refetchOnMountOrArgChange,
+          ...isInfiniteQueryDefinition(context.endpointDefinitions[endpointName]) ? {
+            initialPageParam: stableInitialPageParam
+          } : {}
+        }));
+        promiseRef.current = promise;
+      } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+        lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);
+      }
+    }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved, stableInitialPageParam, endpointName]);
+    return [promiseRef, dispatch, initiate, stableSubscriptionOptions];
+  }
+  function buildUseQueryState(endpointName, preSelector) {
+    const useQueryState = (arg, {
+      skip = false,
+      selectFromResult
+    } = {}) => {
+      const {
+        select
+      } = api.endpoints[endpointName];
+      const stableArg = useStableQueryArgs(skip ? import_query.skipToken : arg, serializeQueryArgs, context.endpointDefinitions[endpointName], endpointName);
+      const lastValue = (0, import_react3.useRef)(void 0);
+      const selectDefaultResult = (0, import_react3.useMemo)(() => (
+        // Normally ts-ignores are bad and should be avoided, but we're
+        // already casting this selector to be `Selector<any>` anyway,
+        // so the inconsistencies don't matter here
+        // @ts-ignore
+        createSelector([
+          // @ts-ignore
+          select(stableArg),
+          (_, lastResult) => lastResult,
+          (_) => stableArg
+        ], preSelector, {
+          memoizeOptions: {
+            resultEqualityCheck: import_react_redux2.shallowEqual
+          }
+        })
+      ), [select, stableArg]);
+      const querySelector = (0, import_react3.useMemo)(() => selectFromResult ? createSelector([selectDefaultResult], selectFromResult, {
+        devModeChecks: {
+          identityFunctionCheck: "never"
+        }
+      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);
+      const currentState = useSelector((state) => querySelector(state, lastValue.current), import_react_redux2.shallowEqual);
+      const store = useStore();
+      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);
+      useIsomorphicLayoutEffect(() => {
+        lastValue.current = newLastValue;
+      }, [newLastValue]);
+      return currentState;
+    };
+    return useQueryState;
+  }
+  function usePromiseRefUnsubscribeOnUnmount(promiseRef) {
+    (0, import_react3.useEffect)(() => {
+      return () => {
+        promiseRef.current?.unsubscribe?.();
+        promiseRef.current = void 0;
+      };
+    }, [promiseRef]);
+  }
+  function refetchOrErrorIfUnmounted(promiseRef) {
+    if (!promiseRef.current) throw new Error(false ? _formatProdErrorMessage2(38) : "Cannot refetch a query that has not been started yet.");
+    return promiseRef.current.refetch();
+  }
+  function buildQueryHooks(endpointName) {
+    const useQuerySubscription = (arg, options = {}) => {
+      const [promiseRef] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
+      usePromiseRefUnsubscribeOnUnmount(promiseRef);
+      return (0, import_react3.useMemo)(() => ({
+        /**
+         * A method to manually refetch data for the query
+         */
+        refetch: () => refetchOrErrorIfUnmounted(promiseRef)
+      }), [promiseRef]);
+    };
+    const useLazyQuerySubscription = ({
+      refetchOnReconnect,
+      refetchOnFocus,
+      pollingInterval = 0,
+      skipPollingIfUnfocused = false
+    } = {}) => {
+      const {
+        initiate
+      } = api.endpoints[endpointName];
+      const dispatch = useDispatch();
+      const [arg, setArg] = (0, import_react3.useState)(UNINITIALIZED_VALUE);
+      const promiseRef = (0, import_react3.useRef)(void 0);
+      const stableSubscriptionOptions = useShallowStableValue({
+        refetchOnReconnect,
+        refetchOnFocus,
+        pollingInterval,
+        skipPollingIfUnfocused
+      });
+      usePossiblyImmediateEffect(() => {
+        const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;
+        if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+          promiseRef.current?.updateSubscriptionOptions(stableSubscriptionOptions);
+        }
+      }, [stableSubscriptionOptions]);
+      const subscriptionOptionsRef = (0, import_react3.useRef)(stableSubscriptionOptions);
+      usePossiblyImmediateEffect(() => {
+        subscriptionOptionsRef.current = stableSubscriptionOptions;
+      }, [stableSubscriptionOptions]);
+      const trigger = (0, import_react3.useCallback)(function(arg2, preferCacheValue = false) {
+        let promise;
+        batch(() => {
+          promiseRef.current?.unsubscribe();
+          promiseRef.current = promise = dispatch(initiate(arg2, {
+            subscriptionOptions: subscriptionOptionsRef.current,
+            forceRefetch: !preferCacheValue
+          }));
+          setArg(arg2);
+        });
+        return promise;
+      }, [dispatch, initiate]);
+      const reset = (0, import_react3.useCallback)(() => {
+        if (promiseRef.current?.queryCacheKey) {
+          dispatch(api.internalActions.removeQueryResult({
+            queryCacheKey: promiseRef.current?.queryCacheKey
+          }));
+        }
+      }, [dispatch]);
+      (0, import_react3.useEffect)(() => {
+        return () => {
+          promiseRef?.current?.unsubscribe();
+        };
+      }, []);
+      (0, import_react3.useEffect)(() => {
+        if (arg !== UNINITIALIZED_VALUE && !promiseRef.current) {
+          trigger(arg, true);
+        }
+      }, [arg, trigger]);
+      return (0, import_react3.useMemo)(() => [trigger, arg, {
+        reset
+      }], [trigger, arg, reset]);
+    };
+    const useQueryState = buildUseQueryState(endpointName, queryStatePreSelector);
+    return {
+      useQueryState,
+      useQuerySubscription,
+      useLazyQuerySubscription,
+      useLazyQuery(options) {
+        const [trigger, arg, {
+          reset
+        }] = useLazyQuerySubscription(options);
+        const queryStateResults = useQueryState(arg, {
+          ...options,
+          skip: arg === UNINITIALIZED_VALUE
+        });
+        const info = (0, import_react3.useMemo)(() => ({
+          lastArg: arg
+        }), [arg]);
+        return (0, import_react3.useMemo)(() => [trigger, {
+          ...queryStateResults,
+          reset
+        }, info], [trigger, queryStateResults, reset, info]);
+      },
+      useQuery(arg, options) {
+        const querySubscriptionResults = useQuerySubscription(arg, options);
+        const queryStateResults = useQueryState(arg, {
+          selectFromResult: arg === import_query.skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,
+          ...options
+        });
+        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS);
+        (0, import_react3.useDebugValue)(debugValue);
+        return (0, import_react3.useMemo)(() => ({
+          ...queryStateResults,
+          ...querySubscriptionResults
+        }), [queryStateResults, querySubscriptionResults]);
+      }
+    };
+  }
+  function buildInfiniteQueryHooks(endpointName) {
+    const useInfiniteQuerySubscription = (arg, options = {}) => {
+      const [promiseRef, dispatch, initiate, stableSubscriptionOptions] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
+      const subscriptionOptionsRef = (0, import_react3.useRef)(stableSubscriptionOptions);
+      usePossiblyImmediateEffect(() => {
+        subscriptionOptionsRef.current = stableSubscriptionOptions;
+      }, [stableSubscriptionOptions]);
+      const trigger = (0, import_react3.useCallback)(function(arg2, direction) {
+        let promise;
+        batch(() => {
+          promiseRef.current?.unsubscribe();
+          promiseRef.current = promise = dispatch(initiate(arg2, {
+            subscriptionOptions: subscriptionOptionsRef.current,
+            direction
+          }));
+        });
+        return promise;
+      }, [promiseRef, dispatch, initiate]);
+      usePromiseRefUnsubscribeOnUnmount(promiseRef);
+      const stableArg = useStableQueryArgs(
+        options.skip ? import_query.skipToken : arg,
+        // Even if the user provided a per-endpoint `serializeQueryArgs` with
+        // a consistent return value, _here_ we want to use the default behavior
+        // so we can tell if _anything_ actually changed. Otherwise, we can end up
+        // with a case where the query args did change but the serialization doesn't,
+        // and then we never try to initiate a refetch.
+        import_query.defaultSerializeQueryArgs,
+        context.endpointDefinitions[endpointName],
+        endpointName
+      );
+      const refetch = (0, import_react3.useCallback)(() => refetchOrErrorIfUnmounted(promiseRef), [promiseRef]);
+      return (0, import_react3.useMemo)(() => {
+        const fetchNextPage = () => {
+          return trigger(stableArg, "forward");
+        };
+        const fetchPreviousPage = () => {
+          return trigger(stableArg, "backward");
+        };
+        return {
+          trigger,
+          /**
+           * A method to manually refetch data for the query
+           */
+          refetch,
+          fetchNextPage,
+          fetchPreviousPage
+        };
+      }, [refetch, trigger, stableArg]);
+    };
+    const useInfiniteQueryState = buildUseQueryState(endpointName, infiniteQueryStatePreSelector);
+    return {
+      useInfiniteQueryState,
+      useInfiniteQuerySubscription,
+      useInfiniteQuery(arg, options) {
+        const {
+          refetch,
+          fetchNextPage,
+          fetchPreviousPage
+        } = useInfiniteQuerySubscription(arg, options);
+        const queryStateResults = useInfiniteQueryState(arg, {
+          selectFromResult: arg === import_query.skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,
+          ...options
+        });
+        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS, "hasNextPage", "hasPreviousPage");
+        (0, import_react3.useDebugValue)(debugValue);
+        return (0, import_react3.useMemo)(() => ({
+          ...queryStateResults,
+          fetchNextPage,
+          fetchPreviousPage,
+          refetch
+        }), [queryStateResults, fetchNextPage, fetchPreviousPage, refetch]);
+      }
+    };
+  }
+  function buildMutationHook(name) {
+    return ({
+      selectFromResult,
+      fixedCacheKey
+    } = {}) => {
+      const {
+        select,
+        initiate
+      } = api.endpoints[name];
+      const dispatch = useDispatch();
+      const [promise, setPromise] = (0, import_react3.useState)();
+      (0, import_react3.useEffect)(() => () => {
+        if (!promise?.arg.fixedCacheKey) {
+          promise?.reset();
+        }
+      }, [promise]);
+      const triggerMutation = (0, import_react3.useCallback)(function(arg) {
+        const promise2 = dispatch(initiate(arg, {
+          fixedCacheKey
+        }));
+        setPromise(promise2);
+        return promise2;
+      }, [dispatch, initiate, fixedCacheKey]);
+      const {
+        requestId
+      } = promise || {};
+      const selectDefaultResult = (0, import_react3.useMemo)(() => select({
+        fixedCacheKey,
+        requestId: promise?.requestId
+      }), [fixedCacheKey, promise, select]);
+      const mutationSelector = (0, import_react3.useMemo)(() => selectFromResult ? createSelector([selectDefaultResult], selectFromResult) : selectDefaultResult, [selectFromResult, selectDefaultResult]);
+      const currentState = useSelector(mutationSelector, import_react_redux2.shallowEqual);
+      const originalArgs = fixedCacheKey == null ? promise?.arg.originalArgs : void 0;
+      const reset = (0, import_react3.useCallback)(() => {
+        batch(() => {
+          if (promise) {
+            setPromise(void 0);
+          }
+          if (fixedCacheKey) {
+            dispatch(api.internalActions.removeMutationResult({
+              requestId,
+              fixedCacheKey
+            }));
+          }
+        });
+      }, [dispatch, fixedCacheKey, promise, requestId]);
+      const debugValue = pick(currentState, ...COMMON_HOOK_DEBUG_FIELDS, "endpointName");
+      (0, import_react3.useDebugValue)(debugValue);
+      const finalState = (0, import_react3.useMemo)(() => ({
+        ...currentState,
+        originalArgs,
+        reset
+      }), [currentState, originalArgs, reset]);
+      return (0, import_react3.useMemo)(() => [triggerMutation, finalState], [triggerMutation, finalState]);
+    };
+  }
+}
+
+// src/query/react/module.ts
+var reactHooksModuleName = /* @__PURE__ */ Symbol();
+var reactHooksModule = ({
+  batch = import_react_redux3.batch,
+  hooks = {
+    useDispatch: import_react_redux3.useDispatch,
+    useSelector: import_react_redux3.useSelector,
+    useStore: import_react_redux3.useStore
+  },
+  createSelector = import_reselect.createSelector,
+  unstable__sideEffectsInRender = false,
+  ...rest
+} = {}) => {
+  if (true) {
+    const hookNames = ["useDispatch", "useSelector", "useStore"];
+    let warned = false;
+    for (const hookName of hookNames) {
+      if (countObjectKeys(rest) > 0) {
+        if (rest[hookName]) {
+          if (!warned) {
+            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 } })`");
+            warned = true;
+          }
+        }
+        hooks[hookName] = rest[hookName];
+      }
+      if (typeof hooks[hookName] !== "function") {
+        throw new Error(false ? _formatProdErrorMessage3(36) : `When using custom hooks for context, all ${hookNames.length} hooks need to be provided: ${hookNames.join(", ")}.
+Hook ${hookName} was either not provided or not a function.`);
+      }
+    }
+  }
+  return {
+    name: reactHooksModuleName,
+    init(api, {
+      serializeQueryArgs
+    }, context) {
+      const anyApi = api;
+      const {
+        buildQueryHooks,
+        buildInfiniteQueryHooks,
+        buildMutationHook,
+        usePrefetch
+      } = buildHooks({
+        api,
+        moduleOptions: {
+          batch,
+          hooks,
+          unstable__sideEffectsInRender,
+          createSelector
+        },
+        serializeQueryArgs,
+        context
+      });
+      safeAssign(anyApi, {
+        usePrefetch
+      });
+      safeAssign(context, {
+        batch
+      });
+      return {
+        injectEndpoint(endpointName, definition) {
+          if (isQueryDefinition(definition)) {
+            const {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription
+            } = buildQueryHooks(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription
+            });
+            api[`use${capitalize(endpointName)}Query`] = useQuery;
+            api[`useLazy${capitalize(endpointName)}Query`] = useLazyQuery;
+          }
+          if (isMutationDefinition(definition)) {
+            const useMutation = buildMutationHook(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useMutation
+            });
+            api[`use${capitalize(endpointName)}Mutation`] = useMutation;
+          } else if (isInfiniteQueryDefinition(definition)) {
+            const {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState
+            } = buildInfiniteQueryHooks(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState
+            });
+            api[`use${capitalize(endpointName)}InfiniteQuery`] = useInfiniteQuery;
+          }
+        }
+      };
+    }
+  };
+};
+
+// src/query/react/index.ts
+__reExport(react_exports, require("@reduxjs/toolkit/query"), module.exports);
+
+// src/query/react/ApiProvider.tsx
+var import_toolkit3 = require("@reduxjs/toolkit");
+var import_react4 = require("react");
+var import_react5 = require("react");
+var React = __toESM(require("react"));
+var import_react_redux4 = require("react-redux");
+var import_query2 = require("@reduxjs/toolkit/query");
+function ApiProvider(props) {
+  const context = props.context || import_react_redux4.ReactReduxContext;
+  const existingContext = (0, import_react4.useContext)(context);
+  if (existingContext) {
+    throw new Error(false ? _formatProdErrorMessage4(35) : "Existing Redux context detected. If you already have a store set up, please use the traditional Redux setup.");
+  }
+  const [store] = React.useState(() => (0, import_toolkit3.configureStore)({
+    reducer: {
+      [props.api.reducerPath]: props.api.reducer
+    },
+    middleware: (gDM) => gDM().concat(props.api.middleware)
+  }));
+  (0, import_react5.useEffect)(() => props.setupListeners === false ? void 0 : (0, import_query2.setupListeners)(store.dispatch, props.setupListeners), [props.setupListeners, store.dispatch]);
+  return /* @__PURE__ */ React.createElement(import_react_redux4.Provider, { store, context }, props.children);
+}
+
+// src/query/react/index.ts
+var createApi = /* @__PURE__ */ (0, import_query3.buildCreateApi)((0, import_query3.coreModule)(), reactHooksModule());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiProvider,
+  UNINITIALIZED_VALUE,
+  createApi,
+  reactHooksModule,
+  reactHooksModuleName,
+  ...require("@reduxjs/toolkit/query")
+});
+//# sourceMappingURL=rtk-query-react.development.cjs.map

frontend/node_modules/@reduxjs/toolkit/dist/query/react/cjs/rtk-query-react.production.min.cjs

@@ -0,0 +1,2 @@
+"use strict";var Pe=Object.create;var W=Object.defineProperty;var he=Object.getOwnPropertyDescriptor;var Ie=Object.getOwnPropertyNames;var Ue=Object.getPrototypeOf,be=Object.prototype.hasOwnProperty;var Ee=(e,s)=>{for(var d in s)W(e,d,{get:s[d],enumerable:!0})},j=(e,s,d,R)=>{if(s&&typeof s=="object"||typeof s=="function")for(let T of Ie(s))!be.call(e,T)&&T!==d&&W(e,T,{get:()=>s[T],enumerable:!(R=he(s,T))||R.enumerable});return e},k=(e,s,d)=>(j(e,s,"default"),d&&j(d,s,"default")),ke=(e,s,d)=>(d=e!=null?Pe(Ue(e)):{},j(s||!e||!e.__esModule?W(d,"default",{value:e,enumerable:!0}):d,e)),Me=e=>j(W({},"__esModule",{value:!0}),e);var E={};Ee(E,{ApiProvider:()=>Se,UNINITIALIZED_VALUE:()=>H,createApi:()=>Ne,reactHooksModule:()=>Qe,reactHooksModuleName:()=>fe});module.exports=Me(E);var te=require("@reduxjs/toolkit/query");var Xe=require("@reduxjs/toolkit"),M=require("react-redux"),Te=require("reselect");function V(e){return e.replace(e[0],e[0].toUpperCase())}function de(e){return e.type==="query"}function ce(e){return e.type==="mutation"}function $(e){return e.type==="infinitequery"}function N(e,...s){return Object.assign(e,...s)}var ge=require("@reduxjs/toolkit"),A=require("@reduxjs/toolkit/query"),n=require("react"),Y=require("react-redux");var H=Symbol();var z=require("react");function G(e,s,d,R){let T=(0,z.useMemo)(()=>({queryArgs:e,serialized:typeof e=="object"?s({queryArgs:e,endpointDefinition:d,endpointName:R}):e}),[e,s,d,R]),D=(0,z.useRef)(T);return(0,z.useEffect)(()=>{D.current.serialized!==T.serialized&&(D.current=T)},[T]),D.current.serialized===T.serialized?D.current.queryArgs:e}var Z=require("react"),ye=require("react-redux");function _(e){let s=(0,Z.useRef)(e);return(0,Z.useEffect)(()=>{(0,ye.shallowEqual)(s.current,e)||(s.current=e)},[e]),(0,ye.shallowEqual)(s.current,e)?s.current:e}var Oe=()=>typeof window<"u"&&typeof window.document<"u"&&typeof window.document.createElement<"u",Fe=Oe(),we=()=>typeof navigator<"u"&&navigator.product==="ReactNative",ve=we(),Le=()=>Fe||ve?n.useLayoutEffect:n.useEffect,Ce=Le(),le=e=>e.isUninitialized?{...e,isUninitialized:!1,isFetching:!0,isLoading:e.data===void 0,status:A.QueryStatus.pending}:e;function oe(e,...s){let d={};return s.forEach(R=>{d[R]=e[R]}),d}var pe=["data","status","isLoading","isSuccess","isError","error"];function Re({api:e,moduleOptions:{batch:s,hooks:{useDispatch:d,useSelector:R,useStore:T},unstable__sideEffectsInRender:D,createSelector:L},serializeQueryArgs:U,context:h}){let O=D?t=>t():n.useEffect;return{buildQueryHooks:q,buildInfiniteQueryHooks:se,buildMutationHook:ae,usePrefetch:ie};function ne(t,a,Q){if(a?.endpointName&&t.isUninitialized){let{endpointName:y}=a,p=h.endpointDefinitions[y];Q!==A.skipToken&&U({queryArgs:a.originalArgs,endpointDefinition:p,endpointName:y})===U({queryArgs:Q,endpointDefinition:p,endpointName:y})&&(a=void 0)}let o=t.isSuccess?t.data:a?.data;o===void 0&&(o=t.data);let u=o!==void 0,r=t.isLoading,i=(!a||a.isLoading||a.isUninitialized)&&!u&&r,f=t.isSuccess||u&&(r&&!a?.isError||t.isUninitialized);return{...t,data:o,currentData:t.data,isFetching:r,isLoading:i,isSuccess:f}}function re(t,a,Q){if(a?.endpointName&&t.isUninitialized){let{endpointName:y}=a,p=h.endpointDefinitions[y];Q!==A.skipToken&&U({queryArgs:a.originalArgs,endpointDefinition:p,endpointName:y})===U({queryArgs:Q,endpointDefinition:p,endpointName:y})&&(a=void 0)}let o=t.isSuccess?t.data:a?.data;o===void 0&&(o=t.data);let u=o!==void 0,r=t.isLoading,i=(!a||a.isLoading||a.isUninitialized)&&!u&&r,f=t.isSuccess||r&&u;return{...t,data:o,currentData:t.data,isFetching:r,isLoading:i,isSuccess:f}}function ie(t,a){let Q=d(),o=_(a);return(0,n.useCallback)((u,r)=>Q(e.util.prefetch(t,u,{...o,...r})),[t,Q,o])}function B(t,a,{refetchOnReconnect:Q,refetchOnFocus:o,refetchOnMountOrArgChange:u,skip:r=!1,pollingInterval:i=0,skipPollingIfUnfocused:f=!1,...y}={}){let{initiate:p}=e.endpoints[t],l=d(),P=(0,n.useRef)(void 0);if(!P.current){let v=l(e.internalActions.internal_getRTKQSubscriptions());P.current=v}let c=G(r?A.skipToken:a,A.defaultSerializeQueryArgs,h.endpointDefinitions[t],t),g=_({refetchOnReconnect:Q,refetchOnFocus:o,pollingInterval:i,skipPollingIfUnfocused:f}),x=y.initialPageParam,m=_(x),S=(0,n.useRef)(void 0),{queryCacheKey:b,requestId:w}=S.current||{},K=!1;b&&w&&(K=P.current.isRequestSubscribed(b,w));let ue=!K&&S.current!==void 0;return O(()=>{ue&&(S.current=void 0)},[ue]),O(()=>{let v=S.current;if(typeof process<"u",c===A.skipToken){v?.unsubscribe(),S.current=void 0;return}let Ae=S.current?.subscriptionOptions;if(!v||v.arg!==c){v?.unsubscribe();let Be=l(p(c,{subscriptionOptions:g,forceRefetch:u,...$(h.endpointDefinitions[t])?{initialPageParam:m}:{}}));S.current=Be}else g!==Ae&&v.updateSubscriptionOptions(g)},[l,p,u,c,g,ue,m,t]),[S,l,p,g]}function C(t,a){return(o,{skip:u=!1,selectFromResult:r}={})=>{let{select:i}=e.endpoints[t],f=G(u?A.skipToken:o,U,h.endpointDefinitions[t],t),y=(0,n.useRef)(void 0),p=(0,n.useMemo)(()=>L([i(f),(x,m)=>m,x=>f],a,{memoizeOptions:{resultEqualityCheck:Y.shallowEqual}}),[i,f]),l=(0,n.useMemo)(()=>r?L([p],r,{devModeChecks:{identityFunctionCheck:"never"}}):p,[p,r]),P=R(x=>l(x,y.current),Y.shallowEqual),c=T(),g=p(c.getState(),y.current);return Ce(()=>{y.current=g},[g]),P}}function I(t){(0,n.useEffect)(()=>()=>{t.current?.unsubscribe?.(),t.current=void 0},[t])}function F(t){if(!t.current)throw new Error((0,ge.formatProdErrorMessage)(38));return t.current.refetch()}function q(t){let a=(u,r={})=>{let[i]=B(t,u,r);return I(i),(0,n.useMemo)(()=>({refetch:()=>F(i)}),[i])},Q=({refetchOnReconnect:u,refetchOnFocus:r,pollingInterval:i=0,skipPollingIfUnfocused:f=!1}={})=>{let{initiate:y}=e.endpoints[t],p=d(),[l,P]=(0,n.useState)(H),c=(0,n.useRef)(void 0),g=_({refetchOnReconnect:u,refetchOnFocus:r,pollingInterval:i,skipPollingIfUnfocused:f});O(()=>{let b=c.current?.subscriptionOptions;g!==b&&c.current?.updateSubscriptionOptions(g)},[g]);let x=(0,n.useRef)(g);O(()=>{x.current=g},[g]);let m=(0,n.useCallback)(function(b,w=!1){let K;return s(()=>{c.current?.unsubscribe(),c.current=K=p(y(b,{subscriptionOptions:x.current,forceRefetch:!w})),P(b)}),K},[p,y]),S=(0,n.useCallback)(()=>{c.current?.queryCacheKey&&p(e.internalActions.removeQueryResult({queryCacheKey:c.current?.queryCacheKey}))},[p]);return(0,n.useEffect)(()=>()=>{c?.current?.unsubscribe()},[]),(0,n.useEffect)(()=>{l!==H&&!c.current&&m(l,!0)},[l,m]),(0,n.useMemo)(()=>[m,l,{reset:S}],[m,l,S])},o=C(t,ne);return{useQueryState:o,useQuerySubscription:a,useLazyQuerySubscription:Q,useLazyQuery(u){let[r,i,{reset:f}]=Q(u),y=o(i,{...u,skip:i===H}),p=(0,n.useMemo)(()=>({lastArg:i}),[i]);return(0,n.useMemo)(()=>[r,{...y,reset:f},p],[r,y,f,p])},useQuery(u,r){let i=a(u,r),f=o(u,{selectFromResult:u===A.skipToken||r?.skip?void 0:le,...r}),y=oe(f,...pe);return(0,n.useDebugValue)(y),(0,n.useMemo)(()=>({...f,...i}),[f,i])}}}function se(t){let a=(o,u={})=>{let[r,i,f,y]=B(t,o,u),p=(0,n.useRef)(y);O(()=>{p.current=y},[y]);let l=(0,n.useCallback)(function(g,x){let m;return s(()=>{r.current?.unsubscribe(),r.current=m=i(f(g,{subscriptionOptions:p.current,direction:x}))}),m},[r,i,f]);I(r);let P=G(u.skip?A.skipToken:o,A.defaultSerializeQueryArgs,h.endpointDefinitions[t],t),c=(0,n.useCallback)(()=>F(r),[r]);return(0,n.useMemo)(()=>({trigger:l,refetch:c,fetchNextPage:()=>l(P,"forward"),fetchPreviousPage:()=>l(P,"backward")}),[c,l,P])},Q=C(t,re);return{useInfiniteQueryState:Q,useInfiniteQuerySubscription:a,useInfiniteQuery(o,u){let{refetch:r,fetchNextPage:i,fetchPreviousPage:f}=a(o,u),y=Q(o,{selectFromResult:o===A.skipToken||u?.skip?void 0:le,...u}),p=oe(y,...pe,"hasNextPage","hasPreviousPage");return(0,n.useDebugValue)(p),(0,n.useMemo)(()=>({...y,fetchNextPage:i,fetchPreviousPage:f,refetch:r}),[y,i,f,r])}}}function ae(t){return({selectFromResult:a,fixedCacheKey:Q}={})=>{let{select:o,initiate:u}=e.endpoints[t],r=d(),[i,f]=(0,n.useState)();(0,n.useEffect)(()=>()=>{i?.arg.fixedCacheKey||i?.reset()},[i]);let y=(0,n.useCallback)(function(b){let w=r(u(b,{fixedCacheKey:Q}));return f(w),w},[r,u,Q]),{requestId:p}=i||{},l=(0,n.useMemo)(()=>o({fixedCacheKey:Q,requestId:i?.requestId}),[Q,i,o]),P=(0,n.useMemo)(()=>a?L([l],a):l,[a,l]),c=R(P,Y.shallowEqual),g=Q==null?i?.arg.originalArgs:void 0,x=(0,n.useCallback)(()=>{s(()=>{i&&f(void 0),Q&&r(e.internalActions.removeMutationResult({requestId:p,fixedCacheKey:Q}))})},[r,Q,i,p]),m=oe(c,...pe,"endpointName");(0,n.useDebugValue)(m);let S=(0,n.useMemo)(()=>({...c,originalArgs:g,reset:x}),[c,g,x]);return(0,n.useMemo)(()=>[y,S],[y,S])}}}var fe=Symbol(),Qe=({batch:e=M.batch,hooks:s={useDispatch:M.useDispatch,useSelector:M.useSelector,useStore:M.useStore},createSelector:d=Te.createSelector,unstable__sideEffectsInRender:R=!1,...T}={})=>({name:fe,init(D,{serializeQueryArgs:L},U){let h=D,{buildQueryHooks:O,buildInfiniteQueryHooks:ne,buildMutationHook:re,usePrefetch:ie}=Re({api:D,moduleOptions:{batch:e,hooks:s,unstable__sideEffectsInRender:R,createSelector:d},serializeQueryArgs:L,context:U});return N(h,{usePrefetch:ie}),N(U,{batch:e}),{injectEndpoint(B,C){if(de(C)){let{useQuery:I,useLazyQuery:F,useLazyQuerySubscription:q,useQueryState:se,useQuerySubscription:ae}=O(B);N(h.endpoints[B],{useQuery:I,useLazyQuery:F,useLazyQuerySubscription:q,useQueryState:se,useQuerySubscription:ae}),D[`use${V(B)}Query`]=I,D[`useLazy${V(B)}Query`]=F}if(ce(C)){let I=re(B);N(h.endpoints[B],{useMutation:I}),D[`use${V(B)}Mutation`]=I}else if($(C)){let{useInfiniteQuery:I,useInfiniteQuerySubscription:F,useInfiniteQueryState:q}=ne(B);N(h.endpoints[B],{useInfiniteQuery:I,useInfiniteQuerySubscription:F,useInfiniteQueryState:q}),D[`use${V(B)}InfiniteQuery`]=I}}}}});k(E,require("@reduxjs/toolkit/query"),module.exports);var J=require("@reduxjs/toolkit"),De=require("react"),xe=require("react"),X=ke(require("react")),ee=require("react-redux"),me=require("@reduxjs/toolkit/query");function Se(e){let s=e.context||ee.ReactReduxContext;if((0,De.useContext)(s))throw new Error((0,J.formatProdErrorMessage)(35));let[R]=X.useState(()=>(0,J.configureStore)({reducer:{[e.api.reducerPath]:e.api.reducer},middleware:T=>T().concat(e.api.middleware)}));return(0,xe.useEffect)(()=>e.setupListeners===!1?void 0:(0,me.setupListeners)(R.dispatch,e.setupListeners),[e.setupListeners,R.dispatch]),X.createElement(ee.Provider,{store:R,context:s},e.children)}var Ne=(0,te.buildCreateApi)((0,te.coreModule)(),Qe());0&&(module.exports={ApiProvider,UNINITIALIZED_VALUE,createApi,reactHooksModule,reactHooksModuleName,...require("@reduxjs/toolkit/query")});
+//# sourceMappingURL=rtk-query-react.production.min.cjs.map

frontend/node_modules/@reduxjs/toolkit/dist/query/react/index.d.mts

@@ -0,0 +1,959 @@
+import * as _reduxjs_toolkit_query from '@reduxjs/toolkit/query';
+import { QueryDefinition, TSHelpersId, TSHelpersOverride, QuerySubState, ResultTypeFrom, QueryStatus, QueryArgFrom, SkipToken, SubscriptionOptions, TSHelpersNoInfer, QueryActionCreatorResult, MutationDefinition, MutationResultSelectorResult, MutationActionCreatorResult, InfiniteQueryDefinition, InfiniteQuerySubState, PageParamFrom, InfiniteQueryArgFrom, InfiniteQueryActionCreatorResult, BaseQueryFn, EndpointDefinitions, DefinitionType, QueryKeys, PrefetchOptions, Module, Api, setupListeners } from '@reduxjs/toolkit/query';
+export * from '@reduxjs/toolkit/query';
+import * as react_redux from 'react-redux';
+import { ReactReduxContextValue } from 'react-redux';
+import { createSelector } from 'reselect';
+import * as React from 'react';
+import { Context } from 'react';
+
+type InfiniteData<DataType, PageParam> = {
+    pages: Array<DataType>;
+    pageParams: Array<PageParam>;
+};
+type InfiniteQueryDirection = 'forward' | 'backward';
+
+export declare const UNINITIALIZED_VALUE: unique symbol;
+type UninitializedValue = typeof UNINITIALIZED_VALUE;
+
+type QueryHooks<Definition extends QueryDefinition<any, any, any, any, any>> = {
+    useQuery: UseQuery<Definition>;
+    useLazyQuery: UseLazyQuery<Definition>;
+    useQuerySubscription: UseQuerySubscription<Definition>;
+    useLazyQuerySubscription: UseLazyQuerySubscription<Definition>;
+    useQueryState: UseQueryState<Definition>;
+};
+type InfiniteQueryHooks<Definition extends InfiniteQueryDefinition<any, any, any, any, any>> = {
+    useInfiniteQuery: UseInfiniteQuery<Definition>;
+    useInfiniteQuerySubscription: UseInfiniteQuerySubscription<Definition>;
+    useInfiniteQueryState: UseInfiniteQueryState<Definition>;
+};
+type MutationHooks<Definition extends MutationDefinition<any, any, any, any, any>> = {
+    useMutation: UseMutation<Definition>;
+};
+/**
+ * A React hook that automatically triggers fetches of data from an endpoint, 'subscribes' the component to the cached data, and reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.
+ *
+ * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already, and the hook will return the data for that query arg once it's available.
+ *
+ * This hook combines the functionality of both [`useQueryState`](#usequerystate) and [`useQuerySubscription`](#usequerysubscription) together, and is intended to be used in the majority of situations.
+ *
+ * #### Features
+ *
+ * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseQuery<D extends QueryDefinition<any, any, any, any>> = <R extends Record<string, any> = UseQueryStateDefaultResult<D>>(arg: QueryArgFrom<D> | SkipToken, options?: UseQuerySubscriptionOptions & UseQueryStateOptions<D, R>) => UseQueryHookResult<D, R>;
+type TypedUseQuery<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseQuery<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type UseQueryHookResult<D extends QueryDefinition<any, any, any, any>, R = UseQueryStateDefaultResult<D>> = UseQueryStateResult<D, R> & UseQuerySubscriptionResult<D>;
+/**
+ * Helper type to manually type the result
+ * of the `useQuery` hook in userland code.
+ */
+type TypedUseQueryHookResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = TypedUseQueryStateResult<ResultType, QueryArg, BaseQuery, R> & TypedUseQuerySubscriptionResult<ResultType, QueryArg, BaseQuery>;
+type UseQuerySubscriptionOptions = SubscriptionOptions & {
+    /**
+     * Prevents a query from automatically running.
+     *
+     * @remarks
+     * When `skip` is true (or `skipToken` is passed in as `arg`):
+     *
+     * - **If the query has cached data:**
+     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+     *   * The query will have a status of `uninitialized`
+     *   * If `skip: false` is set after the initial load, the cached result will be used
+     * - **If the query does not have cached data:**
+     *   * The query will have a status of `uninitialized`
+     *   * The query will not exist in the state when viewed with the dev tools
+     *   * The query will not automatically fetch on mount
+     *   * The query will not automatically run when additional components with the same query are added that do run
+     *
+     * @example
+     * ```tsx
+     * // codeblock-meta no-transpile title="Skip example"
+     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+     *     skip,
+     *   });
+     *
+     *   return (
+     *     <div>
+     *       {name} - {status}
+     *     </div>
+     *   );
+     * };
+     * ```
+     */
+    skip?: boolean;
+    /**
+     * Defaults to `false`. This setting allows you to control whether if a cached result is already available, RTK Query will only serve a cached result, or if it should `refetch` when set to `true` or if an adequate amount of time has passed since the last successful query result.
+     * - `false` - Will not cause a query to be performed _unless_ it does not exist yet.
+     * - `true` - Will always refetch when a new subscriber to a query is added. Behaves the same as calling the `refetch` callback or passing `forceRefetch: true` in the action creator.
+     * - `number` - **Value is in seconds**. If a number is provided and there is an existing query in the cache, it will compare the current time vs the last fulfilled timestamp, and only refetch if enough time has elapsed.
+     *
+     * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
+     */
+    refetchOnMountOrArgChange?: boolean | number;
+};
+/**
+ * A React hook that automatically triggers fetches of data from an endpoint, and 'subscribes' the component to the cached data.
+ *
+ * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already.
+ *
+ * Note that this hook does not return a request status or cached data. For that use-case, see [`useQuery`](#usequery) or [`useQueryState`](#usequerystate).
+ *
+ * #### Features
+ *
+ * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met
+ */
+type UseQuerySubscription<D extends QueryDefinition<any, any, any, any>> = (arg: QueryArgFrom<D> | SkipToken, options?: UseQuerySubscriptionOptions) => UseQuerySubscriptionResult<D>;
+type TypedUseQuerySubscription<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseQuerySubscription<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type UseQuerySubscriptionResult<D extends QueryDefinition<any, any, any, any>> = Pick<QueryActionCreatorResult<D>, 'refetch'>;
+/**
+ * Helper type to manually type the result
+ * of the `useQuerySubscription` hook in userland code.
+ */
+type TypedUseQuerySubscriptionResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseQuerySubscriptionResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type UseLazyQueryLastPromiseInfo<D extends QueryDefinition<any, any, any, any>> = {
+    lastArg: QueryArgFrom<D>;
+};
+/**
+ * A React hook similar to [`useQuery`](#usequery), but with manual control over when the data fetching occurs.
+ *
+ * This hook includes the functionality of [`useLazyQuerySubscription`](#uselazyquerysubscription).
+ *
+ * #### Features
+ *
+ * - Manual control over firing a request to retrieve data
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met and the fetch has been manually called at least once
+ *
+ * #### Note
+ *
+ * When the trigger function returned from a LazyQuery is called, it always initiates a new request to the server even if there is cached data. Set `preferCacheValue`(the second argument to the function) as `true` if you want it to immediately return a cached value if one exists.
+ */
+type UseLazyQuery<D extends QueryDefinition<any, any, any, any>> = <R extends Record<string, any> = UseQueryStateDefaultResult<D>>(options?: SubscriptionOptions & Omit<UseQueryStateOptions<D, R>, 'skip'>) => [
+    LazyQueryTrigger<D>,
+    UseLazyQueryStateResult<D, R>,
+    UseLazyQueryLastPromiseInfo<D>
+];
+type TypedUseLazyQuery<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseLazyQuery<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type UseLazyQueryStateResult<D extends QueryDefinition<any, any, any, any>, R = UseQueryStateDefaultResult<D>> = UseQueryStateResult<D, R> & {
+    /**
+     * Resets the hook state to its initial `uninitialized` state.
+     * This will also remove the last result from the cache.
+     */
+    reset: () => void;
+};
+/**
+ * Helper type to manually type the result
+ * of the `useLazyQuery` hook in userland code.
+ */
+type TypedUseLazyQueryStateResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = UseLazyQueryStateResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>, R>;
+type LazyQueryTrigger<D extends QueryDefinition<any, any, any, any>> = {
+    /**
+     * Triggers a lazy query.
+     *
+     * By default, this will start a new request even if there is already a value in the cache.
+     * If you want to use the cache value and only start a request if there is no cache value, set the second argument to `true`.
+     *
+     * @remarks
+     * If you need to access the error or success payload immediately after a lazy query, you can chain .unwrap().
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using .unwrap with async await"
+     * try {
+     *   const payload = await getUserById(1).unwrap();
+     *   console.log('fulfilled', payload)
+     * } catch (error) {
+     *   console.error('rejected', error);
+     * }
+     * ```
+     */
+    (arg: QueryArgFrom<D>, preferCacheValue?: boolean): QueryActionCreatorResult<D>;
+};
+type TypedLazyQueryTrigger<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = LazyQueryTrigger<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+/**
+ * A React hook similar to [`useQuerySubscription`](#usequerysubscription), but with manual control over when the data fetching occurs.
+ *
+ * Note that this hook does not return a request status or cached data. For that use-case, see [`useLazyQuery`](#uselazyquery).
+ *
+ * #### Features
+ *
+ * - Manual control over firing a request to retrieve data
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met and the fetch has been manually called at least once
+ */
+type UseLazyQuerySubscription<D extends QueryDefinition<any, any, any, any>> = (options?: SubscriptionOptions) => readonly [
+    LazyQueryTrigger<D>,
+    QueryArgFrom<D> | UninitializedValue,
+    {
+        reset: () => void;
+    }
+];
+type TypedUseLazyQuerySubscription<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseLazyQuerySubscription<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+/**
+ * @internal
+ */
+type QueryStateSelector<R extends Record<string, any>, D extends QueryDefinition<any, any, any, any>> = (state: UseQueryStateDefaultResult<D>) => R;
+/**
+ * Provides a way to define a strongly-typed version of
+ * {@linkcode QueryStateSelector} for use with a specific query.
+ * This is useful for scenarios where you want to create a "pre-typed"
+ * {@linkcode UseQueryStateOptions.selectFromResult | selectFromResult}
+ * function.
+ *
+ * @example
+ * <caption>#### __Create a strongly-typed `selectFromResult` selector function__</caption>
+ *
+ * ```tsx
+ * import type { TypedQueryStateSelector } from '@reduxjs/toolkit/query/react'
+ * import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+ *
+ * type Post = {
+ *   id: number
+ *   title: string
+ * }
+ *
+ * type PostsApiResponse = {
+ *   posts: Post[]
+ *   total: number
+ *   skip: number
+ *   limit: number
+ * }
+ *
+ * type QueryArgument = number | undefined
+ *
+ * type BaseQueryFunction = ReturnType<typeof fetchBaseQuery>
+ *
+ * type SelectedResult = Pick<PostsApiResponse, 'posts'>
+ *
+ * const postsApiSlice = createApi({
+ *   baseQuery: fetchBaseQuery({ baseUrl: 'https://dummyjson.com/posts' }),
+ *   reducerPath: 'postsApi',
+ *   tagTypes: ['Posts'],
+ *   endpoints: (build) => ({
+ *     getPosts: build.query<PostsApiResponse, QueryArgument>({
+ *       query: (limit = 5) => `?limit=${limit}&select=title`,
+ *     }),
+ *   }),
+ * })
+ *
+ * const { useGetPostsQuery } = postsApiSlice
+ *
+ * function PostById({ id }: { id: number }) {
+ *   const { post } = useGetPostsQuery(undefined, {
+ *     selectFromResult: (state) => ({
+ *       post: state.data?.posts.find((post) => post.id === id),
+ *     }),
+ *   })
+ *
+ *   return <li>{post?.title}</li>
+ * }
+ *
+ * const EMPTY_ARRAY: Post[] = []
+ *
+ * const typedSelectFromResult: TypedQueryStateSelector<
+ *   PostsApiResponse,
+ *   QueryArgument,
+ *   BaseQueryFunction,
+ *   SelectedResult
+ * > = (state) => ({ posts: state.data?.posts ?? EMPTY_ARRAY })
+ *
+ * function PostsList() {
+ *   const { posts } = useGetPostsQuery(undefined, {
+ *     selectFromResult: typedSelectFromResult,
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <ul>
+ *         {posts.map((post) => (
+ *           <PostById key={post.id} id={post.id} />
+ *         ))}
+ *       </ul>
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @template ResultType - The type of the result `data` returned by the query.
+ * @template QueryArgumentType - The type of the argument passed into the query.
+ * @template BaseQueryFunctionType - The type of the base query function being used.
+ * @template SelectedResultType - The type of the selected result returned by the __`selectFromResult`__ function.
+ *
+ * @since 2.3.0
+ * @public
+ */
+type TypedQueryStateSelector<ResultType, QueryArgumentType, BaseQueryFunctionType extends BaseQueryFn, SelectedResultType extends Record<string, any> = UseQueryStateDefaultResult<QueryDefinition<QueryArgumentType, BaseQueryFunctionType, string, ResultType, string>>> = QueryStateSelector<SelectedResultType, QueryDefinition<QueryArgumentType, BaseQueryFunctionType, string, ResultType, string>>;
+/**
+ * A React hook that reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.
+ *
+ * Note that this hook does not trigger fetching new data. For that use-case, see [`useQuery`](#usequery) or [`useQuerySubscription`](#usequerysubscription).
+ *
+ * #### Features
+ *
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseQueryState<D extends QueryDefinition<any, any, any, any>> = <R extends Record<string, any> = UseQueryStateDefaultResult<D>>(arg: QueryArgFrom<D> | SkipToken, options?: UseQueryStateOptions<D, R>) => UseQueryStateResult<D, R>;
+type TypedUseQueryState<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseQueryState<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+/**
+ * @internal
+ */
+type UseQueryStateOptions<D extends QueryDefinition<any, any, any, any>, R extends Record<string, any>> = {
+    /**
+     * Prevents a query from automatically running.
+     *
+     * @remarks
+     * When skip is true:
+     *
+     * - **If the query has cached data:**
+     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+     *   * The query will have a status of `uninitialized`
+     *   * If `skip: false` is set after skipping the initial load, the cached result will be used
+     * - **If the query does not have cached data:**
+     *   * The query will have a status of `uninitialized`
+     *   * The query will not exist in the state when viewed with the dev tools
+     *   * The query will not automatically fetch on mount
+     *   * The query will not automatically run when additional components with the same query are added that do run
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Skip example"
+     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+     *     skip,
+     *   });
+     *
+     *   return (
+     *     <div>
+     *       {name} - {status}
+     *     </div>
+     *   );
+     * };
+     * ```
+     */
+    skip?: boolean;
+    /**
+     * `selectFromResult` allows you to get a specific segment from a query result in a performant manner.
+     * When using this feature, the component will not rerender unless the underlying data of the selected item has changed.
+     * If the selected item is one element in a larger collection, it will disregard changes to elements in the same collection.
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using selectFromResult to extract a single result"
+     * function PostsList() {
+     *   const { data: posts } = api.useGetPostsQuery();
+     *
+     *   return (
+     *     <ul>
+     *       {posts?.data?.map((post) => (
+     *         <PostById key={post.id} id={post.id} />
+     *       ))}
+     *     </ul>
+     *   );
+     * }
+     *
+     * function PostById({ id }: { id: number }) {
+     *   // Will select the post with the given id, and will only rerender if the given posts data changes
+     *   const { post } = api.useGetPostsQuery(undefined, {
+     *     selectFromResult: ({ data }) => ({ post: data?.find((post) => post.id === id) }),
+     *   });
+     *
+     *   return <li>{post?.name}</li>;
+     * }
+     * ```
+     */
+    selectFromResult?: QueryStateSelector<R, D>;
+};
+/**
+ * Provides a way to define a "pre-typed" version of
+ * {@linkcode UseQueryStateOptions} with specific options for a given query.
+ * This is particularly useful for setting default query behaviors such as
+ * refetching strategies, which can be overridden as needed.
+ *
+ * @example
+ * <caption>#### __Create a `useQuery` hook with default options__</caption>
+ *
+ * ```ts
+ * import type {
+ *   SubscriptionOptions,
+ *   TypedUseQueryStateOptions,
+ * } from '@reduxjs/toolkit/query/react'
+ * import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+ *
+ * type Post = {
+ *   id: number
+ *   name: string
+ * }
+ *
+ * const api = createApi({
+ *   baseQuery: fetchBaseQuery({ baseUrl: '/' }),
+ *   tagTypes: ['Post'],
+ *   endpoints: (build) => ({
+ *     getPosts: build.query<Post[], void>({
+ *       query: () => 'posts',
+ *     }),
+ *   }),
+ * })
+ *
+ * const { useGetPostsQuery } = api
+ *
+ * export const useGetPostsQueryWithDefaults = <
+ *   SelectedResult extends Record<string, any>,
+ * >(
+ *   overrideOptions: TypedUseQueryStateOptions<
+ *     Post[],
+ *     void,
+ *     ReturnType<typeof fetchBaseQuery>,
+ *     SelectedResult
+ *   > &
+ *     SubscriptionOptions,
+ * ) =>
+ *   useGetPostsQuery(undefined, {
+ *     // Insert default options here
+ *
+ *     refetchOnMountOrArgChange: true,
+ *     refetchOnFocus: true,
+ *     ...overrideOptions,
+ *   })
+ * ```
+ *
+ * @template ResultType - The type of the result `data` returned by the query.
+ * @template QueryArg - The type of the argument passed into the query.
+ * @template BaseQuery - The type of the base query function being used.
+ * @template SelectedResult - The type of the selected result returned by the __`selectFromResult`__ function.
+ *
+ * @since 2.2.8
+ * @public
+ */
+type TypedUseQueryStateOptions<ResultType, QueryArg, BaseQuery extends BaseQueryFn, SelectedResult extends Record<string, any> = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = UseQueryStateOptions<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>, SelectedResult>;
+type UseQueryStateResult<_ extends QueryDefinition<any, any, any, any>, R> = TSHelpersNoInfer<R>;
+/**
+ * Helper type to manually type the result
+ * of the `useQueryState` hook in userland code.
+ */
+type TypedUseQueryStateResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = TSHelpersNoInfer<R>;
+type UseQueryStateBaseResult<D extends QueryDefinition<any, any, any, any>> = QuerySubState<D> & {
+    /**
+     * Where `data` tries to hold data as much as possible, also re-using
+     * data from the last arguments passed into the hook, this property
+     * will always contain the received data from the query, for the current query arguments.
+     */
+    currentData?: ResultTypeFrom<D>;
+    /**
+     * Query has not started yet.
+     */
+    isUninitialized: false;
+    /**
+     * Query is currently loading for the first time. No data yet.
+     */
+    isLoading: false;
+    /**
+     * Query is currently fetching, but might have data from an earlier request.
+     */
+    isFetching: false;
+    /**
+     * Query has data from a successful load.
+     */
+    isSuccess: false;
+    /**
+     * Query is currently in "error" state.
+     */
+    isError: false;
+};
+type UseQueryStateDefaultResult<D extends QueryDefinition<any, any, any, any>> = TSHelpersId<TSHelpersOverride<Extract<UseQueryStateBaseResult<D>, {
+    status: QueryStatus.uninitialized;
+}>, {
+    isUninitialized: true;
+}> | TSHelpersOverride<UseQueryStateBaseResult<D>, {
+    isLoading: true;
+    isFetching: boolean;
+    data: undefined;
+} | ({
+    isSuccess: true;
+    isFetching: true;
+    error: undefined;
+} & Required<Pick<UseQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp'>>) | ({
+    isSuccess: true;
+    isFetching: false;
+    error: undefined;
+} & Required<Pick<UseQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp' | 'currentData'>>) | ({
+    isError: true;
+} & Required<Pick<UseQueryStateBaseResult<D>, 'error'>>)>> & {
+    /**
+     * @deprecated Included for completeness, but discouraged.
+     * Please use the `isLoading`, `isFetching`, `isSuccess`, `isError`
+     * and `isUninitialized` flags instead
+     */
+    status: QueryStatus;
+};
+type LazyInfiniteQueryTrigger<D extends InfiniteQueryDefinition<any, any, any, any, any>> = {
+    /**
+     * Triggers a lazy query.
+     *
+     * By default, this will start a new request even if there is already a value in the cache.
+     * If you want to use the cache value and only start a request if there is no cache value, set the second argument to `true`.
+     *
+     * @remarks
+     * If you need to access the error or success payload immediately after a lazy query, you can chain .unwrap().
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using .unwrap with async await"
+     * try {
+     *   const payload = await getUserById(1).unwrap();
+     *   console.log('fulfilled', payload)
+     * } catch (error) {
+     *   console.error('rejected', error);
+     * }
+     * ```
+     */
+    (arg: QueryArgFrom<D>, direction: InfiniteQueryDirection): InfiniteQueryActionCreatorResult<D>;
+};
+type TypedLazyInfiniteQueryTrigger<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = LazyInfiniteQueryTrigger<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+type UseInfiniteQuerySubscriptionOptions<D extends InfiniteQueryDefinition<any, any, any, any, any>> = SubscriptionOptions & {
+    /**
+     * Prevents a query from automatically running.
+     *
+     * @remarks
+     * When `skip` is true (or `skipToken` is passed in as `arg`):
+     *
+     * - **If the query has cached data:**
+     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+     *   * The query will have a status of `uninitialized`
+     *   * If `skip: false` is set after the initial load, the cached result will be used
+     * - **If the query does not have cached data:**
+     *   * The query will have a status of `uninitialized`
+     *   * The query will not exist in the state when viewed with the dev tools
+     *   * The query will not automatically fetch on mount
+     *   * The query will not automatically run when additional components with the same query are added that do run
+     *
+     * @example
+     * ```tsx
+     * // codeblock-meta no-transpile title="Skip example"
+     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+     *     skip,
+     *   });
+     *
+     *   return (
+     *     <div>
+     *       {name} - {status}
+     *     </div>
+     *   );
+     * };
+     * ```
+     */
+    skip?: boolean;
+    /**
+     * Defaults to `false`. This setting allows you to control whether if a cached result is already available, RTK Query will only serve a cached result, or if it should `refetch` when set to `true` or if an adequate amount of time has passed since the last successful query result.
+     * - `false` - Will not cause a query to be performed _unless_ it does not exist yet.
+     * - `true` - Will always refetch when a new subscriber to a query is added. Behaves the same as calling the `refetch` callback or passing `forceRefetch: true` in the action creator.
+     * - `number` - **Value is in seconds**. If a number is provided and there is an existing query in the cache, it will compare the current time vs the last fulfilled timestamp, and only refetch if enough time has elapsed.
+     *
+     * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
+     */
+    refetchOnMountOrArgChange?: boolean | number;
+    initialPageParam?: PageParamFrom<D>;
+};
+type TypedUseInfiniteQuerySubscription<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = UseInfiniteQuerySubscription<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+type UseInfiniteQuerySubscriptionResult<D extends InfiniteQueryDefinition<any, any, any, any, any>> = Pick<InfiniteQueryActionCreatorResult<D>, 'refetch'> & {
+    trigger: LazyInfiniteQueryTrigger<D>;
+    fetchNextPage: () => InfiniteQueryActionCreatorResult<D>;
+    fetchPreviousPage: () => InfiniteQueryActionCreatorResult<D>;
+};
+/**
+ * Helper type to manually type the result
+ * of the `useQuerySubscription` hook in userland code.
+ */
+type TypedUseInfiniteQuerySubscriptionResult<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = UseInfiniteQuerySubscriptionResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+type InfiniteQueryStateSelector<R extends Record<string, any>, D extends InfiniteQueryDefinition<any, any, any, any, any>> = (state: UseInfiniteQueryStateDefaultResult<D>) => R;
+type TypedInfiniteQueryStateSelector<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, SelectedResult extends Record<string, any> = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = InfiniteQueryStateSelector<SelectedResult, InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+/**
+ * A React hook that automatically triggers fetches of data from an endpoint, 'subscribes' the component to the cached data, and reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.  Additionally, it will cache multiple "pages" worth of responses within a single cache entry, and allows fetching more pages forwards and backwards from the current cached pages.
+ *
+ * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already, and the hook will return the data for that query arg once it's available.
+ *
+ *  The `data` field will be a `{pages: Data[], pageParams: PageParam[]}` structure containing all fetched page responses and the corresponding page param values for each page. You may use this to render individual pages, combine all pages into a single infinite list, or other display logic as needed.
+ *
+ * This hook combines the functionality of both [`useInfiniteQueryState`](#useinfinitequerystate) and [`useInfiniteQuerySubscription`](#useinfinitequerysubscription) together, and is intended to be used in the majority of situations.
+ *
+ * As with normal query hooks, `skipToken` is a valid argument that will skip the query from executing.
+ *
+ * By default, the initial request will use the `initialPageParam` value that was defined on the infinite query endpoint. If you want to start from a different value, you can pass `initialPageParam` as part of the hook options to override that initial request value.
+ *
+ * Use the returned `fetchNextPage` and `fetchPreviousPage` methods on the hook result object to trigger fetches forwards and backwards. These will always calculate the next or previous page param based on the current cached pages and the provided `getNext/PreviousPageParam` callbacks defined in the endpoint.
+ *
+ *
+ * #### Features
+ *
+ * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Caches multiple pages worth of responses, and provides methods to trigger more page fetches forwards and backwards
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseInfiniteQuery<D extends InfiniteQueryDefinition<any, any, any, any, any>> = <R extends Record<string, any> = UseInfiniteQueryStateDefaultResult<D>>(arg: InfiniteQueryArgFrom<D> | SkipToken, options?: UseInfiniteQuerySubscriptionOptions<D> & UseInfiniteQueryStateOptions<D, R>) => UseInfiniteQueryHookResult<D, R> & Pick<UseInfiniteQuerySubscriptionResult<D>, 'fetchNextPage' | 'fetchPreviousPage'>;
+type TypedUseInfiniteQuery<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = UseInfiniteQuery<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+/**
+ * A React hook that reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.
+ *
+ * Note that this hook does not trigger fetching new data. For that use-case, see [`useInfiniteQuery`](#useinfinitequery) or [`useInfiniteQuerySubscription`](#useinfinitequerysubscription).
+ *
+ * #### Features
+ *
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseInfiniteQueryState<D extends InfiniteQueryDefinition<any, any, any, any, any>> = <R extends Record<string, any> = UseInfiniteQueryStateDefaultResult<D>>(arg: InfiniteQueryArgFrom<D> | SkipToken, options?: UseInfiniteQueryStateOptions<D, R>) => UseInfiniteQueryStateResult<D, R>;
+type TypedUseInfiniteQueryState<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = UseInfiniteQueryState<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+/**
+ * A React hook that automatically triggers fetches of data from an endpoint, and 'subscribes' the component to the cached data. Additionally, it will cache multiple "pages" worth of responses within a single cache entry, and allows fetching more pages forwards and backwards from the current cached pages.
+ *
+ * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already.
+ *
+ * Note that this hook does not return a request status or cached data. For that use-case, see [`useInfiniteQuery`](#useinfinitequery) or [`useInfiniteQueryState`](#useinfinitequerystate).
+ *
+ * #### Features
+ *
+ * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Caches multiple pages worth of responses, and provides methods to trigger more page fetches forwards and backwards
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met
+ */
+type UseInfiniteQuerySubscription<D extends InfiniteQueryDefinition<any, any, any, any, any>> = (arg: InfiniteQueryArgFrom<D> | SkipToken, options?: UseInfiniteQuerySubscriptionOptions<D>) => UseInfiniteQuerySubscriptionResult<D>;
+type UseInfiniteQueryHookResult<D extends InfiniteQueryDefinition<any, any, any, any, any>, R = UseInfiniteQueryStateDefaultResult<D>> = UseInfiniteQueryStateResult<D, R> & Pick<UseInfiniteQuerySubscriptionResult<D>, 'refetch'>;
+type TypedUseInfiniteQueryHookResult<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, R extends Record<string, any> = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = UseInfiniteQueryHookResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>, R>;
+type UseInfiniteQueryStateOptions<D extends InfiniteQueryDefinition<any, any, any, any, any>, R extends Record<string, any>> = {
+    /**
+     * Prevents a query from automatically running.
+     *
+     * @remarks
+     * When skip is true:
+     *
+     * - **If the query has cached data:**
+     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+     *   * The query will have a status of `uninitialized`
+     *   * If `skip: false` is set after skipping the initial load, the cached result will be used
+     * - **If the query does not have cached data:**
+     *   * The query will have a status of `uninitialized`
+     *   * The query will not exist in the state when viewed with the dev tools
+     *   * The query will not automatically fetch on mount
+     *   * The query will not automatically run when additional components with the same query are added that do run
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Skip example"
+     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+     *     skip,
+     *   });
+     *
+     *   return (
+     *     <div>
+     *       {name} - {status}
+     *     </div>
+     *   );
+     * };
+     * ```
+     */
+    skip?: boolean;
+    /**
+     * `selectFromResult` allows you to get a specific segment from a query result in a performant manner.
+     * When using this feature, the component will not rerender unless the underlying data of the selected item has changed.
+     * If the selected item is one element in a larger collection, it will disregard changes to elements in the same collection.
+     * Note that this should always return an object (not a primitive), as RTKQ adds fields to the return value.
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using selectFromResult to extract a single result"
+     * function PostsList() {
+     *   const { data: posts } = api.useGetPostsQuery();
+     *
+     *   return (
+     *     <ul>
+     *       {posts?.data?.map((post) => (
+     *         <PostById key={post.id} id={post.id} />
+     *       ))}
+     *     </ul>
+     *   );
+     * }
+     *
+     * function PostById({ id }: { id: number }) {
+     *   // Will select the post with the given id, and will only rerender if the given posts data changes
+     *   const { post } = api.useGetPostsQuery(undefined, {
+     *     selectFromResult: ({ data }) => ({ post: data?.find((post) => post.id === id) }),
+     *   });
+     *
+     *   return <li>{post?.name}</li>;
+     * }
+     * ```
+     */
+    selectFromResult?: InfiniteQueryStateSelector<R, D>;
+};
+type TypedUseInfiniteQueryStateOptions<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, SelectedResult extends Record<string, any> = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = UseInfiniteQueryStateOptions<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>, SelectedResult>;
+type UseInfiniteQueryStateResult<D extends InfiniteQueryDefinition<any, any, any, any, any>, R = UseInfiniteQueryStateDefaultResult<D>> = TSHelpersNoInfer<R>;
+type TypedUseInfiniteQueryStateResult<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, R = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = UseInfiniteQueryStateResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>, R>;
+type UseInfiniteQueryStateBaseResult<D extends InfiniteQueryDefinition<any, any, any, any, any>> = InfiniteQuerySubState<D> & {
+    /**
+     * Where `data` tries to hold data as much as possible, also re-using
+     * data from the last arguments passed into the hook, this property
+     * will always contain the received data from the query, for the current query arguments.
+     */
+    currentData?: InfiniteData<ResultTypeFrom<D>, PageParamFrom<D>>;
+    /**
+     * Query has not started yet.
+     */
+    isUninitialized: false;
+    /**
+     * Query is currently loading for the first time. No data yet.
+     */
+    isLoading: false;
+    /**
+     * Query is currently fetching, but might have data from an earlier request.
+     */
+    isFetching: false;
+    /**
+     * Query has data from a successful load.
+     */
+    isSuccess: false;
+    /**
+     * Query is currently in "error" state.
+     */
+    isError: false;
+    hasNextPage: false;
+    hasPreviousPage: false;
+    isFetchingNextPage: false;
+    isFetchingPreviousPage: false;
+};
+type UseInfiniteQueryStateDefaultResult<D extends InfiniteQueryDefinition<any, any, any, any, any>> = TSHelpersId<TSHelpersOverride<Extract<UseInfiniteQueryStateBaseResult<D>, {
+    status: QueryStatus.uninitialized;
+}>, {
+    isUninitialized: true;
+}> | TSHelpersOverride<UseInfiniteQueryStateBaseResult<D>, {
+    isLoading: true;
+    isFetching: boolean;
+    data: undefined;
+} | ({
+    isSuccess: true;
+    isFetching: true;
+    error: undefined;
+} & Required<Pick<UseInfiniteQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp'>>) | ({
+    isSuccess: true;
+    isFetching: false;
+    error: undefined;
+} & Required<Pick<UseInfiniteQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp' | 'currentData'>>) | ({
+    isError: true;
+} & Required<Pick<UseInfiniteQueryStateBaseResult<D>, 'error'>>)>> & {
+    /**
+     * @deprecated Included for completeness, but discouraged.
+     * Please use the `isLoading`, `isFetching`, `isSuccess`, `isError`
+     * and `isUninitialized` flags instead
+     */
+    status: QueryStatus;
+};
+type MutationStateSelector<R extends Record<string, any>, D extends MutationDefinition<any, any, any, any>> = (state: MutationResultSelectorResult<D>) => R;
+type UseMutationStateOptions<D extends MutationDefinition<any, any, any, any>, R extends Record<string, any>> = {
+    selectFromResult?: MutationStateSelector<R, D>;
+    fixedCacheKey?: string;
+};
+type UseMutationStateResult<D extends MutationDefinition<any, any, any, any>, R> = TSHelpersNoInfer<R> & {
+    originalArgs?: QueryArgFrom<D>;
+    /**
+     * Resets the hook state to its initial `uninitialized` state.
+     * This will also remove the last result from the cache.
+     */
+    reset: () => void;
+};
+/**
+ * Helper type to manually type the result
+ * of the `useMutation` hook in userland code.
+ */
+type TypedUseMutationResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = MutationResultSelectorResult<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = UseMutationStateResult<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>, R>;
+/**
+ * A React hook that lets you trigger an update request for a given endpoint, and subscribes the component to read the request status from the Redux store. The component will re-render as the loading status changes.
+ *
+ * #### Features
+ *
+ * - Manual control over firing a request to alter data on the server or possibly invalidate the cache
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseMutation<D extends MutationDefinition<any, any, any, any>> = <R extends Record<string, any> = MutationResultSelectorResult<D>>(options?: UseMutationStateOptions<D, R>) => readonly [MutationTrigger<D>, UseMutationStateResult<D, R>];
+type TypedUseMutation<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseMutation<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type MutationTrigger<D extends MutationDefinition<any, any, any, any>> = {
+    /**
+     * Triggers the mutation and returns a Promise.
+     * @remarks
+     * If you need to access the error or success payload immediately after a mutation, you can chain .unwrap().
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using .unwrap with async await"
+     * try {
+     *   const payload = await addPost({ id: 1, name: 'Example' }).unwrap();
+     *   console.log('fulfilled', payload)
+     * } catch (error) {
+     *   console.error('rejected', error);
+     * }
+     * ```
+     */
+    (arg: QueryArgFrom<D>): MutationActionCreatorResult<D>;
+};
+type TypedMutationTrigger<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = MutationTrigger<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+
+type QueryHookNames<Definitions extends EndpointDefinitions> = {
+    [K in keyof Definitions as Definitions[K] extends {
+        type: DefinitionType.query;
+    } ? `use${Capitalize<K & string>}Query` : never]: UseQuery<Extract<Definitions[K], QueryDefinition<any, any, any, any>>>;
+};
+type LazyQueryHookNames<Definitions extends EndpointDefinitions> = {
+    [K in keyof Definitions as Definitions[K] extends {
+        type: DefinitionType.query;
+    } ? `useLazy${Capitalize<K & string>}Query` : never]: UseLazyQuery<Extract<Definitions[K], QueryDefinition<any, any, any, any>>>;
+};
+type InfiniteQueryHookNames<Definitions extends EndpointDefinitions> = {
+    [K in keyof Definitions as Definitions[K] extends {
+        type: DefinitionType.infinitequery;
+    } ? `use${Capitalize<K & string>}InfiniteQuery` : never]: UseInfiniteQuery<Extract<Definitions[K], InfiniteQueryDefinition<any, any, any, any, any>>>;
+};
+type MutationHookNames<Definitions extends EndpointDefinitions> = {
+    [K in keyof Definitions as Definitions[K] extends {
+        type: DefinitionType.mutation;
+    } ? `use${Capitalize<K & string>}Mutation` : never]: UseMutation<Extract<Definitions[K], MutationDefinition<any, any, any, any>>>;
+};
+type HooksWithUniqueNames<Definitions extends EndpointDefinitions> = QueryHookNames<Definitions> & LazyQueryHookNames<Definitions> & InfiniteQueryHookNames<Definitions> & MutationHookNames<Definitions>;
+
+export declare const reactHooksModuleName: unique symbol;
+type ReactHooksModule = typeof reactHooksModuleName;
+declare module '@reduxjs/toolkit/query' {
+    interface ApiModules<BaseQuery extends BaseQueryFn, Definitions extends EndpointDefinitions, ReducerPath extends string, TagTypes extends string> {
+        [reactHooksModuleName]: {
+            /**
+             *  Endpoints based on the input endpoints provided to `createApi`, containing `select`, `hooks` and `action matchers`.
+             */
+            endpoints: {
+                [K in keyof Definitions]: Definitions[K] extends QueryDefinition<any, any, any, any, any> ? QueryHooks<Definitions[K]> : Definitions[K] extends MutationDefinition<any, any, any, any, any> ? MutationHooks<Definitions[K]> : Definitions[K] extends InfiniteQueryDefinition<any, any, any, any, any> ? InfiniteQueryHooks<Definitions[K]> : never;
+            };
+            /**
+             * A hook that accepts a string endpoint name, and provides a callback that when called, pre-fetches the data for that endpoint.
+             */
+            usePrefetch<EndpointName extends QueryKeys<Definitions>>(endpointName: EndpointName, options?: PrefetchOptions): (arg: QueryArgFrom<Definitions[EndpointName]>, options?: PrefetchOptions) => void;
+        } & HooksWithUniqueNames<Definitions>;
+    }
+}
+type RR = typeof react_redux;
+interface ReactHooksModuleOptions {
+    /**
+     * The hooks from React Redux to be used
+     */
+    hooks?: {
+        /**
+         * The version of the `useDispatch` hook to be used
+         */
+        useDispatch: RR['useDispatch'];
+        /**
+         * The version of the `useSelector` hook to be used
+         */
+        useSelector: RR['useSelector'];
+        /**
+         * The version of the `useStore` hook to be used
+         */
+        useStore: RR['useStore'];
+    };
+    /**
+     * The version of the `batchedUpdates` function to be used
+     */
+    batch?: RR['batch'];
+    /**
+     * Enables performing asynchronous tasks immediately within a render.
+     *
+     * @example
+     *
+     * ```ts
+     * import {
+     *   buildCreateApi,
+     *   coreModule,
+     *   reactHooksModule
+     * } from '@reduxjs/toolkit/query/react'
+     *
+     * const createApi = buildCreateApi(
+     *   coreModule(),
+     *   reactHooksModule({ unstable__sideEffectsInRender: true })
+     * )
+     * ```
+     */
+    unstable__sideEffectsInRender?: boolean;
+    /**
+     * A selector creator (usually from `reselect`, or matching the same signature)
+     */
+    createSelector?: typeof createSelector;
+}
+/**
+ * Creates a module that generates react hooks from endpoints, for use with `buildCreateApi`.
+ *
+ *  @example
+ * ```ts
+ * const MyContext = React.createContext<ReactReduxContextValue | null>(null);
+ * const customCreateApi = buildCreateApi(
+ *   coreModule(),
+ *   reactHooksModule({
+ *     hooks: {
+ *       useDispatch: createDispatchHook(MyContext),
+ *       useSelector: createSelectorHook(MyContext),
+ *       useStore: createStoreHook(MyContext)
+ *     }
+ *   })
+ * );
+ * ```
+ *
+ * @returns A module for use with `buildCreateApi`
+ */
+declare const reactHooksModule: ({ batch, hooks, createSelector, unstable__sideEffectsInRender, ...rest }?: ReactHooksModuleOptions) => Module<ReactHooksModule>;
+
+/**
+ * Can be used as a `Provider` if you **do not already have a Redux store**.
+ *
+ * @example
+ * ```tsx
+ * // codeblock-meta no-transpile title="Basic usage - wrap your App with ApiProvider"
+ * import * as React from 'react';
+ * import { ApiProvider } from '@reduxjs/toolkit/query/react';
+ * import { Pokemon } from './features/Pokemon';
+ *
+ * function App() {
+ *   return (
+ *     <ApiProvider api={api}>
+ *       <Pokemon />
+ *     </ApiProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @remarks
+ * Using this together with an existing redux store, both will
+ * conflict with each other - please use the traditional redux setup
+ * in that case.
+ */
+declare function ApiProvider(props: {
+    children: any;
+    api: Api<any, {}, any, any>;
+    setupListeners?: Parameters<typeof setupListeners>[1] | false;
+    context?: Context<ReactReduxContextValue | null>;
+}): React.JSX.Element;
+
+declare const createApi: _reduxjs_toolkit_query.CreateApi<typeof _reduxjs_toolkit_query.coreModuleName | typeof reactHooksModuleName>;
+
+export { ApiProvider, type TypedInfiniteQueryStateSelector, type TypedLazyInfiniteQueryTrigger, type TypedLazyQueryTrigger, type TypedMutationTrigger, type TypedQueryStateSelector, type TypedUseInfiniteQuery, type TypedUseInfiniteQueryHookResult, type TypedUseInfiniteQueryState, type TypedUseInfiniteQueryStateOptions, type TypedUseInfiniteQueryStateResult, type TypedUseInfiniteQuerySubscription, type TypedUseInfiniteQuerySubscriptionResult, type TypedUseLazyQuery, type TypedUseLazyQueryStateResult, type TypedUseLazyQuerySubscription, type TypedUseMutation, type TypedUseMutationResult, type TypedUseQuery, type TypedUseQueryHookResult, type TypedUseQueryState, type TypedUseQueryStateOptions, type TypedUseQueryStateResult, type TypedUseQuerySubscription, type TypedUseQuerySubscriptionResult, createApi, reactHooksModule };

frontend/node_modules/@reduxjs/toolkit/dist/query/react/index.d.ts

@@ -0,0 +1,959 @@
+import * as _reduxjs_toolkit_query from '@reduxjs/toolkit/query';
+import { QueryDefinition, TSHelpersId, TSHelpersOverride, QuerySubState, ResultTypeFrom, QueryStatus, QueryArgFrom, SkipToken, SubscriptionOptions, TSHelpersNoInfer, QueryActionCreatorResult, MutationDefinition, MutationResultSelectorResult, MutationActionCreatorResult, InfiniteQueryDefinition, InfiniteQuerySubState, PageParamFrom, InfiniteQueryArgFrom, InfiniteQueryActionCreatorResult, BaseQueryFn, EndpointDefinitions, DefinitionType, QueryKeys, PrefetchOptions, Module, Api, setupListeners } from '@reduxjs/toolkit/query';
+export * from '@reduxjs/toolkit/query';
+import * as react_redux from 'react-redux';
+import { ReactReduxContextValue } from 'react-redux';
+import { createSelector } from 'reselect';
+import * as React from 'react';
+import { Context } from 'react';
+
+type InfiniteData<DataType, PageParam> = {
+    pages: Array<DataType>;
+    pageParams: Array<PageParam>;
+};
+type InfiniteQueryDirection = 'forward' | 'backward';
+
+export declare const UNINITIALIZED_VALUE: unique symbol;
+type UninitializedValue = typeof UNINITIALIZED_VALUE;
+
+type QueryHooks<Definition extends QueryDefinition<any, any, any, any, any>> = {
+    useQuery: UseQuery<Definition>;
+    useLazyQuery: UseLazyQuery<Definition>;
+    useQuerySubscription: UseQuerySubscription<Definition>;
+    useLazyQuerySubscription: UseLazyQuerySubscription<Definition>;
+    useQueryState: UseQueryState<Definition>;
+};
+type InfiniteQueryHooks<Definition extends InfiniteQueryDefinition<any, any, any, any, any>> = {
+    useInfiniteQuery: UseInfiniteQuery<Definition>;
+    useInfiniteQuerySubscription: UseInfiniteQuerySubscription<Definition>;
+    useInfiniteQueryState: UseInfiniteQueryState<Definition>;
+};
+type MutationHooks<Definition extends MutationDefinition<any, any, any, any, any>> = {
+    useMutation: UseMutation<Definition>;
+};
+/**
+ * A React hook that automatically triggers fetches of data from an endpoint, 'subscribes' the component to the cached data, and reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.
+ *
+ * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already, and the hook will return the data for that query arg once it's available.
+ *
+ * This hook combines the functionality of both [`useQueryState`](#usequerystate) and [`useQuerySubscription`](#usequerysubscription) together, and is intended to be used in the majority of situations.
+ *
+ * #### Features
+ *
+ * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseQuery<D extends QueryDefinition<any, any, any, any>> = <R extends Record<string, any> = UseQueryStateDefaultResult<D>>(arg: QueryArgFrom<D> | SkipToken, options?: UseQuerySubscriptionOptions & UseQueryStateOptions<D, R>) => UseQueryHookResult<D, R>;
+type TypedUseQuery<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseQuery<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type UseQueryHookResult<D extends QueryDefinition<any, any, any, any>, R = UseQueryStateDefaultResult<D>> = UseQueryStateResult<D, R> & UseQuerySubscriptionResult<D>;
+/**
+ * Helper type to manually type the result
+ * of the `useQuery` hook in userland code.
+ */
+type TypedUseQueryHookResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = TypedUseQueryStateResult<ResultType, QueryArg, BaseQuery, R> & TypedUseQuerySubscriptionResult<ResultType, QueryArg, BaseQuery>;
+type UseQuerySubscriptionOptions = SubscriptionOptions & {
+    /**
+     * Prevents a query from automatically running.
+     *
+     * @remarks
+     * When `skip` is true (or `skipToken` is passed in as `arg`):
+     *
+     * - **If the query has cached data:**
+     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+     *   * The query will have a status of `uninitialized`
+     *   * If `skip: false` is set after the initial load, the cached result will be used
+     * - **If the query does not have cached data:**
+     *   * The query will have a status of `uninitialized`
+     *   * The query will not exist in the state when viewed with the dev tools
+     *   * The query will not automatically fetch on mount
+     *   * The query will not automatically run when additional components with the same query are added that do run
+     *
+     * @example
+     * ```tsx
+     * // codeblock-meta no-transpile title="Skip example"
+     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+     *     skip,
+     *   });
+     *
+     *   return (
+     *     <div>
+     *       {name} - {status}
+     *     </div>
+     *   );
+     * };
+     * ```
+     */
+    skip?: boolean;
+    /**
+     * Defaults to `false`. This setting allows you to control whether if a cached result is already available, RTK Query will only serve a cached result, or if it should `refetch` when set to `true` or if an adequate amount of time has passed since the last successful query result.
+     * - `false` - Will not cause a query to be performed _unless_ it does not exist yet.
+     * - `true` - Will always refetch when a new subscriber to a query is added. Behaves the same as calling the `refetch` callback or passing `forceRefetch: true` in the action creator.
+     * - `number` - **Value is in seconds**. If a number is provided and there is an existing query in the cache, it will compare the current time vs the last fulfilled timestamp, and only refetch if enough time has elapsed.
+     *
+     * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
+     */
+    refetchOnMountOrArgChange?: boolean | number;
+};
+/**
+ * A React hook that automatically triggers fetches of data from an endpoint, and 'subscribes' the component to the cached data.
+ *
+ * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already.
+ *
+ * Note that this hook does not return a request status or cached data. For that use-case, see [`useQuery`](#usequery) or [`useQueryState`](#usequerystate).
+ *
+ * #### Features
+ *
+ * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met
+ */
+type UseQuerySubscription<D extends QueryDefinition<any, any, any, any>> = (arg: QueryArgFrom<D> | SkipToken, options?: UseQuerySubscriptionOptions) => UseQuerySubscriptionResult<D>;
+type TypedUseQuerySubscription<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseQuerySubscription<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type UseQuerySubscriptionResult<D extends QueryDefinition<any, any, any, any>> = Pick<QueryActionCreatorResult<D>, 'refetch'>;
+/**
+ * Helper type to manually type the result
+ * of the `useQuerySubscription` hook in userland code.
+ */
+type TypedUseQuerySubscriptionResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseQuerySubscriptionResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type UseLazyQueryLastPromiseInfo<D extends QueryDefinition<any, any, any, any>> = {
+    lastArg: QueryArgFrom<D>;
+};
+/**
+ * A React hook similar to [`useQuery`](#usequery), but with manual control over when the data fetching occurs.
+ *
+ * This hook includes the functionality of [`useLazyQuerySubscription`](#uselazyquerysubscription).
+ *
+ * #### Features
+ *
+ * - Manual control over firing a request to retrieve data
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met and the fetch has been manually called at least once
+ *
+ * #### Note
+ *
+ * When the trigger function returned from a LazyQuery is called, it always initiates a new request to the server even if there is cached data. Set `preferCacheValue`(the second argument to the function) as `true` if you want it to immediately return a cached value if one exists.
+ */
+type UseLazyQuery<D extends QueryDefinition<any, any, any, any>> = <R extends Record<string, any> = UseQueryStateDefaultResult<D>>(options?: SubscriptionOptions & Omit<UseQueryStateOptions<D, R>, 'skip'>) => [
+    LazyQueryTrigger<D>,
+    UseLazyQueryStateResult<D, R>,
+    UseLazyQueryLastPromiseInfo<D>
+];
+type TypedUseLazyQuery<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseLazyQuery<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type UseLazyQueryStateResult<D extends QueryDefinition<any, any, any, any>, R = UseQueryStateDefaultResult<D>> = UseQueryStateResult<D, R> & {
+    /**
+     * Resets the hook state to its initial `uninitialized` state.
+     * This will also remove the last result from the cache.
+     */
+    reset: () => void;
+};
+/**
+ * Helper type to manually type the result
+ * of the `useLazyQuery` hook in userland code.
+ */
+type TypedUseLazyQueryStateResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = UseLazyQueryStateResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>, R>;
+type LazyQueryTrigger<D extends QueryDefinition<any, any, any, any>> = {
+    /**
+     * Triggers a lazy query.
+     *
+     * By default, this will start a new request even if there is already a value in the cache.
+     * If you want to use the cache value and only start a request if there is no cache value, set the second argument to `true`.
+     *
+     * @remarks
+     * If you need to access the error or success payload immediately after a lazy query, you can chain .unwrap().
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using .unwrap with async await"
+     * try {
+     *   const payload = await getUserById(1).unwrap();
+     *   console.log('fulfilled', payload)
+     * } catch (error) {
+     *   console.error('rejected', error);
+     * }
+     * ```
+     */
+    (arg: QueryArgFrom<D>, preferCacheValue?: boolean): QueryActionCreatorResult<D>;
+};
+type TypedLazyQueryTrigger<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = LazyQueryTrigger<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+/**
+ * A React hook similar to [`useQuerySubscription`](#usequerysubscription), but with manual control over when the data fetching occurs.
+ *
+ * Note that this hook does not return a request status or cached data. For that use-case, see [`useLazyQuery`](#uselazyquery).
+ *
+ * #### Features
+ *
+ * - Manual control over firing a request to retrieve data
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met and the fetch has been manually called at least once
+ */
+type UseLazyQuerySubscription<D extends QueryDefinition<any, any, any, any>> = (options?: SubscriptionOptions) => readonly [
+    LazyQueryTrigger<D>,
+    QueryArgFrom<D> | UninitializedValue,
+    {
+        reset: () => void;
+    }
+];
+type TypedUseLazyQuerySubscription<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseLazyQuerySubscription<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+/**
+ * @internal
+ */
+type QueryStateSelector<R extends Record<string, any>, D extends QueryDefinition<any, any, any, any>> = (state: UseQueryStateDefaultResult<D>) => R;
+/**
+ * Provides a way to define a strongly-typed version of
+ * {@linkcode QueryStateSelector} for use with a specific query.
+ * This is useful for scenarios where you want to create a "pre-typed"
+ * {@linkcode UseQueryStateOptions.selectFromResult | selectFromResult}
+ * function.
+ *
+ * @example
+ * <caption>#### __Create a strongly-typed `selectFromResult` selector function__</caption>
+ *
+ * ```tsx
+ * import type { TypedQueryStateSelector } from '@reduxjs/toolkit/query/react'
+ * import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+ *
+ * type Post = {
+ *   id: number
+ *   title: string
+ * }
+ *
+ * type PostsApiResponse = {
+ *   posts: Post[]
+ *   total: number
+ *   skip: number
+ *   limit: number
+ * }
+ *
+ * type QueryArgument = number | undefined
+ *
+ * type BaseQueryFunction = ReturnType<typeof fetchBaseQuery>
+ *
+ * type SelectedResult = Pick<PostsApiResponse, 'posts'>
+ *
+ * const postsApiSlice = createApi({
+ *   baseQuery: fetchBaseQuery({ baseUrl: 'https://dummyjson.com/posts' }),
+ *   reducerPath: 'postsApi',
+ *   tagTypes: ['Posts'],
+ *   endpoints: (build) => ({
+ *     getPosts: build.query<PostsApiResponse, QueryArgument>({
+ *       query: (limit = 5) => `?limit=${limit}&select=title`,
+ *     }),
+ *   }),
+ * })
+ *
+ * const { useGetPostsQuery } = postsApiSlice
+ *
+ * function PostById({ id }: { id: number }) {
+ *   const { post } = useGetPostsQuery(undefined, {
+ *     selectFromResult: (state) => ({
+ *       post: state.data?.posts.find((post) => post.id === id),
+ *     }),
+ *   })
+ *
+ *   return <li>{post?.title}</li>
+ * }
+ *
+ * const EMPTY_ARRAY: Post[] = []
+ *
+ * const typedSelectFromResult: TypedQueryStateSelector<
+ *   PostsApiResponse,
+ *   QueryArgument,
+ *   BaseQueryFunction,
+ *   SelectedResult
+ * > = (state) => ({ posts: state.data?.posts ?? EMPTY_ARRAY })
+ *
+ * function PostsList() {
+ *   const { posts } = useGetPostsQuery(undefined, {
+ *     selectFromResult: typedSelectFromResult,
+ *   })
+ *
+ *   return (
+ *     <div>
+ *       <ul>
+ *         {posts.map((post) => (
+ *           <PostById key={post.id} id={post.id} />
+ *         ))}
+ *       </ul>
+ *     </div>
+ *   )
+ * }
+ * ```
+ *
+ * @template ResultType - The type of the result `data` returned by the query.
+ * @template QueryArgumentType - The type of the argument passed into the query.
+ * @template BaseQueryFunctionType - The type of the base query function being used.
+ * @template SelectedResultType - The type of the selected result returned by the __`selectFromResult`__ function.
+ *
+ * @since 2.3.0
+ * @public
+ */
+type TypedQueryStateSelector<ResultType, QueryArgumentType, BaseQueryFunctionType extends BaseQueryFn, SelectedResultType extends Record<string, any> = UseQueryStateDefaultResult<QueryDefinition<QueryArgumentType, BaseQueryFunctionType, string, ResultType, string>>> = QueryStateSelector<SelectedResultType, QueryDefinition<QueryArgumentType, BaseQueryFunctionType, string, ResultType, string>>;
+/**
+ * A React hook that reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.
+ *
+ * Note that this hook does not trigger fetching new data. For that use-case, see [`useQuery`](#usequery) or [`useQuerySubscription`](#usequerysubscription).
+ *
+ * #### Features
+ *
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseQueryState<D extends QueryDefinition<any, any, any, any>> = <R extends Record<string, any> = UseQueryStateDefaultResult<D>>(arg: QueryArgFrom<D> | SkipToken, options?: UseQueryStateOptions<D, R>) => UseQueryStateResult<D, R>;
+type TypedUseQueryState<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseQueryState<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+/**
+ * @internal
+ */
+type UseQueryStateOptions<D extends QueryDefinition<any, any, any, any>, R extends Record<string, any>> = {
+    /**
+     * Prevents a query from automatically running.
+     *
+     * @remarks
+     * When skip is true:
+     *
+     * - **If the query has cached data:**
+     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+     *   * The query will have a status of `uninitialized`
+     *   * If `skip: false` is set after skipping the initial load, the cached result will be used
+     * - **If the query does not have cached data:**
+     *   * The query will have a status of `uninitialized`
+     *   * The query will not exist in the state when viewed with the dev tools
+     *   * The query will not automatically fetch on mount
+     *   * The query will not automatically run when additional components with the same query are added that do run
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Skip example"
+     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+     *     skip,
+     *   });
+     *
+     *   return (
+     *     <div>
+     *       {name} - {status}
+     *     </div>
+     *   );
+     * };
+     * ```
+     */
+    skip?: boolean;
+    /**
+     * `selectFromResult` allows you to get a specific segment from a query result in a performant manner.
+     * When using this feature, the component will not rerender unless the underlying data of the selected item has changed.
+     * If the selected item is one element in a larger collection, it will disregard changes to elements in the same collection.
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using selectFromResult to extract a single result"
+     * function PostsList() {
+     *   const { data: posts } = api.useGetPostsQuery();
+     *
+     *   return (
+     *     <ul>
+     *       {posts?.data?.map((post) => (
+     *         <PostById key={post.id} id={post.id} />
+     *       ))}
+     *     </ul>
+     *   );
+     * }
+     *
+     * function PostById({ id }: { id: number }) {
+     *   // Will select the post with the given id, and will only rerender if the given posts data changes
+     *   const { post } = api.useGetPostsQuery(undefined, {
+     *     selectFromResult: ({ data }) => ({ post: data?.find((post) => post.id === id) }),
+     *   });
+     *
+     *   return <li>{post?.name}</li>;
+     * }
+     * ```
+     */
+    selectFromResult?: QueryStateSelector<R, D>;
+};
+/**
+ * Provides a way to define a "pre-typed" version of
+ * {@linkcode UseQueryStateOptions} with specific options for a given query.
+ * This is particularly useful for setting default query behaviors such as
+ * refetching strategies, which can be overridden as needed.
+ *
+ * @example
+ * <caption>#### __Create a `useQuery` hook with default options__</caption>
+ *
+ * ```ts
+ * import type {
+ *   SubscriptionOptions,
+ *   TypedUseQueryStateOptions,
+ * } from '@reduxjs/toolkit/query/react'
+ * import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+ *
+ * type Post = {
+ *   id: number
+ *   name: string
+ * }
+ *
+ * const api = createApi({
+ *   baseQuery: fetchBaseQuery({ baseUrl: '/' }),
+ *   tagTypes: ['Post'],
+ *   endpoints: (build) => ({
+ *     getPosts: build.query<Post[], void>({
+ *       query: () => 'posts',
+ *     }),
+ *   }),
+ * })
+ *
+ * const { useGetPostsQuery } = api
+ *
+ * export const useGetPostsQueryWithDefaults = <
+ *   SelectedResult extends Record<string, any>,
+ * >(
+ *   overrideOptions: TypedUseQueryStateOptions<
+ *     Post[],
+ *     void,
+ *     ReturnType<typeof fetchBaseQuery>,
+ *     SelectedResult
+ *   > &
+ *     SubscriptionOptions,
+ * ) =>
+ *   useGetPostsQuery(undefined, {
+ *     // Insert default options here
+ *
+ *     refetchOnMountOrArgChange: true,
+ *     refetchOnFocus: true,
+ *     ...overrideOptions,
+ *   })
+ * ```
+ *
+ * @template ResultType - The type of the result `data` returned by the query.
+ * @template QueryArg - The type of the argument passed into the query.
+ * @template BaseQuery - The type of the base query function being used.
+ * @template SelectedResult - The type of the selected result returned by the __`selectFromResult`__ function.
+ *
+ * @since 2.2.8
+ * @public
+ */
+type TypedUseQueryStateOptions<ResultType, QueryArg, BaseQuery extends BaseQueryFn, SelectedResult extends Record<string, any> = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = UseQueryStateOptions<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>, SelectedResult>;
+type UseQueryStateResult<_ extends QueryDefinition<any, any, any, any>, R> = TSHelpersNoInfer<R>;
+/**
+ * Helper type to manually type the result
+ * of the `useQueryState` hook in userland code.
+ */
+type TypedUseQueryStateResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = UseQueryStateDefaultResult<QueryDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = TSHelpersNoInfer<R>;
+type UseQueryStateBaseResult<D extends QueryDefinition<any, any, any, any>> = QuerySubState<D> & {
+    /**
+     * Where `data` tries to hold data as much as possible, also re-using
+     * data from the last arguments passed into the hook, this property
+     * will always contain the received data from the query, for the current query arguments.
+     */
+    currentData?: ResultTypeFrom<D>;
+    /**
+     * Query has not started yet.
+     */
+    isUninitialized: false;
+    /**
+     * Query is currently loading for the first time. No data yet.
+     */
+    isLoading: false;
+    /**
+     * Query is currently fetching, but might have data from an earlier request.
+     */
+    isFetching: false;
+    /**
+     * Query has data from a successful load.
+     */
+    isSuccess: false;
+    /**
+     * Query is currently in "error" state.
+     */
+    isError: false;
+};
+type UseQueryStateDefaultResult<D extends QueryDefinition<any, any, any, any>> = TSHelpersId<TSHelpersOverride<Extract<UseQueryStateBaseResult<D>, {
+    status: QueryStatus.uninitialized;
+}>, {
+    isUninitialized: true;
+}> | TSHelpersOverride<UseQueryStateBaseResult<D>, {
+    isLoading: true;
+    isFetching: boolean;
+    data: undefined;
+} | ({
+    isSuccess: true;
+    isFetching: true;
+    error: undefined;
+} & Required<Pick<UseQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp'>>) | ({
+    isSuccess: true;
+    isFetching: false;
+    error: undefined;
+} & Required<Pick<UseQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp' | 'currentData'>>) | ({
+    isError: true;
+} & Required<Pick<UseQueryStateBaseResult<D>, 'error'>>)>> & {
+    /**
+     * @deprecated Included for completeness, but discouraged.
+     * Please use the `isLoading`, `isFetching`, `isSuccess`, `isError`
+     * and `isUninitialized` flags instead
+     */
+    status: QueryStatus;
+};
+type LazyInfiniteQueryTrigger<D extends InfiniteQueryDefinition<any, any, any, any, any>> = {
+    /**
+     * Triggers a lazy query.
+     *
+     * By default, this will start a new request even if there is already a value in the cache.
+     * If you want to use the cache value and only start a request if there is no cache value, set the second argument to `true`.
+     *
+     * @remarks
+     * If you need to access the error or success payload immediately after a lazy query, you can chain .unwrap().
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using .unwrap with async await"
+     * try {
+     *   const payload = await getUserById(1).unwrap();
+     *   console.log('fulfilled', payload)
+     * } catch (error) {
+     *   console.error('rejected', error);
+     * }
+     * ```
+     */
+    (arg: QueryArgFrom<D>, direction: InfiniteQueryDirection): InfiniteQueryActionCreatorResult<D>;
+};
+type TypedLazyInfiniteQueryTrigger<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = LazyInfiniteQueryTrigger<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+type UseInfiniteQuerySubscriptionOptions<D extends InfiniteQueryDefinition<any, any, any, any, any>> = SubscriptionOptions & {
+    /**
+     * Prevents a query from automatically running.
+     *
+     * @remarks
+     * When `skip` is true (or `skipToken` is passed in as `arg`):
+     *
+     * - **If the query has cached data:**
+     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+     *   * The query will have a status of `uninitialized`
+     *   * If `skip: false` is set after the initial load, the cached result will be used
+     * - **If the query does not have cached data:**
+     *   * The query will have a status of `uninitialized`
+     *   * The query will not exist in the state when viewed with the dev tools
+     *   * The query will not automatically fetch on mount
+     *   * The query will not automatically run when additional components with the same query are added that do run
+     *
+     * @example
+     * ```tsx
+     * // codeblock-meta no-transpile title="Skip example"
+     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+     *     skip,
+     *   });
+     *
+     *   return (
+     *     <div>
+     *       {name} - {status}
+     *     </div>
+     *   );
+     * };
+     * ```
+     */
+    skip?: boolean;
+    /**
+     * Defaults to `false`. This setting allows you to control whether if a cached result is already available, RTK Query will only serve a cached result, or if it should `refetch` when set to `true` or if an adequate amount of time has passed since the last successful query result.
+     * - `false` - Will not cause a query to be performed _unless_ it does not exist yet.
+     * - `true` - Will always refetch when a new subscriber to a query is added. Behaves the same as calling the `refetch` callback or passing `forceRefetch: true` in the action creator.
+     * - `number` - **Value is in seconds**. If a number is provided and there is an existing query in the cache, it will compare the current time vs the last fulfilled timestamp, and only refetch if enough time has elapsed.
+     *
+     * If you specify this option alongside `skip: true`, this **will not be evaluated** until `skip` is false.
+     */
+    refetchOnMountOrArgChange?: boolean | number;
+    initialPageParam?: PageParamFrom<D>;
+};
+type TypedUseInfiniteQuerySubscription<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = UseInfiniteQuerySubscription<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+type UseInfiniteQuerySubscriptionResult<D extends InfiniteQueryDefinition<any, any, any, any, any>> = Pick<InfiniteQueryActionCreatorResult<D>, 'refetch'> & {
+    trigger: LazyInfiniteQueryTrigger<D>;
+    fetchNextPage: () => InfiniteQueryActionCreatorResult<D>;
+    fetchPreviousPage: () => InfiniteQueryActionCreatorResult<D>;
+};
+/**
+ * Helper type to manually type the result
+ * of the `useQuerySubscription` hook in userland code.
+ */
+type TypedUseInfiniteQuerySubscriptionResult<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = UseInfiniteQuerySubscriptionResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+type InfiniteQueryStateSelector<R extends Record<string, any>, D extends InfiniteQueryDefinition<any, any, any, any, any>> = (state: UseInfiniteQueryStateDefaultResult<D>) => R;
+type TypedInfiniteQueryStateSelector<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, SelectedResult extends Record<string, any> = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = InfiniteQueryStateSelector<SelectedResult, InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+/**
+ * A React hook that automatically triggers fetches of data from an endpoint, 'subscribes' the component to the cached data, and reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.  Additionally, it will cache multiple "pages" worth of responses within a single cache entry, and allows fetching more pages forwards and backwards from the current cached pages.
+ *
+ * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already, and the hook will return the data for that query arg once it's available.
+ *
+ *  The `data` field will be a `{pages: Data[], pageParams: PageParam[]}` structure containing all fetched page responses and the corresponding page param values for each page. You may use this to render individual pages, combine all pages into a single infinite list, or other display logic as needed.
+ *
+ * This hook combines the functionality of both [`useInfiniteQueryState`](#useinfinitequerystate) and [`useInfiniteQuerySubscription`](#useinfinitequerysubscription) together, and is intended to be used in the majority of situations.
+ *
+ * As with normal query hooks, `skipToken` is a valid argument that will skip the query from executing.
+ *
+ * By default, the initial request will use the `initialPageParam` value that was defined on the infinite query endpoint. If you want to start from a different value, you can pass `initialPageParam` as part of the hook options to override that initial request value.
+ *
+ * Use the returned `fetchNextPage` and `fetchPreviousPage` methods on the hook result object to trigger fetches forwards and backwards. These will always calculate the next or previous page param based on the current cached pages and the provided `getNext/PreviousPageParam` callbacks defined in the endpoint.
+ *
+ *
+ * #### Features
+ *
+ * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Caches multiple pages worth of responses, and provides methods to trigger more page fetches forwards and backwards
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseInfiniteQuery<D extends InfiniteQueryDefinition<any, any, any, any, any>> = <R extends Record<string, any> = UseInfiniteQueryStateDefaultResult<D>>(arg: InfiniteQueryArgFrom<D> | SkipToken, options?: UseInfiniteQuerySubscriptionOptions<D> & UseInfiniteQueryStateOptions<D, R>) => UseInfiniteQueryHookResult<D, R> & Pick<UseInfiniteQuerySubscriptionResult<D>, 'fetchNextPage' | 'fetchPreviousPage'>;
+type TypedUseInfiniteQuery<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = UseInfiniteQuery<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+/**
+ * A React hook that reads the request status and cached data from the Redux store. The component will re-render as the loading status changes and the data becomes available.
+ *
+ * Note that this hook does not trigger fetching new data. For that use-case, see [`useInfiniteQuery`](#useinfinitequery) or [`useInfiniteQuerySubscription`](#useinfinitequerysubscription).
+ *
+ * #### Features
+ *
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseInfiniteQueryState<D extends InfiniteQueryDefinition<any, any, any, any, any>> = <R extends Record<string, any> = UseInfiniteQueryStateDefaultResult<D>>(arg: InfiniteQueryArgFrom<D> | SkipToken, options?: UseInfiniteQueryStateOptions<D, R>) => UseInfiniteQueryStateResult<D, R>;
+type TypedUseInfiniteQueryState<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn> = UseInfiniteQueryState<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>;
+/**
+ * A React hook that automatically triggers fetches of data from an endpoint, and 'subscribes' the component to the cached data. Additionally, it will cache multiple "pages" worth of responses within a single cache entry, and allows fetching more pages forwards and backwards from the current cached pages.
+ *
+ * The query arg is used as a cache key. Changing the query arg will tell the hook to re-fetch the data if it does not exist in the cache already.
+ *
+ * Note that this hook does not return a request status or cached data. For that use-case, see [`useInfiniteQuery`](#useinfinitequery) or [`useInfiniteQueryState`](#useinfinitequerystate).
+ *
+ * #### Features
+ *
+ * - Automatically triggers requests to retrieve data based on the hook argument and whether cached data exists by default
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Caches multiple pages worth of responses, and provides methods to trigger more page fetches forwards and backwards
+ * - Accepts polling/re-fetching options to trigger automatic re-fetches when the corresponding criteria is met
+ */
+type UseInfiniteQuerySubscription<D extends InfiniteQueryDefinition<any, any, any, any, any>> = (arg: InfiniteQueryArgFrom<D> | SkipToken, options?: UseInfiniteQuerySubscriptionOptions<D>) => UseInfiniteQuerySubscriptionResult<D>;
+type UseInfiniteQueryHookResult<D extends InfiniteQueryDefinition<any, any, any, any, any>, R = UseInfiniteQueryStateDefaultResult<D>> = UseInfiniteQueryStateResult<D, R> & Pick<UseInfiniteQuerySubscriptionResult<D>, 'refetch'>;
+type TypedUseInfiniteQueryHookResult<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, R extends Record<string, any> = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = UseInfiniteQueryHookResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>, R>;
+type UseInfiniteQueryStateOptions<D extends InfiniteQueryDefinition<any, any, any, any, any>, R extends Record<string, any>> = {
+    /**
+     * Prevents a query from automatically running.
+     *
+     * @remarks
+     * When skip is true:
+     *
+     * - **If the query has cached data:**
+     *   * The cached data **will not be used** on the initial load, and will ignore updates from any identical query until the `skip` condition is removed
+     *   * The query will have a status of `uninitialized`
+     *   * If `skip: false` is set after skipping the initial load, the cached result will be used
+     * - **If the query does not have cached data:**
+     *   * The query will have a status of `uninitialized`
+     *   * The query will not exist in the state when viewed with the dev tools
+     *   * The query will not automatically fetch on mount
+     *   * The query will not automatically run when additional components with the same query are added that do run
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Skip example"
+     * const Pokemon = ({ name, skip }: { name: string; skip: boolean }) => {
+     *   const { data, error, status } = useGetPokemonByNameQuery(name, {
+     *     skip,
+     *   });
+     *
+     *   return (
+     *     <div>
+     *       {name} - {status}
+     *     </div>
+     *   );
+     * };
+     * ```
+     */
+    skip?: boolean;
+    /**
+     * `selectFromResult` allows you to get a specific segment from a query result in a performant manner.
+     * When using this feature, the component will not rerender unless the underlying data of the selected item has changed.
+     * If the selected item is one element in a larger collection, it will disregard changes to elements in the same collection.
+     * Note that this should always return an object (not a primitive), as RTKQ adds fields to the return value.
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using selectFromResult to extract a single result"
+     * function PostsList() {
+     *   const { data: posts } = api.useGetPostsQuery();
+     *
+     *   return (
+     *     <ul>
+     *       {posts?.data?.map((post) => (
+     *         <PostById key={post.id} id={post.id} />
+     *       ))}
+     *     </ul>
+     *   );
+     * }
+     *
+     * function PostById({ id }: { id: number }) {
+     *   // Will select the post with the given id, and will only rerender if the given posts data changes
+     *   const { post } = api.useGetPostsQuery(undefined, {
+     *     selectFromResult: ({ data }) => ({ post: data?.find((post) => post.id === id) }),
+     *   });
+     *
+     *   return <li>{post?.name}</li>;
+     * }
+     * ```
+     */
+    selectFromResult?: InfiniteQueryStateSelector<R, D>;
+};
+type TypedUseInfiniteQueryStateOptions<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, SelectedResult extends Record<string, any> = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = UseInfiniteQueryStateOptions<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>, SelectedResult>;
+type UseInfiniteQueryStateResult<D extends InfiniteQueryDefinition<any, any, any, any, any>, R = UseInfiniteQueryStateDefaultResult<D>> = TSHelpersNoInfer<R>;
+type TypedUseInfiniteQueryStateResult<ResultType, QueryArg, PageParam, BaseQuery extends BaseQueryFn, R = UseInfiniteQueryStateDefaultResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>>> = UseInfiniteQueryStateResult<InfiniteQueryDefinition<QueryArg, PageParam, BaseQuery, string, ResultType, string>, R>;
+type UseInfiniteQueryStateBaseResult<D extends InfiniteQueryDefinition<any, any, any, any, any>> = InfiniteQuerySubState<D> & {
+    /**
+     * Where `data` tries to hold data as much as possible, also re-using
+     * data from the last arguments passed into the hook, this property
+     * will always contain the received data from the query, for the current query arguments.
+     */
+    currentData?: InfiniteData<ResultTypeFrom<D>, PageParamFrom<D>>;
+    /**
+     * Query has not started yet.
+     */
+    isUninitialized: false;
+    /**
+     * Query is currently loading for the first time. No data yet.
+     */
+    isLoading: false;
+    /**
+     * Query is currently fetching, but might have data from an earlier request.
+     */
+    isFetching: false;
+    /**
+     * Query has data from a successful load.
+     */
+    isSuccess: false;
+    /**
+     * Query is currently in "error" state.
+     */
+    isError: false;
+    hasNextPage: false;
+    hasPreviousPage: false;
+    isFetchingNextPage: false;
+    isFetchingPreviousPage: false;
+};
+type UseInfiniteQueryStateDefaultResult<D extends InfiniteQueryDefinition<any, any, any, any, any>> = TSHelpersId<TSHelpersOverride<Extract<UseInfiniteQueryStateBaseResult<D>, {
+    status: QueryStatus.uninitialized;
+}>, {
+    isUninitialized: true;
+}> | TSHelpersOverride<UseInfiniteQueryStateBaseResult<D>, {
+    isLoading: true;
+    isFetching: boolean;
+    data: undefined;
+} | ({
+    isSuccess: true;
+    isFetching: true;
+    error: undefined;
+} & Required<Pick<UseInfiniteQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp'>>) | ({
+    isSuccess: true;
+    isFetching: false;
+    error: undefined;
+} & Required<Pick<UseInfiniteQueryStateBaseResult<D>, 'data' | 'fulfilledTimeStamp' | 'currentData'>>) | ({
+    isError: true;
+} & Required<Pick<UseInfiniteQueryStateBaseResult<D>, 'error'>>)>> & {
+    /**
+     * @deprecated Included for completeness, but discouraged.
+     * Please use the `isLoading`, `isFetching`, `isSuccess`, `isError`
+     * and `isUninitialized` flags instead
+     */
+    status: QueryStatus;
+};
+type MutationStateSelector<R extends Record<string, any>, D extends MutationDefinition<any, any, any, any>> = (state: MutationResultSelectorResult<D>) => R;
+type UseMutationStateOptions<D extends MutationDefinition<any, any, any, any>, R extends Record<string, any>> = {
+    selectFromResult?: MutationStateSelector<R, D>;
+    fixedCacheKey?: string;
+};
+type UseMutationStateResult<D extends MutationDefinition<any, any, any, any>, R> = TSHelpersNoInfer<R> & {
+    originalArgs?: QueryArgFrom<D>;
+    /**
+     * Resets the hook state to its initial `uninitialized` state.
+     * This will also remove the last result from the cache.
+     */
+    reset: () => void;
+};
+/**
+ * Helper type to manually type the result
+ * of the `useMutation` hook in userland code.
+ */
+type TypedUseMutationResult<ResultType, QueryArg, BaseQuery extends BaseQueryFn, R = MutationResultSelectorResult<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>>> = UseMutationStateResult<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>, R>;
+/**
+ * A React hook that lets you trigger an update request for a given endpoint, and subscribes the component to read the request status from the Redux store. The component will re-render as the loading status changes.
+ *
+ * #### Features
+ *
+ * - Manual control over firing a request to alter data on the server or possibly invalidate the cache
+ * - 'Subscribes' the component to keep cached data in the store, and 'unsubscribes' when the component unmounts
+ * - Returns the latest request status and cached data from the Redux store
+ * - Re-renders as the request status changes and data becomes available
+ */
+type UseMutation<D extends MutationDefinition<any, any, any, any>> = <R extends Record<string, any> = MutationResultSelectorResult<D>>(options?: UseMutationStateOptions<D, R>) => readonly [MutationTrigger<D>, UseMutationStateResult<D, R>];
+type TypedUseMutation<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = UseMutation<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+type MutationTrigger<D extends MutationDefinition<any, any, any, any>> = {
+    /**
+     * Triggers the mutation and returns a Promise.
+     * @remarks
+     * If you need to access the error or success payload immediately after a mutation, you can chain .unwrap().
+     *
+     * @example
+     * ```ts
+     * // codeblock-meta title="Using .unwrap with async await"
+     * try {
+     *   const payload = await addPost({ id: 1, name: 'Example' }).unwrap();
+     *   console.log('fulfilled', payload)
+     * } catch (error) {
+     *   console.error('rejected', error);
+     * }
+     * ```
+     */
+    (arg: QueryArgFrom<D>): MutationActionCreatorResult<D>;
+};
+type TypedMutationTrigger<ResultType, QueryArg, BaseQuery extends BaseQueryFn> = MutationTrigger<MutationDefinition<QueryArg, BaseQuery, string, ResultType, string>>;
+
+type QueryHookNames<Definitions extends EndpointDefinitions> = {
+    [K in keyof Definitions as Definitions[K] extends {
+        type: DefinitionType.query;
+    } ? `use${Capitalize<K & string>}Query` : never]: UseQuery<Extract<Definitions[K], QueryDefinition<any, any, any, any>>>;
+};
+type LazyQueryHookNames<Definitions extends EndpointDefinitions> = {
+    [K in keyof Definitions as Definitions[K] extends {
+        type: DefinitionType.query;
+    } ? `useLazy${Capitalize<K & string>}Query` : never]: UseLazyQuery<Extract<Definitions[K], QueryDefinition<any, any, any, any>>>;
+};
+type InfiniteQueryHookNames<Definitions extends EndpointDefinitions> = {
+    [K in keyof Definitions as Definitions[K] extends {
+        type: DefinitionType.infinitequery;
+    } ? `use${Capitalize<K & string>}InfiniteQuery` : never]: UseInfiniteQuery<Extract<Definitions[K], InfiniteQueryDefinition<any, any, any, any, any>>>;
+};
+type MutationHookNames<Definitions extends EndpointDefinitions> = {
+    [K in keyof Definitions as Definitions[K] extends {
+        type: DefinitionType.mutation;
+    } ? `use${Capitalize<K & string>}Mutation` : never]: UseMutation<Extract<Definitions[K], MutationDefinition<any, any, any, any>>>;
+};
+type HooksWithUniqueNames<Definitions extends EndpointDefinitions> = QueryHookNames<Definitions> & LazyQueryHookNames<Definitions> & InfiniteQueryHookNames<Definitions> & MutationHookNames<Definitions>;
+
+export declare const reactHooksModuleName: unique symbol;
+type ReactHooksModule = typeof reactHooksModuleName;
+declare module '@reduxjs/toolkit/query' {
+    interface ApiModules<BaseQuery extends BaseQueryFn, Definitions extends EndpointDefinitions, ReducerPath extends string, TagTypes extends string> {
+        [reactHooksModuleName]: {
+            /**
+             *  Endpoints based on the input endpoints provided to `createApi`, containing `select`, `hooks` and `action matchers`.
+             */
+            endpoints: {
+                [K in keyof Definitions]: Definitions[K] extends QueryDefinition<any, any, any, any, any> ? QueryHooks<Definitions[K]> : Definitions[K] extends MutationDefinition<any, any, any, any, any> ? MutationHooks<Definitions[K]> : Definitions[K] extends InfiniteQueryDefinition<any, any, any, any, any> ? InfiniteQueryHooks<Definitions[K]> : never;
+            };
+            /**
+             * A hook that accepts a string endpoint name, and provides a callback that when called, pre-fetches the data for that endpoint.
+             */
+            usePrefetch<EndpointName extends QueryKeys<Definitions>>(endpointName: EndpointName, options?: PrefetchOptions): (arg: QueryArgFrom<Definitions[EndpointName]>, options?: PrefetchOptions) => void;
+        } & HooksWithUniqueNames<Definitions>;
+    }
+}
+type RR = typeof react_redux;
+interface ReactHooksModuleOptions {
+    /**
+     * The hooks from React Redux to be used
+     */
+    hooks?: {
+        /**
+         * The version of the `useDispatch` hook to be used
+         */
+        useDispatch: RR['useDispatch'];
+        /**
+         * The version of the `useSelector` hook to be used
+         */
+        useSelector: RR['useSelector'];
+        /**
+         * The version of the `useStore` hook to be used
+         */
+        useStore: RR['useStore'];
+    };
+    /**
+     * The version of the `batchedUpdates` function to be used
+     */
+    batch?: RR['batch'];
+    /**
+     * Enables performing asynchronous tasks immediately within a render.
+     *
+     * @example
+     *
+     * ```ts
+     * import {
+     *   buildCreateApi,
+     *   coreModule,
+     *   reactHooksModule
+     * } from '@reduxjs/toolkit/query/react'
+     *
+     * const createApi = buildCreateApi(
+     *   coreModule(),
+     *   reactHooksModule({ unstable__sideEffectsInRender: true })
+     * )
+     * ```
+     */
+    unstable__sideEffectsInRender?: boolean;
+    /**
+     * A selector creator (usually from `reselect`, or matching the same signature)
+     */
+    createSelector?: typeof createSelector;
+}
+/**
+ * Creates a module that generates react hooks from endpoints, for use with `buildCreateApi`.
+ *
+ *  @example
+ * ```ts
+ * const MyContext = React.createContext<ReactReduxContextValue | null>(null);
+ * const customCreateApi = buildCreateApi(
+ *   coreModule(),
+ *   reactHooksModule({
+ *     hooks: {
+ *       useDispatch: createDispatchHook(MyContext),
+ *       useSelector: createSelectorHook(MyContext),
+ *       useStore: createStoreHook(MyContext)
+ *     }
+ *   })
+ * );
+ * ```
+ *
+ * @returns A module for use with `buildCreateApi`
+ */
+declare const reactHooksModule: ({ batch, hooks, createSelector, unstable__sideEffectsInRender, ...rest }?: ReactHooksModuleOptions) => Module<ReactHooksModule>;
+
+/**
+ * Can be used as a `Provider` if you **do not already have a Redux store**.
+ *
+ * @example
+ * ```tsx
+ * // codeblock-meta no-transpile title="Basic usage - wrap your App with ApiProvider"
+ * import * as React from 'react';
+ * import { ApiProvider } from '@reduxjs/toolkit/query/react';
+ * import { Pokemon } from './features/Pokemon';
+ *
+ * function App() {
+ *   return (
+ *     <ApiProvider api={api}>
+ *       <Pokemon />
+ *     </ApiProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @remarks
+ * Using this together with an existing redux store, both will
+ * conflict with each other - please use the traditional redux setup
+ * in that case.
+ */
+declare function ApiProvider(props: {
+    children: any;
+    api: Api<any, {}, any, any>;
+    setupListeners?: Parameters<typeof setupListeners>[1] | false;
+    context?: Context<ReactReduxContextValue | null>;
+}): React.JSX.Element;
+
+declare const createApi: _reduxjs_toolkit_query.CreateApi<typeof _reduxjs_toolkit_query.coreModuleName | typeof reactHooksModuleName>;
+
+export { ApiProvider, type TypedInfiniteQueryStateSelector, type TypedLazyInfiniteQueryTrigger, type TypedLazyQueryTrigger, type TypedMutationTrigger, type TypedQueryStateSelector, type TypedUseInfiniteQuery, type TypedUseInfiniteQueryHookResult, type TypedUseInfiniteQueryState, type TypedUseInfiniteQueryStateOptions, type TypedUseInfiniteQueryStateResult, type TypedUseInfiniteQuerySubscription, type TypedUseInfiniteQuerySubscriptionResult, type TypedUseLazyQuery, type TypedUseLazyQueryStateResult, type TypedUseLazyQuerySubscription, type TypedUseMutation, type TypedUseMutationResult, type TypedUseQuery, type TypedUseQueryHookResult, type TypedUseQueryState, type TypedUseQueryStateOptions, type TypedUseQueryStateResult, type TypedUseQuerySubscription, type TypedUseQuerySubscriptionResult, createApi, reactHooksModule };

frontend/node_modules/@reduxjs/toolkit/dist/query/react/rtk-query-react.browser.mjs

@@ -0,0 +1,2 @@
+import{buildCreateApi as qe,coreModule as Ke}from"@reduxjs/toolkit/query";import"@reduxjs/toolkit";import{batch as be,useDispatch as Ee,useSelector as ke,useStore as Me}from"react-redux";import{createSelector as Oe}from"reselect";function q(e){return e.replace(e[0],e[0].toUpperCase())}function ie(e){return e.type==="query"}function se(e){return e.type==="mutation"}function _(e){return e.type==="infinitequery"}function L(e,...c){return Object.assign(e,...c)}import{formatProdErrorMessage as xe}from"@reduxjs/toolkit";import{defaultSerializeQueryArgs as ue,QueryStatus as me,skipToken as b}from"@reduxjs/toolkit/query";import{useCallback as F,useDebugValue as ee,useEffect as N,useLayoutEffect as Se,useMemo as A,useRef as C,useState as ye}from"react";import{shallowEqual as te}from"react-redux";var K=Symbol();import{useEffect as le,useRef as ge,useMemo as Re}from"react";function j(e,c,x,l){let h=Re(()=>({queryArgs:e,serialized:typeof e=="object"?c({queryArgs:e,endpointDefinition:x,endpointName:l}):e}),[e,c,x,l]),g=ge(h);return le(()=>{g.current.serialized!==h.serialized&&(g.current=h)},[h]),g.current.serialized===h.serialized?g.current.queryArgs:e}import{useEffect as Te,useRef as De}from"react";import{shallowEqual as ae}from"react-redux";function V(e){let c=De(e);return Te(()=>{ae(c.current,e)||(c.current=e)},[e]),ae(c.current,e)?c.current:e}var Ae=()=>typeof window<"u"&&typeof window.document<"u"&&typeof window.document.createElement<"u",Be=Ae(),Pe=()=>typeof navigator<"u"&&navigator.product==="ReactNative",he=Pe(),Ie=()=>Be||he?Se:N,Ue=Ie(),oe=e=>e.isUninitialized?{...e,isUninitialized:!1,isFetching:!0,isLoading:e.data===void 0,status:me.pending}:e;function ne(e,...c){let x={};return c.forEach(l=>{x[l]=e[l]}),x}var re=["data","status","isLoading","isSuccess","isError","error"];function pe({api:e,moduleOptions:{batch:c,hooks:{useDispatch:x,useSelector:l,useStore:h},unstable__sideEffectsInRender:g,createSelector:w},serializeQueryArgs:I,context:B}){let E=g?t=>t():N;return{buildQueryHooks:H,buildInfiniteQueryHooks:Y,buildMutationHook:J,usePrefetch:Z};function $(t,i,p){if(i?.endpointName&&t.isUninitialized){let{endpointName:a}=i,y=B.endpointDefinitions[a];p!==b&&I({queryArgs:i.originalArgs,endpointDefinition:y,endpointName:a})===I({queryArgs:p,endpointDefinition:y,endpointName:a})&&(i=void 0)}let u=t.isSuccess?t.data:i?.data;u===void 0&&(u=t.data);let s=u!==void 0,n=t.isLoading,r=(!i||i.isLoading||i.isUninitialized)&&!s&&n,o=t.isSuccess||s&&(n&&!i?.isError||t.isUninitialized);return{...t,data:u,currentData:t.data,isFetching:n,isLoading:r,isSuccess:o}}function G(t,i,p){if(i?.endpointName&&t.isUninitialized){let{endpointName:a}=i,y=B.endpointDefinitions[a];p!==b&&I({queryArgs:i.originalArgs,endpointDefinition:y,endpointName:a})===I({queryArgs:p,endpointDefinition:y,endpointName:a})&&(i=void 0)}let u=t.isSuccess?t.data:i?.data;u===void 0&&(u=t.data);let s=u!==void 0,n=t.isLoading,r=(!i||i.isLoading||i.isUninitialized)&&!s&&n,o=t.isSuccess||n&&s;return{...t,data:u,currentData:t.data,isFetching:n,isLoading:r,isSuccess:o}}function Z(t,i){let p=x(),u=V(i);return F((s,n)=>p(e.util.prefetch(t,s,{...u,...n})),[t,p,u])}function m(t,i,{refetchOnReconnect:p,refetchOnFocus:u,refetchOnMountOrArgChange:s,skip:n=!1,pollingInterval:r=0,skipPollingIfUnfocused:o=!1,...a}={}){let{initiate:y}=e.endpoints[t],Q=x(),S=C(void 0);if(!S.current){let O=Q(e.internalActions.internal_getRTKQSubscriptions());S.current=O}let f=j(n?b:i,ue,B.endpointDefinitions[t],t),d=V({refetchOnReconnect:p,refetchOnFocus:u,pollingInterval:r,skipPollingIfUnfocused:o}),R=a.initialPageParam,T=V(R),D=C(void 0),{queryCacheKey:U,requestId:M}=D.current||{},z=!1;U&&M&&(z=S.current.isRequestSubscribed(U,M));let X=!z&&D.current!==void 0;return E(()=>{X&&(D.current=void 0)},[X]),E(()=>{let O=D.current;if(f===b){O?.unsubscribe(),D.current=void 0;return}let de=D.current?.subscriptionOptions;if(!O||O.arg!==f){O?.unsubscribe();let ce=Q(y(f,{subscriptionOptions:d,forceRefetch:s,..._(B.endpointDefinitions[t])?{initialPageParam:T}:{}}));D.current=ce}else d!==de&&O.updateSubscriptionOptions(d)},[Q,y,s,f,d,X,T,t]),[D,Q,y,d]}function v(t,i){return(u,{skip:s=!1,selectFromResult:n}={})=>{let{select:r}=e.endpoints[t],o=j(s?b:u,I,B.endpointDefinitions[t],t),a=C(void 0),y=A(()=>w([r(o),(R,T)=>T,R=>o],i,{memoizeOptions:{resultEqualityCheck:te}}),[r,o]),Q=A(()=>n?w([y],n,{devModeChecks:{identityFunctionCheck:"never"}}):y,[y,n]),S=l(R=>Q(R,a.current),te),f=h(),d=y(f.getState(),a.current);return Ue(()=>{a.current=d},[d]),S}}function P(t){N(()=>()=>{t.current?.unsubscribe?.(),t.current=void 0},[t])}function k(t){if(!t.current)throw new Error(xe(38));return t.current.refetch()}function H(t){let i=(s,n={})=>{let[r]=m(t,s,n);return P(r),A(()=>({refetch:()=>k(r)}),[r])},p=({refetchOnReconnect:s,refetchOnFocus:n,pollingInterval:r=0,skipPollingIfUnfocused:o=!1}={})=>{let{initiate:a}=e.endpoints[t],y=x(),[Q,S]=ye(K),f=C(void 0),d=V({refetchOnReconnect:s,refetchOnFocus:n,pollingInterval:r,skipPollingIfUnfocused:o});E(()=>{let U=f.current?.subscriptionOptions;d!==U&&f.current?.updateSubscriptionOptions(d)},[d]);let R=C(d);E(()=>{R.current=d},[d]);let T=F(function(U,M=!1){let z;return c(()=>{f.current?.unsubscribe(),f.current=z=y(a(U,{subscriptionOptions:R.current,forceRefetch:!M})),S(U)}),z},[y,a]),D=F(()=>{f.current?.queryCacheKey&&y(e.internalActions.removeQueryResult({queryCacheKey:f.current?.queryCacheKey}))},[y]);return N(()=>()=>{f?.current?.unsubscribe()},[]),N(()=>{Q!==K&&!f.current&&T(Q,!0)},[Q,T]),A(()=>[T,Q,{reset:D}],[T,Q,D])},u=v(t,$);return{useQueryState:u,useQuerySubscription:i,useLazyQuerySubscription:p,useLazyQuery(s){let[n,r,{reset:o}]=p(s),a=u(r,{...s,skip:r===K}),y=A(()=>({lastArg:r}),[r]);return A(()=>[n,{...a,reset:o},y],[n,a,o,y])},useQuery(s,n){let r=i(s,n),o=u(s,{selectFromResult:s===b||n?.skip?void 0:oe,...n}),a=ne(o,...re);return ee(a),A(()=>({...o,...r}),[o,r])}}}function Y(t){let i=(u,s={})=>{let[n,r,o,a]=m(t,u,s),y=C(a);E(()=>{y.current=a},[a]);let Q=F(function(d,R){let T;return c(()=>{n.current?.unsubscribe(),n.current=T=r(o(d,{subscriptionOptions:y.current,direction:R}))}),T},[n,r,o]);P(n);let S=j(s.skip?b:u,ue,B.endpointDefinitions[t],t),f=F(()=>k(n),[n]);return A(()=>({trigger:Q,refetch:f,fetchNextPage:()=>Q(S,"forward"),fetchPreviousPage:()=>Q(S,"backward")}),[f,Q,S])},p=v(t,G);return{useInfiniteQueryState:p,useInfiniteQuerySubscription:i,useInfiniteQuery(u,s){let{refetch:n,fetchNextPage:r,fetchPreviousPage:o}=i(u,s),a=p(u,{selectFromResult:u===b||s?.skip?void 0:oe,...s}),y=ne(a,...re,"hasNextPage","hasPreviousPage");return ee(y),A(()=>({...a,fetchNextPage:r,fetchPreviousPage:o,refetch:n}),[a,r,o,n])}}}function J(t){return({selectFromResult:i,fixedCacheKey:p}={})=>{let{select:u,initiate:s}=e.endpoints[t],n=x(),[r,o]=ye();N(()=>()=>{r?.arg.fixedCacheKey||r?.reset()},[r]);let a=F(function(U){let M=n(s(U,{fixedCacheKey:p}));return o(M),M},[n,s,p]),{requestId:y}=r||{},Q=A(()=>u({fixedCacheKey:p,requestId:r?.requestId}),[p,r,u]),S=A(()=>i?w([Q],i):Q,[i,Q]),f=l(S,te),d=p==null?r?.arg.originalArgs:void 0,R=F(()=>{c(()=>{r&&o(void 0),p&&n(e.internalActions.removeMutationResult({requestId:y,fixedCacheKey:p}))})},[n,p,r,y]),T=ne(f,...re,"endpointName");ee(T);let D=A(()=>({...f,originalArgs:d,reset:R}),[f,d,R]);return A(()=>[a,D],[a,D])}}}var fe=Symbol(),Qe=({batch:e=be,hooks:c={useDispatch:Ee,useSelector:ke,useStore:Me},createSelector:x=Oe,unstable__sideEffectsInRender:l=!1,...h}={})=>({name:fe,init(g,{serializeQueryArgs:w},I){let B=g,{buildQueryHooks:E,buildInfiniteQueryHooks:$,buildMutationHook:G,usePrefetch:Z}=pe({api:g,moduleOptions:{batch:e,hooks:c,unstable__sideEffectsInRender:l,createSelector:x},serializeQueryArgs:w,context:I});return L(B,{usePrefetch:Z}),L(I,{batch:e}),{injectEndpoint(m,v){if(ie(v)){let{useQuery:P,useLazyQuery:k,useLazyQuerySubscription:H,useQueryState:Y,useQuerySubscription:J}=E(m);L(B.endpoints[m],{useQuery:P,useLazyQuery:k,useLazyQuerySubscription:H,useQueryState:Y,useQuerySubscription:J}),g[`use${q(m)}Query`]=P,g[`useLazy${q(m)}Query`]=k}if(se(v)){let P=G(m);L(B.endpoints[m],{useMutation:P}),g[`use${q(m)}Mutation`]=P}else if(_(v)){let{useInfiniteQuery:P,useInfiniteQuerySubscription:k,useInfiniteQueryState:H}=$(m);L(B.endpoints[m],{useInfiniteQuery:P,useInfiniteQuerySubscription:k,useInfiniteQueryState:H}),g[`use${q(m)}InfiniteQuery`]=P}}}}});export*from"@reduxjs/toolkit/query";import{configureStore as Fe,formatProdErrorMessage as we}from"@reduxjs/toolkit";import{useContext as ve}from"react";import{useEffect as Le}from"react";import*as W from"react";import{Provider as Ce,ReactReduxContext as Ne}from"react-redux";import{setupListeners as He}from"@reduxjs/toolkit/query";function ze(e){let c=e.context||Ne;if(ve(c))throw new Error(we(35));let[l]=W.useState(()=>Fe({reducer:{[e.api.reducerPath]:e.api.reducer},middleware:h=>h().concat(e.api.middleware)}));return Le(()=>e.setupListeners===!1?void 0:He(l.dispatch,e.setupListeners),[e.setupListeners,l.dispatch]),W.createElement(Ce,{store:l,context:c},e.children)}var It=qe(Ke(),Qe());export{ze as ApiProvider,K as UNINITIALIZED_VALUE,It as createApi,Qe as reactHooksModule,fe as reactHooksModuleName};
+//# sourceMappingURL=rtk-query-react.browser.mjs.map

frontend/node_modules/@reduxjs/toolkit/dist/query/react/rtk-query-react.legacy-esm.js

@@ -0,0 +1,753 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+
+// src/query/react/index.ts
+import { buildCreateApi, coreModule } from "@reduxjs/toolkit/query";
+
+// src/query/react/module.ts
+import { formatProdErrorMessage as _formatProdErrorMessage3 } from "@reduxjs/toolkit";
+import { batch as rrBatch, useDispatch as rrUseDispatch, useSelector as rrUseSelector, useStore as rrUseStore } from "react-redux";
+import { createSelector as _createSelector } from "reselect";
+
+// src/query/utils/capitalize.ts
+function capitalize(str) {
+  return str.replace(str[0], str[0].toUpperCase());
+}
+
+// src/query/utils/countObjectKeys.ts
+function countObjectKeys(obj) {
+  let count = 0;
+  for (const _key in obj) {
+    count++;
+  }
+  return count;
+}
+
+// src/query/endpointDefinitions.ts
+function isQueryDefinition(e) {
+  return e.type === "query" /* query */;
+}
+function isMutationDefinition(e) {
+  return e.type === "mutation" /* mutation */;
+}
+function isInfiniteQueryDefinition(e) {
+  return e.type === "infinitequery" /* infinitequery */;
+}
+
+// src/query/tsHelpers.ts
+function safeAssign(target, ...args) {
+  return Object.assign(target, ...args);
+}
+
+// src/query/react/buildHooks.ts
+import { formatProdErrorMessage as _formatProdErrorMessage, formatProdErrorMessage as _formatProdErrorMessage2 } from "@reduxjs/toolkit";
+import { defaultSerializeQueryArgs, QueryStatus, skipToken } from "@reduxjs/toolkit/query";
+import { useCallback, useDebugValue, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo2, useRef as useRef3, useState } from "react";
+import { shallowEqual as shallowEqual2 } from "react-redux";
+
+// src/query/react/constants.ts
+var UNINITIALIZED_VALUE = Symbol();
+
+// src/query/react/useSerializedStableValue.ts
+import { useEffect, useRef, useMemo } from "react";
+function useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {
+  const incoming = useMemo(() => ({
+    queryArgs,
+    serialized: typeof queryArgs == "object" ? serialize({
+      queryArgs,
+      endpointDefinition,
+      endpointName
+    }) : queryArgs
+  }), [queryArgs, serialize, endpointDefinition, endpointName]);
+  const cache = useRef(incoming);
+  useEffect(() => {
+    if (cache.current.serialized !== incoming.serialized) {
+      cache.current = incoming;
+    }
+  }, [incoming]);
+  return cache.current.serialized === incoming.serialized ? cache.current.queryArgs : queryArgs;
+}
+
+// src/query/react/useShallowStableValue.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { shallowEqual } from "react-redux";
+function useShallowStableValue(value) {
+  const cache = useRef2(value);
+  useEffect2(() => {
+    if (!shallowEqual(cache.current, value)) {
+      cache.current = value;
+    }
+  }, [value]);
+  return shallowEqual(cache.current, value) ? cache.current : value;
+}
+
+// src/query/react/buildHooks.ts
+var canUseDOM = () => !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+var isDOM = /* @__PURE__ */ canUseDOM();
+var isRunningInReactNative = () => typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var isReactNative = /* @__PURE__ */ isRunningInReactNative();
+var getUseIsomorphicLayoutEffect = () => isDOM || isReactNative ? useLayoutEffect : useEffect3;
+var useIsomorphicLayoutEffect = /* @__PURE__ */ getUseIsomorphicLayoutEffect();
+var noPendingQueryStateSelector = (selected) => {
+  if (selected.isUninitialized) {
+    return __spreadProps(__spreadValues({}, selected), {
+      isUninitialized: false,
+      isFetching: true,
+      isLoading: selected.data !== void 0 ? false : true,
+      status: QueryStatus.pending
+    });
+  }
+  return selected;
+};
+function pick(obj, ...keys) {
+  const ret = {};
+  keys.forEach((key) => {
+    ret[key] = obj[key];
+  });
+  return ret;
+}
+var COMMON_HOOK_DEBUG_FIELDS = ["data", "status", "isLoading", "isSuccess", "isError", "error"];
+function buildHooks({
+  api,
+  moduleOptions: {
+    batch,
+    hooks: {
+      useDispatch,
+      useSelector,
+      useStore
+    },
+    unstable__sideEffectsInRender,
+    createSelector
+  },
+  serializeQueryArgs,
+  context
+}) {
+  const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : useEffect3;
+  return {
+    buildQueryHooks,
+    buildInfiniteQueryHooks,
+    buildMutationHook,
+    usePrefetch
+  };
+  function queryStatePreSelector(currentState, lastResult, queryArgs) {
+    if ((lastResult == null ? void 0 : lastResult.endpointName) && currentState.isUninitialized) {
+      const {
+        endpointName
+      } = lastResult;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      if (queryArgs !== skipToken && serializeQueryArgs({
+        queryArgs: lastResult.originalArgs,
+        endpointDefinition,
+        endpointName
+      }) === serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      })) lastResult = void 0;
+    }
+    let data = currentState.isSuccess ? currentState.data : lastResult == null ? void 0 : lastResult.data;
+    if (data === void 0) data = currentState.data;
+    const hasData = data !== void 0;
+    const isFetching = currentState.isLoading;
+    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
+    const isSuccess = currentState.isSuccess || hasData && (isFetching && !(lastResult == null ? void 0 : lastResult.isError) || currentState.isUninitialized);
+    return __spreadProps(__spreadValues({}, currentState), {
+      data,
+      currentData: currentState.data,
+      isFetching,
+      isLoading,
+      isSuccess
+    });
+  }
+  function infiniteQueryStatePreSelector(currentState, lastResult, queryArgs) {
+    if ((lastResult == null ? void 0 : lastResult.endpointName) && currentState.isUninitialized) {
+      const {
+        endpointName
+      } = lastResult;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      if (queryArgs !== skipToken && serializeQueryArgs({
+        queryArgs: lastResult.originalArgs,
+        endpointDefinition,
+        endpointName
+      }) === serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      })) lastResult = void 0;
+    }
+    let data = currentState.isSuccess ? currentState.data : lastResult == null ? void 0 : lastResult.data;
+    if (data === void 0) data = currentState.data;
+    const hasData = data !== void 0;
+    const isFetching = currentState.isLoading;
+    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
+    const isSuccess = currentState.isSuccess || isFetching && hasData;
+    return __spreadProps(__spreadValues({}, currentState), {
+      data,
+      currentData: currentState.data,
+      isFetching,
+      isLoading,
+      isSuccess
+    });
+  }
+  function usePrefetch(endpointName, defaultOptions) {
+    const dispatch = useDispatch();
+    const stableDefaultOptions = useShallowStableValue(defaultOptions);
+    return useCallback((arg, options) => dispatch(api.util.prefetch(endpointName, arg, __spreadValues(__spreadValues({}, stableDefaultOptions), options))), [endpointName, dispatch, stableDefaultOptions]);
+  }
+  function useQuerySubscriptionCommonImpl(endpointName, arg, _a = {}) {
+    var _b = _a, {
+      refetchOnReconnect,
+      refetchOnFocus,
+      refetchOnMountOrArgChange,
+      skip = false,
+      pollingInterval = 0,
+      skipPollingIfUnfocused = false
+    } = _b, rest = __objRest(_b, [
+      "refetchOnReconnect",
+      "refetchOnFocus",
+      "refetchOnMountOrArgChange",
+      "skip",
+      "pollingInterval",
+      "skipPollingIfUnfocused"
+    ]);
+    const {
+      initiate
+    } = api.endpoints[endpointName];
+    const dispatch = useDispatch();
+    const subscriptionSelectorsRef = useRef3(void 0);
+    if (!subscriptionSelectorsRef.current) {
+      const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());
+      if (process.env.NODE_ENV !== "production") {
+        if (typeof returnedValue !== "object" || typeof (returnedValue == null ? void 0 : returnedValue.type) === "string") {
+          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.
+    You must add the middleware for RTK-Query to function correctly!`);
+        }
+      }
+      subscriptionSelectorsRef.current = returnedValue;
+    }
+    const stableArg = useStableQueryArgs(
+      skip ? skipToken : arg,
+      // Even if the user provided a per-endpoint `serializeQueryArgs` with
+      // a consistent return value, _here_ we want to use the default behavior
+      // so we can tell if _anything_ actually changed. Otherwise, we can end up
+      // with a case where the query args did change but the serialization doesn't,
+      // and then we never try to initiate a refetch.
+      defaultSerializeQueryArgs,
+      context.endpointDefinitions[endpointName],
+      endpointName
+    );
+    const stableSubscriptionOptions = useShallowStableValue({
+      refetchOnReconnect,
+      refetchOnFocus,
+      pollingInterval,
+      skipPollingIfUnfocused
+    });
+    const initialPageParam = rest.initialPageParam;
+    const stableInitialPageParam = useShallowStableValue(initialPageParam);
+    const promiseRef = useRef3(void 0);
+    let {
+      queryCacheKey,
+      requestId
+    } = promiseRef.current || {};
+    let currentRenderHasSubscription = false;
+    if (queryCacheKey && requestId) {
+      currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);
+    }
+    const subscriptionRemoved = !currentRenderHasSubscription && promiseRef.current !== void 0;
+    usePossiblyImmediateEffect(() => {
+      if (subscriptionRemoved) {
+        promiseRef.current = void 0;
+      }
+    }, [subscriptionRemoved]);
+    usePossiblyImmediateEffect(() => {
+      var _a2;
+      const lastPromise = promiseRef.current;
+      if (typeof process !== "undefined" && process.env.NODE_ENV === "removeMeOnCompilation") {
+        console.log(subscriptionRemoved);
+      }
+      if (stableArg === skipToken) {
+        lastPromise == null ? void 0 : lastPromise.unsubscribe();
+        promiseRef.current = void 0;
+        return;
+      }
+      const lastSubscriptionOptions = (_a2 = promiseRef.current) == null ? void 0 : _a2.subscriptionOptions;
+      if (!lastPromise || lastPromise.arg !== stableArg) {
+        lastPromise == null ? void 0 : lastPromise.unsubscribe();
+        const promise = dispatch(initiate(stableArg, __spreadValues({
+          subscriptionOptions: stableSubscriptionOptions,
+          forceRefetch: refetchOnMountOrArgChange
+        }, isInfiniteQueryDefinition(context.endpointDefinitions[endpointName]) ? {
+          initialPageParam: stableInitialPageParam
+        } : {})));
+        promiseRef.current = promise;
+      } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+        lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);
+      }
+    }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved, stableInitialPageParam, endpointName]);
+    return [promiseRef, dispatch, initiate, stableSubscriptionOptions];
+  }
+  function buildUseQueryState(endpointName, preSelector) {
+    const useQueryState = (arg, {
+      skip = false,
+      selectFromResult
+    } = {}) => {
+      const {
+        select
+      } = api.endpoints[endpointName];
+      const stableArg = useStableQueryArgs(skip ? skipToken : arg, serializeQueryArgs, context.endpointDefinitions[endpointName], endpointName);
+      const lastValue = useRef3(void 0);
+      const selectDefaultResult = useMemo2(() => (
+        // Normally ts-ignores are bad and should be avoided, but we're
+        // already casting this selector to be `Selector<any>` anyway,
+        // so the inconsistencies don't matter here
+        // @ts-ignore
+        createSelector([
+          // @ts-ignore
+          select(stableArg),
+          (_, lastResult) => lastResult,
+          (_) => stableArg
+        ], preSelector, {
+          memoizeOptions: {
+            resultEqualityCheck: shallowEqual2
+          }
+        })
+      ), [select, stableArg]);
+      const querySelector = useMemo2(() => selectFromResult ? createSelector([selectDefaultResult], selectFromResult, {
+        devModeChecks: {
+          identityFunctionCheck: "never"
+        }
+      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);
+      const currentState = useSelector((state) => querySelector(state, lastValue.current), shallowEqual2);
+      const store = useStore();
+      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);
+      useIsomorphicLayoutEffect(() => {
+        lastValue.current = newLastValue;
+      }, [newLastValue]);
+      return currentState;
+    };
+    return useQueryState;
+  }
+  function usePromiseRefUnsubscribeOnUnmount(promiseRef) {
+    useEffect3(() => {
+      return () => {
+        var _a, _b;
+        (_b = (_a = promiseRef.current) == null ? void 0 : _a.unsubscribe) == null ? void 0 : _b.call(_a);
+        promiseRef.current = void 0;
+      };
+    }, [promiseRef]);
+  }
+  function refetchOrErrorIfUnmounted(promiseRef) {
+    if (!promiseRef.current) throw new Error(process.env.NODE_ENV === "production" ? _formatProdErrorMessage2(38) : "Cannot refetch a query that has not been started yet.");
+    return promiseRef.current.refetch();
+  }
+  function buildQueryHooks(endpointName) {
+    const useQuerySubscription = (arg, options = {}) => {
+      const [promiseRef] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
+      usePromiseRefUnsubscribeOnUnmount(promiseRef);
+      return useMemo2(() => ({
+        /**
+         * A method to manually refetch data for the query
+         */
+        refetch: () => refetchOrErrorIfUnmounted(promiseRef)
+      }), [promiseRef]);
+    };
+    const useLazyQuerySubscription = ({
+      refetchOnReconnect,
+      refetchOnFocus,
+      pollingInterval = 0,
+      skipPollingIfUnfocused = false
+    } = {}) => {
+      const {
+        initiate
+      } = api.endpoints[endpointName];
+      const dispatch = useDispatch();
+      const [arg, setArg] = useState(UNINITIALIZED_VALUE);
+      const promiseRef = useRef3(void 0);
+      const stableSubscriptionOptions = useShallowStableValue({
+        refetchOnReconnect,
+        refetchOnFocus,
+        pollingInterval,
+        skipPollingIfUnfocused
+      });
+      usePossiblyImmediateEffect(() => {
+        var _a, _b;
+        const lastSubscriptionOptions = (_a = promiseRef.current) == null ? void 0 : _a.subscriptionOptions;
+        if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+          (_b = promiseRef.current) == null ? void 0 : _b.updateSubscriptionOptions(stableSubscriptionOptions);
+        }
+      }, [stableSubscriptionOptions]);
+      const subscriptionOptionsRef = useRef3(stableSubscriptionOptions);
+      usePossiblyImmediateEffect(() => {
+        subscriptionOptionsRef.current = stableSubscriptionOptions;
+      }, [stableSubscriptionOptions]);
+      const trigger = useCallback(function(arg2, preferCacheValue = false) {
+        let promise;
+        batch(() => {
+          var _a;
+          (_a = promiseRef.current) == null ? void 0 : _a.unsubscribe();
+          promiseRef.current = promise = dispatch(initiate(arg2, {
+            subscriptionOptions: subscriptionOptionsRef.current,
+            forceRefetch: !preferCacheValue
+          }));
+          setArg(arg2);
+        });
+        return promise;
+      }, [dispatch, initiate]);
+      const reset = useCallback(() => {
+        var _a, _b;
+        if ((_a = promiseRef.current) == null ? void 0 : _a.queryCacheKey) {
+          dispatch(api.internalActions.removeQueryResult({
+            queryCacheKey: (_b = promiseRef.current) == null ? void 0 : _b.queryCacheKey
+          }));
+        }
+      }, [dispatch]);
+      useEffect3(() => {
+        return () => {
+          var _a;
+          (_a = promiseRef == null ? void 0 : promiseRef.current) == null ? void 0 : _a.unsubscribe();
+        };
+      }, []);
+      useEffect3(() => {
+        if (arg !== UNINITIALIZED_VALUE && !promiseRef.current) {
+          trigger(arg, true);
+        }
+      }, [arg, trigger]);
+      return useMemo2(() => [trigger, arg, {
+        reset
+      }], [trigger, arg, reset]);
+    };
+    const useQueryState = buildUseQueryState(endpointName, queryStatePreSelector);
+    return {
+      useQueryState,
+      useQuerySubscription,
+      useLazyQuerySubscription,
+      useLazyQuery(options) {
+        const [trigger, arg, {
+          reset
+        }] = useLazyQuerySubscription(options);
+        const queryStateResults = useQueryState(arg, __spreadProps(__spreadValues({}, options), {
+          skip: arg === UNINITIALIZED_VALUE
+        }));
+        const info = useMemo2(() => ({
+          lastArg: arg
+        }), [arg]);
+        return useMemo2(() => [trigger, __spreadProps(__spreadValues({}, queryStateResults), {
+          reset
+        }), info], [trigger, queryStateResults, reset, info]);
+      },
+      useQuery(arg, options) {
+        const querySubscriptionResults = useQuerySubscription(arg, options);
+        const queryStateResults = useQueryState(arg, __spreadValues({
+          selectFromResult: arg === skipToken || (options == null ? void 0 : options.skip) ? void 0 : noPendingQueryStateSelector
+        }, options));
+        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS);
+        useDebugValue(debugValue);
+        return useMemo2(() => __spreadValues(__spreadValues({}, queryStateResults), querySubscriptionResults), [queryStateResults, querySubscriptionResults]);
+      }
+    };
+  }
+  function buildInfiniteQueryHooks(endpointName) {
+    const useInfiniteQuerySubscription = (arg, options = {}) => {
+      const [promiseRef, dispatch, initiate, stableSubscriptionOptions] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
+      const subscriptionOptionsRef = useRef3(stableSubscriptionOptions);
+      usePossiblyImmediateEffect(() => {
+        subscriptionOptionsRef.current = stableSubscriptionOptions;
+      }, [stableSubscriptionOptions]);
+      const trigger = useCallback(function(arg2, direction) {
+        let promise;
+        batch(() => {
+          var _a;
+          (_a = promiseRef.current) == null ? void 0 : _a.unsubscribe();
+          promiseRef.current = promise = dispatch(initiate(arg2, {
+            subscriptionOptions: subscriptionOptionsRef.current,
+            direction
+          }));
+        });
+        return promise;
+      }, [promiseRef, dispatch, initiate]);
+      usePromiseRefUnsubscribeOnUnmount(promiseRef);
+      const stableArg = useStableQueryArgs(
+        options.skip ? skipToken : arg,
+        // Even if the user provided a per-endpoint `serializeQueryArgs` with
+        // a consistent return value, _here_ we want to use the default behavior
+        // so we can tell if _anything_ actually changed. Otherwise, we can end up
+        // with a case where the query args did change but the serialization doesn't,
+        // and then we never try to initiate a refetch.
+        defaultSerializeQueryArgs,
+        context.endpointDefinitions[endpointName],
+        endpointName
+      );
+      const refetch = useCallback(() => refetchOrErrorIfUnmounted(promiseRef), [promiseRef]);
+      return useMemo2(() => {
+        const fetchNextPage = () => {
+          return trigger(stableArg, "forward");
+        };
+        const fetchPreviousPage = () => {
+          return trigger(stableArg, "backward");
+        };
+        return {
+          trigger,
+          /**
+           * A method to manually refetch data for the query
+           */
+          refetch,
+          fetchNextPage,
+          fetchPreviousPage
+        };
+      }, [refetch, trigger, stableArg]);
+    };
+    const useInfiniteQueryState = buildUseQueryState(endpointName, infiniteQueryStatePreSelector);
+    return {
+      useInfiniteQueryState,
+      useInfiniteQuerySubscription,
+      useInfiniteQuery(arg, options) {
+        const {
+          refetch,
+          fetchNextPage,
+          fetchPreviousPage
+        } = useInfiniteQuerySubscription(arg, options);
+        const queryStateResults = useInfiniteQueryState(arg, __spreadValues({
+          selectFromResult: arg === skipToken || (options == null ? void 0 : options.skip) ? void 0 : noPendingQueryStateSelector
+        }, options));
+        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS, "hasNextPage", "hasPreviousPage");
+        useDebugValue(debugValue);
+        return useMemo2(() => __spreadProps(__spreadValues({}, queryStateResults), {
+          fetchNextPage,
+          fetchPreviousPage,
+          refetch
+        }), [queryStateResults, fetchNextPage, fetchPreviousPage, refetch]);
+      }
+    };
+  }
+  function buildMutationHook(name) {
+    return ({
+      selectFromResult,
+      fixedCacheKey
+    } = {}) => {
+      const {
+        select,
+        initiate
+      } = api.endpoints[name];
+      const dispatch = useDispatch();
+      const [promise, setPromise] = useState();
+      useEffect3(() => () => {
+        if (!(promise == null ? void 0 : promise.arg.fixedCacheKey)) {
+          promise == null ? void 0 : promise.reset();
+        }
+      }, [promise]);
+      const triggerMutation = useCallback(function(arg) {
+        const promise2 = dispatch(initiate(arg, {
+          fixedCacheKey
+        }));
+        setPromise(promise2);
+        return promise2;
+      }, [dispatch, initiate, fixedCacheKey]);
+      const {
+        requestId
+      } = promise || {};
+      const selectDefaultResult = useMemo2(() => select({
+        fixedCacheKey,
+        requestId: promise == null ? void 0 : promise.requestId
+      }), [fixedCacheKey, promise, select]);
+      const mutationSelector = useMemo2(() => selectFromResult ? createSelector([selectDefaultResult], selectFromResult) : selectDefaultResult, [selectFromResult, selectDefaultResult]);
+      const currentState = useSelector(mutationSelector, shallowEqual2);
+      const originalArgs = fixedCacheKey == null ? promise == null ? void 0 : promise.arg.originalArgs : void 0;
+      const reset = useCallback(() => {
+        batch(() => {
+          if (promise) {
+            setPromise(void 0);
+          }
+          if (fixedCacheKey) {
+            dispatch(api.internalActions.removeMutationResult({
+              requestId,
+              fixedCacheKey
+            }));
+          }
+        });
+      }, [dispatch, fixedCacheKey, promise, requestId]);
+      const debugValue = pick(currentState, ...COMMON_HOOK_DEBUG_FIELDS, "endpointName");
+      useDebugValue(debugValue);
+      const finalState = useMemo2(() => __spreadProps(__spreadValues({}, currentState), {
+        originalArgs,
+        reset
+      }), [currentState, originalArgs, reset]);
+      return useMemo2(() => [triggerMutation, finalState], [triggerMutation, finalState]);
+    };
+  }
+}
+
+// src/query/react/module.ts
+var reactHooksModuleName = /* @__PURE__ */ Symbol();
+var reactHooksModule = (_a = {}) => {
+  var _b = _a, {
+    batch = rrBatch,
+    hooks = {
+      useDispatch: rrUseDispatch,
+      useSelector: rrUseSelector,
+      useStore: rrUseStore
+    },
+    createSelector = _createSelector,
+    unstable__sideEffectsInRender = false
+  } = _b, rest = __objRest(_b, [
+    "batch",
+    "hooks",
+    "createSelector",
+    "unstable__sideEffectsInRender"
+  ]);
+  if (process.env.NODE_ENV !== "production") {
+    const hookNames = ["useDispatch", "useSelector", "useStore"];
+    let warned = false;
+    for (const hookName of hookNames) {
+      if (countObjectKeys(rest) > 0) {
+        if (rest[hookName]) {
+          if (!warned) {
+            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 } })`");
+            warned = true;
+          }
+        }
+        hooks[hookName] = rest[hookName];
+      }
+      if (typeof hooks[hookName] !== "function") {
+        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(", ")}.
+Hook ${hookName} was either not provided or not a function.`);
+      }
+    }
+  }
+  return {
+    name: reactHooksModuleName,
+    init(api, {
+      serializeQueryArgs
+    }, context) {
+      const anyApi = api;
+      const {
+        buildQueryHooks,
+        buildInfiniteQueryHooks,
+        buildMutationHook,
+        usePrefetch
+      } = buildHooks({
+        api,
+        moduleOptions: {
+          batch,
+          hooks,
+          unstable__sideEffectsInRender,
+          createSelector
+        },
+        serializeQueryArgs,
+        context
+      });
+      safeAssign(anyApi, {
+        usePrefetch
+      });
+      safeAssign(context, {
+        batch
+      });
+      return {
+        injectEndpoint(endpointName, definition) {
+          if (isQueryDefinition(definition)) {
+            const {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription
+            } = buildQueryHooks(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription
+            });
+            api[`use${capitalize(endpointName)}Query`] = useQuery;
+            api[`useLazy${capitalize(endpointName)}Query`] = useLazyQuery;
+          }
+          if (isMutationDefinition(definition)) {
+            const useMutation = buildMutationHook(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useMutation
+            });
+            api[`use${capitalize(endpointName)}Mutation`] = useMutation;
+          } else if (isInfiniteQueryDefinition(definition)) {
+            const {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState
+            } = buildInfiniteQueryHooks(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState
+            });
+            api[`use${capitalize(endpointName)}InfiniteQuery`] = useInfiniteQuery;
+          }
+        }
+      };
+    }
+  };
+};
+
+// src/query/react/index.ts
+export * from "@reduxjs/toolkit/query";
+
+// src/query/react/ApiProvider.tsx
+import { configureStore, formatProdErrorMessage as _formatProdErrorMessage4 } from "@reduxjs/toolkit";
+import { useContext } from "react";
+import { useEffect as useEffect4 } from "react";
+import * as React from "react";
+import { Provider, ReactReduxContext } from "react-redux";
+import { setupListeners } from "@reduxjs/toolkit/query";
+function ApiProvider(props) {
+  const context = props.context || ReactReduxContext;
+  const existingContext = useContext(context);
+  if (existingContext) {
+    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.");
+  }
+  const [store] = React.useState(() => configureStore({
+    reducer: {
+      [props.api.reducerPath]: props.api.reducer
+    },
+    middleware: (gDM) => gDM().concat(props.api.middleware)
+  }));
+  useEffect4(() => props.setupListeners === false ? void 0 : setupListeners(store.dispatch, props.setupListeners), [props.setupListeners, store.dispatch]);
+  return /* @__PURE__ */ React.createElement(Provider, { store, context }, props.children);
+}
+
+// src/query/react/index.ts
+var createApi = /* @__PURE__ */ buildCreateApi(coreModule(), reactHooksModule());
+export {
+  ApiProvider,
+  UNINITIALIZED_VALUE,
+  createApi,
+  reactHooksModule,
+  reactHooksModuleName
+};
+//# sourceMappingURL=rtk-query-react.legacy-esm.js.map

frontend/node_modules/@reduxjs/toolkit/dist/query/react/rtk-query-react.modern.mjs

@@ -0,0 +1,718 @@
+// src/query/react/index.ts
+import { buildCreateApi, coreModule } from "@reduxjs/toolkit/query";
+
+// src/query/react/module.ts
+import { formatProdErrorMessage as _formatProdErrorMessage3 } from "@reduxjs/toolkit";
+import { batch as rrBatch, useDispatch as rrUseDispatch, useSelector as rrUseSelector, useStore as rrUseStore } from "react-redux";
+import { createSelector as _createSelector } from "reselect";
+
+// src/query/utils/capitalize.ts
+function capitalize(str) {
+  return str.replace(str[0], str[0].toUpperCase());
+}
+
+// src/query/utils/countObjectKeys.ts
+function countObjectKeys(obj) {
+  let count = 0;
+  for (const _key in obj) {
+    count++;
+  }
+  return count;
+}
+
+// src/query/endpointDefinitions.ts
+function isQueryDefinition(e) {
+  return e.type === "query" /* query */;
+}
+function isMutationDefinition(e) {
+  return e.type === "mutation" /* mutation */;
+}
+function isInfiniteQueryDefinition(e) {
+  return e.type === "infinitequery" /* infinitequery */;
+}
+
+// src/query/tsHelpers.ts
+function safeAssign(target, ...args) {
+  return Object.assign(target, ...args);
+}
+
+// src/query/react/buildHooks.ts
+import { formatProdErrorMessage as _formatProdErrorMessage, formatProdErrorMessage as _formatProdErrorMessage2 } from "@reduxjs/toolkit";
+import { defaultSerializeQueryArgs, QueryStatus, skipToken } from "@reduxjs/toolkit/query";
+import { useCallback, useDebugValue, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo2, useRef as useRef3, useState } from "react";
+import { shallowEqual as shallowEqual2 } from "react-redux";
+
+// src/query/react/constants.ts
+var UNINITIALIZED_VALUE = Symbol();
+
+// src/query/react/useSerializedStableValue.ts
+import { useEffect, useRef, useMemo } from "react";
+function useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {
+  const incoming = useMemo(() => ({
+    queryArgs,
+    serialized: typeof queryArgs == "object" ? serialize({
+      queryArgs,
+      endpointDefinition,
+      endpointName
+    }) : queryArgs
+  }), [queryArgs, serialize, endpointDefinition, endpointName]);
+  const cache = useRef(incoming);
+  useEffect(() => {
+    if (cache.current.serialized !== incoming.serialized) {
+      cache.current = incoming;
+    }
+  }, [incoming]);
+  return cache.current.serialized === incoming.serialized ? cache.current.queryArgs : queryArgs;
+}
+
+// src/query/react/useShallowStableValue.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { shallowEqual } from "react-redux";
+function useShallowStableValue(value) {
+  const cache = useRef2(value);
+  useEffect2(() => {
+    if (!shallowEqual(cache.current, value)) {
+      cache.current = value;
+    }
+  }, [value]);
+  return shallowEqual(cache.current, value) ? cache.current : value;
+}
+
+// src/query/react/buildHooks.ts
+var canUseDOM = () => !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+var isDOM = /* @__PURE__ */ canUseDOM();
+var isRunningInReactNative = () => typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var isReactNative = /* @__PURE__ */ isRunningInReactNative();
+var getUseIsomorphicLayoutEffect = () => isDOM || isReactNative ? useLayoutEffect : useEffect3;
+var useIsomorphicLayoutEffect = /* @__PURE__ */ getUseIsomorphicLayoutEffect();
+var noPendingQueryStateSelector = (selected) => {
+  if (selected.isUninitialized) {
+    return {
+      ...selected,
+      isUninitialized: false,
+      isFetching: true,
+      isLoading: selected.data !== void 0 ? false : true,
+      status: QueryStatus.pending
+    };
+  }
+  return selected;
+};
+function pick(obj, ...keys) {
+  const ret = {};
+  keys.forEach((key) => {
+    ret[key] = obj[key];
+  });
+  return ret;
+}
+var COMMON_HOOK_DEBUG_FIELDS = ["data", "status", "isLoading", "isSuccess", "isError", "error"];
+function buildHooks({
+  api,
+  moduleOptions: {
+    batch,
+    hooks: {
+      useDispatch,
+      useSelector,
+      useStore
+    },
+    unstable__sideEffectsInRender,
+    createSelector
+  },
+  serializeQueryArgs,
+  context
+}) {
+  const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : useEffect3;
+  return {
+    buildQueryHooks,
+    buildInfiniteQueryHooks,
+    buildMutationHook,
+    usePrefetch
+  };
+  function queryStatePreSelector(currentState, lastResult, queryArgs) {
+    if (lastResult?.endpointName && currentState.isUninitialized) {
+      const {
+        endpointName
+      } = lastResult;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      if (queryArgs !== skipToken && serializeQueryArgs({
+        queryArgs: lastResult.originalArgs,
+        endpointDefinition,
+        endpointName
+      }) === serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      })) lastResult = void 0;
+    }
+    let data = currentState.isSuccess ? currentState.data : lastResult?.data;
+    if (data === void 0) data = currentState.data;
+    const hasData = data !== void 0;
+    const isFetching = currentState.isLoading;
+    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
+    const isSuccess = currentState.isSuccess || hasData && (isFetching && !lastResult?.isError || currentState.isUninitialized);
+    return {
+      ...currentState,
+      data,
+      currentData: currentState.data,
+      isFetching,
+      isLoading,
+      isSuccess
+    };
+  }
+  function infiniteQueryStatePreSelector(currentState, lastResult, queryArgs) {
+    if (lastResult?.endpointName && currentState.isUninitialized) {
+      const {
+        endpointName
+      } = lastResult;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      if (queryArgs !== skipToken && serializeQueryArgs({
+        queryArgs: lastResult.originalArgs,
+        endpointDefinition,
+        endpointName
+      }) === serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      })) lastResult = void 0;
+    }
+    let data = currentState.isSuccess ? currentState.data : lastResult?.data;
+    if (data === void 0) data = currentState.data;
+    const hasData = data !== void 0;
+    const isFetching = currentState.isLoading;
+    const isLoading = (!lastResult || lastResult.isLoading || lastResult.isUninitialized) && !hasData && isFetching;
+    const isSuccess = currentState.isSuccess || isFetching && hasData;
+    return {
+      ...currentState,
+      data,
+      currentData: currentState.data,
+      isFetching,
+      isLoading,
+      isSuccess
+    };
+  }
+  function usePrefetch(endpointName, defaultOptions) {
+    const dispatch = useDispatch();
+    const stableDefaultOptions = useShallowStableValue(defaultOptions);
+    return useCallback((arg, options) => dispatch(api.util.prefetch(endpointName, arg, {
+      ...stableDefaultOptions,
+      ...options
+    })), [endpointName, dispatch, stableDefaultOptions]);
+  }
+  function useQuerySubscriptionCommonImpl(endpointName, arg, {
+    refetchOnReconnect,
+    refetchOnFocus,
+    refetchOnMountOrArgChange,
+    skip = false,
+    pollingInterval = 0,
+    skipPollingIfUnfocused = false,
+    ...rest
+  } = {}) {
+    const {
+      initiate
+    } = api.endpoints[endpointName];
+    const dispatch = useDispatch();
+    const subscriptionSelectorsRef = useRef3(void 0);
+    if (!subscriptionSelectorsRef.current) {
+      const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());
+      if (process.env.NODE_ENV !== "production") {
+        if (typeof returnedValue !== "object" || typeof returnedValue?.type === "string") {
+          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.
+    You must add the middleware for RTK-Query to function correctly!`);
+        }
+      }
+      subscriptionSelectorsRef.current = returnedValue;
+    }
+    const stableArg = useStableQueryArgs(
+      skip ? skipToken : arg,
+      // Even if the user provided a per-endpoint `serializeQueryArgs` with
+      // a consistent return value, _here_ we want to use the default behavior
+      // so we can tell if _anything_ actually changed. Otherwise, we can end up
+      // with a case where the query args did change but the serialization doesn't,
+      // and then we never try to initiate a refetch.
+      defaultSerializeQueryArgs,
+      context.endpointDefinitions[endpointName],
+      endpointName
+    );
+    const stableSubscriptionOptions = useShallowStableValue({
+      refetchOnReconnect,
+      refetchOnFocus,
+      pollingInterval,
+      skipPollingIfUnfocused
+    });
+    const initialPageParam = rest.initialPageParam;
+    const stableInitialPageParam = useShallowStableValue(initialPageParam);
+    const promiseRef = useRef3(void 0);
+    let {
+      queryCacheKey,
+      requestId
+    } = promiseRef.current || {};
+    let currentRenderHasSubscription = false;
+    if (queryCacheKey && requestId) {
+      currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);
+    }
+    const subscriptionRemoved = !currentRenderHasSubscription && promiseRef.current !== void 0;
+    usePossiblyImmediateEffect(() => {
+      if (subscriptionRemoved) {
+        promiseRef.current = void 0;
+      }
+    }, [subscriptionRemoved]);
+    usePossiblyImmediateEffect(() => {
+      const lastPromise = promiseRef.current;
+      if (typeof process !== "undefined" && process.env.NODE_ENV === "removeMeOnCompilation") {
+        console.log(subscriptionRemoved);
+      }
+      if (stableArg === skipToken) {
+        lastPromise?.unsubscribe();
+        promiseRef.current = void 0;
+        return;
+      }
+      const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;
+      if (!lastPromise || lastPromise.arg !== stableArg) {
+        lastPromise?.unsubscribe();
+        const promise = dispatch(initiate(stableArg, {
+          subscriptionOptions: stableSubscriptionOptions,
+          forceRefetch: refetchOnMountOrArgChange,
+          ...isInfiniteQueryDefinition(context.endpointDefinitions[endpointName]) ? {
+            initialPageParam: stableInitialPageParam
+          } : {}
+        }));
+        promiseRef.current = promise;
+      } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+        lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);
+      }
+    }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved, stableInitialPageParam, endpointName]);
+    return [promiseRef, dispatch, initiate, stableSubscriptionOptions];
+  }
+  function buildUseQueryState(endpointName, preSelector) {
+    const useQueryState = (arg, {
+      skip = false,
+      selectFromResult
+    } = {}) => {
+      const {
+        select
+      } = api.endpoints[endpointName];
+      const stableArg = useStableQueryArgs(skip ? skipToken : arg, serializeQueryArgs, context.endpointDefinitions[endpointName], endpointName);
+      const lastValue = useRef3(void 0);
+      const selectDefaultResult = useMemo2(() => (
+        // Normally ts-ignores are bad and should be avoided, but we're
+        // already casting this selector to be `Selector<any>` anyway,
+        // so the inconsistencies don't matter here
+        // @ts-ignore
+        createSelector([
+          // @ts-ignore
+          select(stableArg),
+          (_, lastResult) => lastResult,
+          (_) => stableArg
+        ], preSelector, {
+          memoizeOptions: {
+            resultEqualityCheck: shallowEqual2
+          }
+        })
+      ), [select, stableArg]);
+      const querySelector = useMemo2(() => selectFromResult ? createSelector([selectDefaultResult], selectFromResult, {
+        devModeChecks: {
+          identityFunctionCheck: "never"
+        }
+      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);
+      const currentState = useSelector((state) => querySelector(state, lastValue.current), shallowEqual2);
+      const store = useStore();
+      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);
+      useIsomorphicLayoutEffect(() => {
+        lastValue.current = newLastValue;
+      }, [newLastValue]);
+      return currentState;
+    };
+    return useQueryState;
+  }
+  function usePromiseRefUnsubscribeOnUnmount(promiseRef) {
+    useEffect3(() => {
+      return () => {
+        promiseRef.current?.unsubscribe?.();
+        promiseRef.current = void 0;
+      };
+    }, [promiseRef]);
+  }
+  function refetchOrErrorIfUnmounted(promiseRef) {
+    if (!promiseRef.current) throw new Error(process.env.NODE_ENV === "production" ? _formatProdErrorMessage2(38) : "Cannot refetch a query that has not been started yet.");
+    return promiseRef.current.refetch();
+  }
+  function buildQueryHooks(endpointName) {
+    const useQuerySubscription = (arg, options = {}) => {
+      const [promiseRef] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
+      usePromiseRefUnsubscribeOnUnmount(promiseRef);
+      return useMemo2(() => ({
+        /**
+         * A method to manually refetch data for the query
+         */
+        refetch: () => refetchOrErrorIfUnmounted(promiseRef)
+      }), [promiseRef]);
+    };
+    const useLazyQuerySubscription = ({
+      refetchOnReconnect,
+      refetchOnFocus,
+      pollingInterval = 0,
+      skipPollingIfUnfocused = false
+    } = {}) => {
+      const {
+        initiate
+      } = api.endpoints[endpointName];
+      const dispatch = useDispatch();
+      const [arg, setArg] = useState(UNINITIALIZED_VALUE);
+      const promiseRef = useRef3(void 0);
+      const stableSubscriptionOptions = useShallowStableValue({
+        refetchOnReconnect,
+        refetchOnFocus,
+        pollingInterval,
+        skipPollingIfUnfocused
+      });
+      usePossiblyImmediateEffect(() => {
+        const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;
+        if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+          promiseRef.current?.updateSubscriptionOptions(stableSubscriptionOptions);
+        }
+      }, [stableSubscriptionOptions]);
+      const subscriptionOptionsRef = useRef3(stableSubscriptionOptions);
+      usePossiblyImmediateEffect(() => {
+        subscriptionOptionsRef.current = stableSubscriptionOptions;
+      }, [stableSubscriptionOptions]);
+      const trigger = useCallback(function(arg2, preferCacheValue = false) {
+        let promise;
+        batch(() => {
+          promiseRef.current?.unsubscribe();
+          promiseRef.current = promise = dispatch(initiate(arg2, {
+            subscriptionOptions: subscriptionOptionsRef.current,
+            forceRefetch: !preferCacheValue
+          }));
+          setArg(arg2);
+        });
+        return promise;
+      }, [dispatch, initiate]);
+      const reset = useCallback(() => {
+        if (promiseRef.current?.queryCacheKey) {
+          dispatch(api.internalActions.removeQueryResult({
+            queryCacheKey: promiseRef.current?.queryCacheKey
+          }));
+        }
+      }, [dispatch]);
+      useEffect3(() => {
+        return () => {
+          promiseRef?.current?.unsubscribe();
+        };
+      }, []);
+      useEffect3(() => {
+        if (arg !== UNINITIALIZED_VALUE && !promiseRef.current) {
+          trigger(arg, true);
+        }
+      }, [arg, trigger]);
+      return useMemo2(() => [trigger, arg, {
+        reset
+      }], [trigger, arg, reset]);
+    };
+    const useQueryState = buildUseQueryState(endpointName, queryStatePreSelector);
+    return {
+      useQueryState,
+      useQuerySubscription,
+      useLazyQuerySubscription,
+      useLazyQuery(options) {
+        const [trigger, arg, {
+          reset
+        }] = useLazyQuerySubscription(options);
+        const queryStateResults = useQueryState(arg, {
+          ...options,
+          skip: arg === UNINITIALIZED_VALUE
+        });
+        const info = useMemo2(() => ({
+          lastArg: arg
+        }), [arg]);
+        return useMemo2(() => [trigger, {
+          ...queryStateResults,
+          reset
+        }, info], [trigger, queryStateResults, reset, info]);
+      },
+      useQuery(arg, options) {
+        const querySubscriptionResults = useQuerySubscription(arg, options);
+        const queryStateResults = useQueryState(arg, {
+          selectFromResult: arg === skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,
+          ...options
+        });
+        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS);
+        useDebugValue(debugValue);
+        return useMemo2(() => ({
+          ...queryStateResults,
+          ...querySubscriptionResults
+        }), [queryStateResults, querySubscriptionResults]);
+      }
+    };
+  }
+  function buildInfiniteQueryHooks(endpointName) {
+    const useInfiniteQuerySubscription = (arg, options = {}) => {
+      const [promiseRef, dispatch, initiate, stableSubscriptionOptions] = useQuerySubscriptionCommonImpl(endpointName, arg, options);
+      const subscriptionOptionsRef = useRef3(stableSubscriptionOptions);
+      usePossiblyImmediateEffect(() => {
+        subscriptionOptionsRef.current = stableSubscriptionOptions;
+      }, [stableSubscriptionOptions]);
+      const trigger = useCallback(function(arg2, direction) {
+        let promise;
+        batch(() => {
+          promiseRef.current?.unsubscribe();
+          promiseRef.current = promise = dispatch(initiate(arg2, {
+            subscriptionOptions: subscriptionOptionsRef.current,
+            direction
+          }));
+        });
+        return promise;
+      }, [promiseRef, dispatch, initiate]);
+      usePromiseRefUnsubscribeOnUnmount(promiseRef);
+      const stableArg = useStableQueryArgs(
+        options.skip ? skipToken : arg,
+        // Even if the user provided a per-endpoint `serializeQueryArgs` with
+        // a consistent return value, _here_ we want to use the default behavior
+        // so we can tell if _anything_ actually changed. Otherwise, we can end up
+        // with a case where the query args did change but the serialization doesn't,
+        // and then we never try to initiate a refetch.
+        defaultSerializeQueryArgs,
+        context.endpointDefinitions[endpointName],
+        endpointName
+      );
+      const refetch = useCallback(() => refetchOrErrorIfUnmounted(promiseRef), [promiseRef]);
+      return useMemo2(() => {
+        const fetchNextPage = () => {
+          return trigger(stableArg, "forward");
+        };
+        const fetchPreviousPage = () => {
+          return trigger(stableArg, "backward");
+        };
+        return {
+          trigger,
+          /**
+           * A method to manually refetch data for the query
+           */
+          refetch,
+          fetchNextPage,
+          fetchPreviousPage
+        };
+      }, [refetch, trigger, stableArg]);
+    };
+    const useInfiniteQueryState = buildUseQueryState(endpointName, infiniteQueryStatePreSelector);
+    return {
+      useInfiniteQueryState,
+      useInfiniteQuerySubscription,
+      useInfiniteQuery(arg, options) {
+        const {
+          refetch,
+          fetchNextPage,
+          fetchPreviousPage
+        } = useInfiniteQuerySubscription(arg, options);
+        const queryStateResults = useInfiniteQueryState(arg, {
+          selectFromResult: arg === skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,
+          ...options
+        });
+        const debugValue = pick(queryStateResults, ...COMMON_HOOK_DEBUG_FIELDS, "hasNextPage", "hasPreviousPage");
+        useDebugValue(debugValue);
+        return useMemo2(() => ({
+          ...queryStateResults,
+          fetchNextPage,
+          fetchPreviousPage,
+          refetch
+        }), [queryStateResults, fetchNextPage, fetchPreviousPage, refetch]);
+      }
+    };
+  }
+  function buildMutationHook(name) {
+    return ({
+      selectFromResult,
+      fixedCacheKey
+    } = {}) => {
+      const {
+        select,
+        initiate
+      } = api.endpoints[name];
+      const dispatch = useDispatch();
+      const [promise, setPromise] = useState();
+      useEffect3(() => () => {
+        if (!promise?.arg.fixedCacheKey) {
+          promise?.reset();
+        }
+      }, [promise]);
+      const triggerMutation = useCallback(function(arg) {
+        const promise2 = dispatch(initiate(arg, {
+          fixedCacheKey
+        }));
+        setPromise(promise2);
+        return promise2;
+      }, [dispatch, initiate, fixedCacheKey]);
+      const {
+        requestId
+      } = promise || {};
+      const selectDefaultResult = useMemo2(() => select({
+        fixedCacheKey,
+        requestId: promise?.requestId
+      }), [fixedCacheKey, promise, select]);
+      const mutationSelector = useMemo2(() => selectFromResult ? createSelector([selectDefaultResult], selectFromResult) : selectDefaultResult, [selectFromResult, selectDefaultResult]);
+      const currentState = useSelector(mutationSelector, shallowEqual2);
+      const originalArgs = fixedCacheKey == null ? promise?.arg.originalArgs : void 0;
+      const reset = useCallback(() => {
+        batch(() => {
+          if (promise) {
+            setPromise(void 0);
+          }
+          if (fixedCacheKey) {
+            dispatch(api.internalActions.removeMutationResult({
+              requestId,
+              fixedCacheKey
+            }));
+          }
+        });
+      }, [dispatch, fixedCacheKey, promise, requestId]);
+      const debugValue = pick(currentState, ...COMMON_HOOK_DEBUG_FIELDS, "endpointName");
+      useDebugValue(debugValue);
+      const finalState = useMemo2(() => ({
+        ...currentState,
+        originalArgs,
+        reset
+      }), [currentState, originalArgs, reset]);
+      return useMemo2(() => [triggerMutation, finalState], [triggerMutation, finalState]);
+    };
+  }
+}
+
+// src/query/react/module.ts
+var reactHooksModuleName = /* @__PURE__ */ Symbol();
+var reactHooksModule = ({
+  batch = rrBatch,
+  hooks = {
+    useDispatch: rrUseDispatch,
+    useSelector: rrUseSelector,
+    useStore: rrUseStore
+  },
+  createSelector = _createSelector,
+  unstable__sideEffectsInRender = false,
+  ...rest
+} = {}) => {
+  if (process.env.NODE_ENV !== "production") {
+    const hookNames = ["useDispatch", "useSelector", "useStore"];
+    let warned = false;
+    for (const hookName of hookNames) {
+      if (countObjectKeys(rest) > 0) {
+        if (rest[hookName]) {
+          if (!warned) {
+            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 } })`");
+            warned = true;
+          }
+        }
+        hooks[hookName] = rest[hookName];
+      }
+      if (typeof hooks[hookName] !== "function") {
+        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(", ")}.
+Hook ${hookName} was either not provided or not a function.`);
+      }
+    }
+  }
+  return {
+    name: reactHooksModuleName,
+    init(api, {
+      serializeQueryArgs
+    }, context) {
+      const anyApi = api;
+      const {
+        buildQueryHooks,
+        buildInfiniteQueryHooks,
+        buildMutationHook,
+        usePrefetch
+      } = buildHooks({
+        api,
+        moduleOptions: {
+          batch,
+          hooks,
+          unstable__sideEffectsInRender,
+          createSelector
+        },
+        serializeQueryArgs,
+        context
+      });
+      safeAssign(anyApi, {
+        usePrefetch
+      });
+      safeAssign(context, {
+        batch
+      });
+      return {
+        injectEndpoint(endpointName, definition) {
+          if (isQueryDefinition(definition)) {
+            const {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription
+            } = buildQueryHooks(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useQuery,
+              useLazyQuery,
+              useLazyQuerySubscription,
+              useQueryState,
+              useQuerySubscription
+            });
+            api[`use${capitalize(endpointName)}Query`] = useQuery;
+            api[`useLazy${capitalize(endpointName)}Query`] = useLazyQuery;
+          }
+          if (isMutationDefinition(definition)) {
+            const useMutation = buildMutationHook(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useMutation
+            });
+            api[`use${capitalize(endpointName)}Mutation`] = useMutation;
+          } else if (isInfiniteQueryDefinition(definition)) {
+            const {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState
+            } = buildInfiniteQueryHooks(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useInfiniteQuery,
+              useInfiniteQuerySubscription,
+              useInfiniteQueryState
+            });
+            api[`use${capitalize(endpointName)}InfiniteQuery`] = useInfiniteQuery;
+          }
+        }
+      };
+    }
+  };
+};
+
+// src/query/react/index.ts
+export * from "@reduxjs/toolkit/query";
+
+// src/query/react/ApiProvider.tsx
+import { configureStore, formatProdErrorMessage as _formatProdErrorMessage4 } from "@reduxjs/toolkit";
+import { useContext } from "react";
+import { useEffect as useEffect4 } from "react";
+import * as React from "react";
+import { Provider, ReactReduxContext } from "react-redux";
+import { setupListeners } from "@reduxjs/toolkit/query";
+function ApiProvider(props) {
+  const context = props.context || ReactReduxContext;
+  const existingContext = useContext(context);
+  if (existingContext) {
+    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.");
+  }
+  const [store] = React.useState(() => configureStore({
+    reducer: {
+      [props.api.reducerPath]: props.api.reducer
+    },
+    middleware: (gDM) => gDM().concat(props.api.middleware)
+  }));
+  useEffect4(() => props.setupListeners === false ? void 0 : setupListeners(store.dispatch, props.setupListeners), [props.setupListeners, store.dispatch]);
+  return /* @__PURE__ */ React.createElement(Provider, { store, context }, props.children);
+}
+
+// src/query/react/index.ts
+var createApi = /* @__PURE__ */ buildCreateApi(coreModule(), reactHooksModule());
+export {
+  ApiProvider,
+  UNINITIALIZED_VALUE,
+  createApi,
+  reactHooksModule,
+  reactHooksModuleName
+};
+//# sourceMappingURL=rtk-query-react.modern.mjs.map

frontend/node_modules/@reduxjs/toolkit/dist/query/rtk-query.browser.mjs

@@ -0,0 +1,2 @@
+var Ue=(y=>(y.uninitialized="uninitialized",y.pending="pending",y.fulfilled="fulfilled",y.rejected="rejected",y))(Ue||{});function Le(e){return{status:e,isUninitialized:e==="uninitialized",isLoading:e==="pending",isSuccess:e==="fulfilled",isError:e==="rejected"}}import{createAction as X,createSlice as ae,createSelector as Ye,createAsyncThunk as je,combineReducers as Xe,createNextState as Se,isAnyOf as oe,isAllOf as Pe,isAction as Ze,isPending as Ie,isRejected as fe,isFulfilled as W,isRejectedWithValue as me,isAsyncThunkAction as He,prepareAutoBatched as ge,SHOULD_AUTOBATCH as ke,isPlainObject as te,nanoid as Be}from"@reduxjs/toolkit";var et=te;function Me(e,n){if(e===n||!(et(e)&&et(n)||Array.isArray(e)&&Array.isArray(n)))return n;let d=Object.keys(n),g=Object.keys(e),y=d.length===g.length,x=Array.isArray(n)?[]:{};for(let T of d)x[T]=Me(e[T],n[T]),y&&(y=e[T]===x[T]);return y?e:x}function J(e){let n=0;for(let d in e)n++;return n}var _e=e=>[].concat(...e);function tt(e){return new RegExp("(^|:)//").test(e)}function nt(){return typeof document>"u"?!0:document.visibilityState!=="hidden"}function se(e){return e!=null}function rt(){return typeof navigator>"u"||navigator.onLine===void 0?!0:navigator.onLine}var Ct=e=>e.replace(/\/$/,""),Ft=e=>e.replace(/^\//,"");function it(e,n){if(!e)return n;if(!n)return e;if(tt(n))return n;let d=e.endsWith("/")||!n.startsWith("?")?"/":"";return e=Ct(e),n=Ft(n),`${e}${d}${n}`}function at(e,n,d){return e.has(n)?e.get(n):e.set(n,d).get(n)}var ot=(...e)=>fetch(...e),vt=e=>e.status>=200&&e.status<=299,Ot=e=>/ion\/(vnd\.api\+)?json/.test(e.get("content-type")||"");function st(e){if(!te(e))return e;let n={...e};for(let[d,g]of Object.entries(n))g===void 0&&delete n[d];return n}function Nt({baseUrl:e,prepareHeaders:n=h=>h,fetchFn:d=ot,paramsSerializer:g,isJsonContentType:y=Ot,jsonContentType:x="application/json",jsonReplacer:T,timeout:k,responseHandler:w,validateStatus:A,...P}={}){return typeof fetch>"u"&&d===ot&&console.warn("Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments."),async(R,a,f)=>{let{getState:B,extra:p,endpoint:o,forced:S,type:c}=a,u,{url:m,headers:D=new Headers(P.headers),params:b=void 0,responseHandler:I=w??"json",validateStatus:Q=A??vt,timeout:s=k,...t}=typeof R=="string"?{url:R}:R,r,i=a.signal;s&&(r=new AbortController,a.signal.addEventListener("abort",r.abort),i=r.signal);let l={...P,signal:i,...t};D=new Headers(st(D)),l.headers=await n(D,{getState:B,arg:R,extra:p,endpoint:o,forced:S,type:c,extraOptions:f})||D;let E=N=>typeof N=="object"&&(te(N)||Array.isArray(N)||typeof N.toJSON=="function");if(!l.headers.has("content-type")&&E(l.body)&&l.headers.set("content-type",x),E(l.body)&&y(l.headers)&&(l.body=JSON.stringify(l.body,T)),b){let N=~m.indexOf("?")?"&":"?",F=g?g(b):new URLSearchParams(st(b));m+=N+F}m=it(e,m);let v=new Request(m,l);u={request:new Request(m,l)};let C,M=!1,K=r&&setTimeout(()=>{M=!0,r.abort()},s);try{C=await d(v)}catch(N){return{error:{status:M?"TIMEOUT_ERROR":"FETCH_ERROR",error:String(N)},meta:u}}finally{K&&clearTimeout(K),r?.signal.removeEventListener("abort",r.abort)}let j=C.clone();u.response=j;let z,L="";try{let N;if(await Promise.all([h(C,I).then(F=>z=F,F=>N=F),j.text().then(F=>L=F,()=>{})]),N)throw N}catch(N){return{error:{status:"PARSING_ERROR",originalStatus:C.status,data:L,error:String(N)},meta:u}}return Q(C,z)?{data:z,meta:u}:{error:{status:C.status,data:z},meta:u}};async function h(R,a){if(typeof a=="function")return a(R);if(a==="content-type"&&(a=y(R.headers)?"json":"text"),a==="json"){let f=await R.text();return f.length?JSON.parse(f):null}return R.text()}}var G=class{constructor(n,d=void 0){this.value=n;this.meta=d}};async function qt(e=0,n=5){let d=Math.min(e,n),g=~~((Math.random()+.4)*(300<<d));await new Promise(y=>setTimeout(x=>y(x),g))}function Kt(e,n){throw Object.assign(new G({error:e,meta:n}),{throwImmediately:!0})}var ut={},Ut=(e,n)=>async(d,g,y)=>{let x=[5,(n||ut).maxRetries,(y||ut).maxRetries].filter(P=>P!==void 0),[T]=x.slice(-1),w={maxRetries:T,backoff:qt,retryCondition:(P,h,{attempt:R})=>R<=T,...n,...y},A=0;for(;;)try{let P=await e(d,g,y);if(P.error)throw new G(P);return P}catch(P){if(A++,P.throwImmediately){if(P instanceof G)return P.value;throw P}if(P instanceof G&&!w.retryCondition(P.value.error,d,{attempt:A,baseQueryApi:g,extraOptions:y}))return P.value;await w.backoff(A,w.maxRetries)}},Lt=Object.assign(Ut,{fail:Kt});var ne=X("__rtkq/focused"),Qe=X("__rtkq/unfocused"),re=X("__rtkq/online"),Te=X("__rtkq/offline"),Ve=!1;function jt(e,n){function d(){let g=()=>e(ne()),y=()=>e(Qe()),x=()=>e(re()),T=()=>e(Te()),k=()=>{window.document.visibilityState==="visible"?g():y()};return Ve||typeof window<"u"&&window.addEventListener&&(window.addEventListener("visibilitychange",k,!1),window.addEventListener("focus",g,!1),window.addEventListener("online",x,!1),window.addEventListener("offline",T,!1),Ve=!0),()=>{window.removeEventListener("focus",g),window.removeEventListener("visibilitychange",k),window.removeEventListener("online",x),window.removeEventListener("offline",T),Ve=!1}}return n?n(e,{onFocus:ne,onFocusLost:Qe,onOffline:Te,onOnline:re}):d()}function ue(e){return e.type==="query"}function yt(e){return e.type==="mutation"}function ye(e){return e.type==="infinitequery"}function he(e){return ue(e)||ye(e)}function xe(e,n,d,g,y,x){return Ht(e)?e(n,d,g,y).filter(se).map(we).map(x):Array.isArray(e)?e.map(we).map(x):[]}function Ht(e){return typeof e=="function"}function we(e){return typeof e=="string"?{type:e}:e}import{isDraftable as Vt,produceWithPatches as zt}from"immer";import"@reduxjs/toolkit";function dt(e,n){return e.catch(n)}var Ae=Symbol("forceQueryFn"),De=e=>typeof e[Ae]=="function";function pt({serializeQueryArgs:e,queryThunk:n,infiniteQueryThunk:d,mutationThunk:g,api:y,context:x}){let T=new Map,k=new Map,{unsubscribeQueryResult:w,removeMutationResult:A,updateSubscriptionOptions:P}=y.internalActions;return{buildInitiateQuery:o,buildInitiateInfiniteQuery:S,buildInitiateMutation:c,getRunningQueryThunk:h,getRunningMutationThunk:R,getRunningQueriesThunk:a,getRunningMutationsThunk:f};function h(u,m){return D=>{let b=x.endpointDefinitions[u],I=e({queryArgs:m,endpointDefinition:b,endpointName:u});return T.get(D)?.[I]}}function R(u,m){return D=>k.get(D)?.[m]}function a(){return u=>Object.values(T.get(u)||{}).filter(se)}function f(){return u=>Object.values(k.get(u)||{}).filter(se)}function B(u){}function p(u,m){let D=(b,{subscribe:I=!0,forceRefetch:Q,subscriptionOptions:s,[Ae]:t,...r}={})=>(i,l)=>{let E=e({queryArgs:b,endpointDefinition:m,endpointName:u}),v,O={...r,type:"query",subscribe:I,forceRefetch:Q,subscriptionOptions:s,endpointName:u,originalArgs:b,queryCacheKey:E,[Ae]:t};if(ue(m))v=n(O);else{let{direction:H,initialPageParam:q}=r;v=d({...O,direction:H,initialPageParam:q})}let C=y.endpoints[u].select(b),M=i(v),K=C(l());let{requestId:j,abort:z}=M,L=K.requestId!==j,N=T.get(i)?.[E],F=()=>C(l()),_=Object.assign(t?M.then(F):L&&!N?Promise.resolve(K):Promise.all([N,M]).then(F),{arg:b,requestId:j,subscriptionOptions:s,queryCacheKey:E,abort:z,async unwrap(){let H=await _;if(H.isError)throw H.error;return H.data},refetch:()=>i(D(b,{subscribe:!1,forceRefetch:!0})),unsubscribe(){I&&i(w({queryCacheKey:E,requestId:j}))},updateSubscriptionOptions(H){_.subscriptionOptions=H,i(P({endpointName:u,requestId:j,queryCacheKey:E,options:H}))}});if(!N&&!L&&!t){let H=at(T,i,{});H[E]=_,_.then(()=>{delete H[E],J(H)||T.delete(i)})}return _};return D}function o(u,m){return p(u,m)}function S(u,m){return p(u,m)}function c(u){return(m,{track:D=!0,fixedCacheKey:b}={})=>(I,Q)=>{let s=g({type:"mutation",endpointName:u,originalArgs:m,track:D,fixedCacheKey:b}),t=I(s);let{requestId:r,abort:i,unwrap:l}=t,E=dt(t.unwrap().then(M=>({data:M})),M=>({error:M})),v=()=>{I(A({requestId:r,fixedCacheKey:b}))},O=Object.assign(E,{arg:t.arg,requestId:r,abort:i,unwrap:l,reset:v}),C=k.get(I)||{};return k.set(I,C),C[r]=O,O.then(()=>{delete C[r],J(C)||k.delete(I)}),b&&(C[b]=O,O.then(()=>{C[b]===O&&(delete C[b],J(C)||k.delete(I))})),O}}}import{SchemaError as _t}from"@standard-schema/utils";var Re=class extends _t{constructor(d,g,y,x){super(d);this.value=g;this.schemaName=y;this._bqMeta=x}};async function ie(e,n,d,g){let y=await e["~standard"].validate(n);if(y.issues)throw new Re(y.issues,n,d,g);return y.value}function Wt(e){return e}var be=(e={})=>({...e,[ke]:!0});function ct({reducerPath:e,baseQuery:n,context:{endpointDefinitions:d},serializeQueryArgs:g,api:y,assertTagType:x,selectors:T,onSchemaFailure:k,catchSchemaFailure:w,skipSchemaValidation:A}){let P=(t,r,i,l)=>(E,v)=>{let O=d[t],C=g({queryArgs:r,endpointDefinition:O,endpointName:t});if(E(y.internalActions.queryResultPatched({queryCacheKey:C,patches:i})),!l)return;let M=y.endpoints[t].select(r)(v()),K=xe(O.providesTags,M.data,void 0,r,{},x);E(y.internalActions.updateProvidedBy([{queryCacheKey:C,providedTags:K}]))};function h(t,r,i=0){let l=[r,...t];return i&&l.length>i?l.slice(0,-1):l}function R(t,r,i=0){let l=[...t,r];return i&&l.length>i?l.slice(1):l}let a=(t,r,i,l=!0)=>(E,v)=>{let C=y.endpoints[t].select(r)(v()),M={patches:[],inversePatches:[],undo:()=>E(y.util.patchQueryData(t,r,M.inversePatches,l))};if(C.status==="uninitialized")return M;let K;if("data"in C)if(Vt(C.data)){let[j,z,L]=zt(C.data,i);M.patches.push(...z),M.inversePatches.push(...L),K=j}else K=i(C.data),M.patches.push({op:"replace",path:[],value:K}),M.inversePatches.push({op:"replace",path:[],value:C.data});return M.patches.length===0||E(y.util.patchQueryData(t,r,M.patches,l)),M},f=(t,r,i)=>l=>l(y.endpoints[t].initiate(r,{subscribe:!1,forceRefetch:!0,[Ae]:()=>({data:i})})),B=(t,r)=>t.query&&t[r]?t[r]:Wt,p=async(t,{signal:r,abort:i,rejectWithValue:l,fulfillWithValue:E,dispatch:v,getState:O,extra:C})=>{let M=d[t.endpointName],{metaSchema:K,skipSchemaValidation:j=A}=M;try{let z=B(M,"transformResponse"),L={signal:r,abort:i,dispatch:v,getState:O,extra:C,endpoint:t.endpointName,type:t.type,forced:t.type==="query"?o(t,O()):void 0,queryCacheKey:t.type==="query"?t.queryCacheKey:void 0},N=t.type==="query"?t[Ae]:void 0,F,_=async(q,U,V,pe)=>{if(U==null&&q.pages.length)return Promise.resolve({data:q});let Z={queryArg:t.originalArgs,pageParam:U},ce=await H(Z),$=pe?h:R;return{data:{pages:$(q.pages,ce.data,V),pageParams:$(q.pageParams,U,V)},meta:ce.meta}};async function H(q){let U,{extraOptions:V,argSchema:pe,rawResponseSchema:Z,responseSchema:ce}=M;if(pe&&!j&&(q=await ie(pe,q,"argSchema",{})),N?U=N():M.query?U=await n(M.query(q),L,V):U=await M.queryFn(q,L,V,le=>n(le,L,V)),U.error)throw new G(U.error,U.meta);let{data:$}=U;Z&&!j&&($=await ie(Z,U.data,"rawResponseSchema",U.meta));let ee=await z($,U.meta,q);return ce&&!j&&(ee=await ie(ce,ee,"responseSchema",U.meta)),{...U,data:ee}}if(t.type==="query"&&"infiniteQueryOptions"in M){let{infiniteQueryOptions:q}=M,{maxPages:U=1/0}=q,V,pe={pages:[],pageParams:[]},Z=T.selectQueryEntry(O(),t.queryCacheKey)?.data,$=o(t,O())&&!t.direction||!Z?pe:Z;if("direction"in t&&t.direction&&$.pages.length){let ee=t.direction==="backward",Ee=(ee?ze:Ce)(q,$,t.originalArgs);V=await _($,Ee,U,ee)}else{let{initialPageParam:ee=q.initialPageParam}=t,le=Z?.pageParams??[],Ee=le[0]??ee,Je=le.length;V=await _($,Ee,U),N&&(V={data:V.data.pages[0]});for(let Ge=1;Ge<Je;Ge++){let wt=Ce(q,V.data,t.originalArgs);V=await _(V.data,wt,U)}}F=V}else F=await H(t.originalArgs);return K&&!j&&F.meta&&(F.meta=await ie(K,F.meta,"metaSchema",F.meta)),E(F.data,be({fulfilledTimeStamp:Date.now(),baseQueryMeta:F.meta}))}catch(z){let L=z;if(L instanceof G){let N=B(M,"transformErrorResponse"),{rawErrorResponseSchema:F,errorResponseSchema:_}=M,{value:H,meta:q}=L;try{F&&!j&&(H=await ie(F,H,"rawErrorResponseSchema",q)),K&&!j&&(q=await ie(K,q,"metaSchema",q));let U=await N(H,q,t.originalArgs);return _&&!j&&(U=await ie(_,U,"errorResponseSchema",q)),l(U,be({baseQueryMeta:q}))}catch(U){L=U}}try{if(L instanceof Re){let N={endpoint:t.endpointName,arg:t.originalArgs,type:t.type,queryCacheKey:t.type==="query"?t.queryCacheKey:void 0};M.onSchemaFailure?.(L,N),k?.(L,N);let{catchSchemaFailure:F=w}=M;if(F)return l(F(L,N),be({baseQueryMeta:L._bqMeta}))}}catch(N){L=N}throw console.error(L),L}};function o(t,r){let i=T.selectQueryEntry(r,t.queryCacheKey),l=T.selectConfig(r).refetchOnMountOrArgChange,E=i?.fulfilledTimeStamp,v=t.forceRefetch??(t.subscribe&&l);return v?v===!0||(Number(new Date)-Number(E))/1e3>=v:!1}let S=()=>je(`${e}/executeQuery`,p,{getPendingMeta({arg:r}){let i=d[r.endpointName];return be({startedTimeStamp:Date.now(),...ye(i)?{direction:r.direction}:{}})},condition(r,{getState:i}){let l=i(),E=T.selectQueryEntry(l,r.queryCacheKey),v=E?.fulfilledTimeStamp,O=r.originalArgs,C=E?.originalArgs,M=d[r.endpointName],K=r.direction;return De(r)?!0:E?.status==="pending"?!1:o(r,l)||ue(M)&&M?.forceRefetch?.({currentArg:O,previousArg:C,endpointState:E,state:l})?!0:!(v&&!K)},dispatchConditionRejection:!0}),c=S(),u=S(),m=je(`${e}/executeMutation`,p,{getPendingMeta(){return be({startedTimeStamp:Date.now()})}}),D=t=>"force"in t,b=t=>"ifOlderThan"in t,I=(t,r,i)=>(l,E)=>{let v=D(i)&&i.force,O=b(i)&&i.ifOlderThan,C=(K=!0)=>{let j={forceRefetch:K,isPrefetch:!0};return y.endpoints[t].initiate(r,j)},M=y.endpoints[t].select(r)(E());if(v)l(C());else if(O){let K=M?.fulfilledTimeStamp;if(!K){l(C());return}(Number(new Date)-Number(new Date(K)))/1e3>=O&&l(C())}else l(C(!1))};function Q(t){return r=>r?.meta?.arg?.endpointName===t}function s(t,r){return{matchPending:Pe(Ie(t),Q(r)),matchFulfilled:Pe(W(t),Q(r)),matchRejected:Pe(fe(t),Q(r))}}return{queryThunk:c,mutationThunk:m,infiniteQueryThunk:u,prefetch:I,updateQueryData:a,upsertQueryData:f,patchQueryData:P,buildMatchThunkActions:s}}function Ce(e,{pages:n,pageParams:d},g){let y=n.length-1;return e.getNextPageParam(n[y],n,d[y],d,g)}function ze(e,{pages:n,pageParams:d},g){return e.getPreviousPageParam?.(n[0],n,d[0],d,g)}function Fe(e,n,d,g){return xe(d[e.meta.arg.endpointName][n],W(e)?e.payload:void 0,me(e)?e.payload:void 0,e.meta.arg.originalArgs,"baseQueryMeta"in e.meta?e.meta.baseQueryMeta:void 0,g)}import{isDraft as $t}from"immer";import{applyPatches as lt,original as Jt}from"immer";function ve(e,n,d){let g=e[n];g&&d(g)}function de(e){return("arg"in e?e.arg.fixedCacheKey:e.fixedCacheKey)??e.requestId}function ft(e,n,d){let g=e[de(n)];g&&d(g)}var Oe={};function mt({reducerPath:e,queryThunk:n,mutationThunk:d,serializeQueryArgs:g,context:{endpointDefinitions:y,apiUid:x,extractRehydrationInfo:T,hasRehydrationInfo:k},assertTagType:w,config:A}){let P=X(`${e}/resetApiState`);function h(Q,s,t,r){Q[s.queryCacheKey]??={status:"uninitialized",endpointName:s.endpointName},ve(Q,s.queryCacheKey,i=>{i.status="pending",i.requestId=t&&i.requestId?i.requestId:r.requestId,s.originalArgs!==void 0&&(i.originalArgs=s.originalArgs),i.startedTimeStamp=r.startedTimeStamp;let l=y[r.arg.endpointName];ye(l)&&"direction"in s&&(i.direction=s.direction)})}function R(Q,s,t,r){ve(Q,s.arg.queryCacheKey,i=>{if(i.requestId!==s.requestId&&!r)return;let{merge:l}=y[s.arg.endpointName];if(i.status="fulfilled",l)if(i.data!==void 0){let{fulfilledTimeStamp:E,arg:v,baseQueryMeta:O,requestId:C}=s,M=Se(i.data,K=>l(K,t,{arg:v.originalArgs,baseQueryMeta:O,fulfilledTimeStamp:E,requestId:C}));i.data=M}else i.data=t;else i.data=y[s.arg.endpointName].structuralSharing??!0?Me($t(i.data)?Jt(i.data):i.data,t):t;delete i.error,i.fulfilledTimeStamp=s.fulfilledTimeStamp})}let a=ae({name:`${e}/queries`,initialState:Oe,reducers:{removeQueryResult:{reducer(Q,{payload:{queryCacheKey:s}}){delete Q[s]},prepare:ge()},cacheEntriesUpserted:{reducer(Q,s){for(let t of s.payload){let{queryDescription:r,value:i}=t;h(Q,r,!0,{arg:r,requestId:s.meta.requestId,startedTimeStamp:s.meta.timestamp}),R(Q,{arg:r,requestId:s.meta.requestId,fulfilledTimeStamp:s.meta.timestamp,baseQueryMeta:{}},i,!0)}},prepare:Q=>({payload:Q.map(r=>{let{endpointName:i,arg:l,value:E}=r,v=y[i];return{queryDescription:{type:"query",endpointName:i,originalArgs:r.arg,queryCacheKey:g({queryArgs:l,endpointDefinition:v,endpointName:i})},value:E}}),meta:{[ke]:!0,requestId:Be(),timestamp:Date.now()}})},queryResultPatched:{reducer(Q,{payload:{queryCacheKey:s,patches:t}}){ve(Q,s,r=>{r.data=lt(r.data,t.concat())})},prepare:ge()}},extraReducers(Q){Q.addCase(n.pending,(s,{meta:t,meta:{arg:r}})=>{let i=De(r);h(s,r,i,t)}).addCase(n.fulfilled,(s,{meta:t,payload:r})=>{let i=De(t.arg);R(s,t,r,i)}).addCase(n.rejected,(s,{meta:{condition:t,arg:r,requestId:i},error:l,payload:E})=>{ve(s,r.queryCacheKey,v=>{if(!t){if(v.requestId!==i)return;v.status="rejected",v.error=E??l}})}).addMatcher(k,(s,t)=>{let{queries:r}=T(t);for(let[i,l]of Object.entries(r))(l?.status==="fulfilled"||l?.status==="rejected")&&(s[i]=l)})}}),f=ae({name:`${e}/mutations`,initialState:Oe,reducers:{removeMutationResult:{reducer(Q,{payload:s}){let t=de(s);t in Q&&delete Q[t]},prepare:ge()}},extraReducers(Q){Q.addCase(d.pending,(s,{meta:t,meta:{requestId:r,arg:i,startedTimeStamp:l}})=>{i.track&&(s[de(t)]={requestId:r,status:"pending",endpointName:i.endpointName,startedTimeStamp:l})}).addCase(d.fulfilled,(s,{payload:t,meta:r})=>{r.arg.track&&ft(s,r,i=>{i.requestId===r.requestId&&(i.status="fulfilled",i.data=t,i.fulfilledTimeStamp=r.fulfilledTimeStamp)})}).addCase(d.rejected,(s,{payload:t,error:r,meta:i})=>{i.arg.track&&ft(s,i,l=>{l.requestId===i.requestId&&(l.status="rejected",l.error=t??r)})}).addMatcher(k,(s,t)=>{let{mutations:r}=T(t);for(let[i,l]of Object.entries(r))(l?.status==="fulfilled"||l?.status==="rejected")&&i!==l?.requestId&&(s[i]=l)})}}),B={tags:{},keys:{}},p=ae({name:`${e}/invalidation`,initialState:B,reducers:{updateProvidedBy:{reducer(Q,s){for(let{queryCacheKey:t,providedTags:r}of s.payload){o(Q,t);for(let{type:i,id:l}of r){let E=(Q.tags[i]??={})[l||"__internal_without_id"]??=[];E.includes(t)||E.push(t)}Q.keys[t]=r}},prepare:ge()}},extraReducers(Q){Q.addCase(a.actions.removeQueryResult,(s,{payload:{queryCacheKey:t}})=>{o(s,t)}).addMatcher(k,(s,t)=>{let{provided:r}=T(t);for(let[i,l]of Object.entries(r))for(let[E,v]of Object.entries(l)){let O=(s.tags[i]??={})[E||"__internal_without_id"]??=[];for(let C of v)O.includes(C)||O.push(C)}}).addMatcher(oe(W(n),me(n)),(s,t)=>{S(s,[t])}).addMatcher(a.actions.cacheEntriesUpserted.match,(s,t)=>{let r=t.payload.map(({queryDescription:i,value:l})=>({type:"UNKNOWN",payload:l,meta:{requestStatus:"fulfilled",requestId:"UNKNOWN",arg:i}}));S(s,r)})}});function o(Q,s){let t=Q.keys[s]??[];for(let r of t){let i=r.type,l=r.id??"__internal_without_id",E=Q.tags[i]?.[l];E&&(Q.tags[i][l]=E.filter(v=>v!==s))}delete Q.keys[s]}function S(Q,s){let t=s.map(r=>{let i=Fe(r,"providesTags",y,w),{queryCacheKey:l}=r.meta.arg;return{queryCacheKey:l,providedTags:i}});p.caseReducers.updateProvidedBy(Q,p.actions.updateProvidedBy(t))}let c=ae({name:`${e}/subscriptions`,initialState:Oe,reducers:{updateSubscriptionOptions(Q,s){},unsubscribeQueryResult(Q,s){},internal_getRTKQSubscriptions(){}}}),u=ae({name:`${e}/internalSubscriptions`,initialState:Oe,reducers:{subscriptionsUpdated:{reducer(Q,s){return lt(Q,s.payload)},prepare:ge()}}}),m=ae({name:`${e}/config`,initialState:{online:rt(),focused:nt(),middlewareRegistered:!1,...A},reducers:{middlewareRegistered(Q,{payload:s}){Q.middlewareRegistered=Q.middlewareRegistered==="conflict"||x!==s?"conflict":!0}},extraReducers:Q=>{Q.addCase(re,s=>{s.online=!0}).addCase(Te,s=>{s.online=!1}).addCase(ne,s=>{s.focused=!0}).addCase(Qe,s=>{s.focused=!1}).addMatcher(k,s=>({...s}))}}),D=Xe({queries:a.reducer,mutations:f.reducer,provided:p.reducer,subscriptions:u.reducer,config:m.reducer}),b=(Q,s)=>D(P.match(s)?void 0:Q,s),I={...m.actions,...a.actions,...c.actions,...u.actions,...f.actions,...p.actions,resetApiState:P};return{reducer:b,actions:I}}var Ne=Symbol.for("RTKQ/skipToken"),Tt={status:"uninitialized"},gt=Se(Tt,()=>{}),Qt=Se(Tt,()=>{});function ht({serializeQueryArgs:e,reducerPath:n,createSelector:d}){let g=c=>gt,y=c=>Qt;return{buildQuerySelector:R,buildInfiniteQuerySelector:a,buildMutationSelector:f,selectInvalidatedBy:B,selectCachedArgsForQuery:p,selectApiState:T,selectQueries:k,selectMutations:A,selectQueryEntry:w,selectConfig:P};function x(c){return{...c,...Le(c.status)}}function T(c){return c[n]}function k(c){return T(c)?.queries}function w(c,u){return k(c)?.[u]}function A(c){return T(c)?.mutations}function P(c){return T(c)?.config}function h(c,u,m){return D=>{if(D===Ne)return d(g,m);let b=e({queryArgs:D,endpointDefinition:u,endpointName:c});return d(Q=>w(Q,b)??gt,m)}}function R(c,u){return h(c,u,x)}function a(c,u){let{infiniteQueryOptions:m}=u;function D(b){let I={...b,...Le(b.status)},{isLoading:Q,isError:s,direction:t}=I,r=t==="forward",i=t==="backward";return{...I,hasNextPage:o(m,I.data,I.originalArgs),hasPreviousPage:S(m,I.data,I.originalArgs),isFetchingNextPage:Q&&r,isFetchingPreviousPage:Q&&i,isFetchNextPageError:s&&r,isFetchPreviousPageError:s&&i}}return h(c,u,D)}function f(){return c=>{let u;return typeof c=="object"?u=de(c)??Ne:u=c,d(u===Ne?y:b=>T(b)?.mutations?.[u]??Qt,x)}}function B(c,u){let m=c[n],D=new Set;for(let b of u.filter(se).map(we)){let I=m.provided.tags[b.type];if(!I)continue;let Q=(b.id!==void 0?I[b.id]:_e(Object.values(I)))??[];for(let s of Q)D.add(s)}return _e(Array.from(D.values()).map(b=>{let I=m.queries[b];return I?[{queryCacheKey:b,endpointName:I.endpointName,originalArgs:I.originalArgs}]:[]}))}function p(c,u){return Object.values(k(c)).filter(m=>m?.endpointName===u&&m.status!=="uninitialized").map(m=>m.originalArgs)}function o(c,u,m){return u?Ce(c,u,m)!=null:!1}function S(c,u,m){return!u||!c.getPreviousPageParam?!1:ze(c,u,m)!=null}}import{formatProdErrorMessage as Gt}from"@reduxjs/toolkit";var At=WeakMap?new WeakMap:void 0,qe=({endpointName:e,queryArgs:n})=>{let d="",g=At?.get(n);if(typeof g=="string")d=g;else{let y=JSON.stringify(n,(x,T)=>(T=typeof T=="bigint"?{$bigint:T.toString()}:T,T=te(T)?Object.keys(T).sort().reduce((k,w)=>(k[w]=T[w],k),{}):T,T));te(n)&&At?.set(n,y),d=y}return`${e}(${d})`};import{weakMapMemoize as Rt}from"reselect";function We(...e){return function(d){let g=Rt(A=>d.extractRehydrationInfo?.(A,{reducerPath:d.reducerPath??"api"})),y={reducerPath:"api",keepUnusedDataFor:60,refetchOnMountOrArgChange:!1,refetchOnFocus:!1,refetchOnReconnect:!1,invalidationBehavior:"delayed",...d,extractRehydrationInfo:g,serializeQueryArgs(A){let P=qe;if("serializeQueryArgs"in A.endpointDefinition){let h=A.endpointDefinition.serializeQueryArgs;P=R=>{let a=h(R);return typeof a=="string"?a:qe({...R,queryArgs:a})}}else d.serializeQueryArgs&&(P=d.serializeQueryArgs);return P(A)},tagTypes:[...d.tagTypes||[]]},x={endpointDefinitions:{},batch(A){A()},apiUid:Be(),extractRehydrationInfo:g,hasRehydrationInfo:Rt(A=>g(A)!=null)},T={injectEndpoints:w,enhanceEndpoints({addTagTypes:A,endpoints:P}){if(A)for(let h of A)y.tagTypes.includes(h)||y.tagTypes.push(h);if(P)for(let[h,R]of Object.entries(P))typeof R=="function"?R(x.endpointDefinitions[h]):Object.assign(x.endpointDefinitions[h]||{},R);return T}},k=e.map(A=>A.init(T,y,x));function w(A){let P=A.endpoints({query:h=>({...h,type:"query"}),mutation:h=>({...h,type:"mutation"}),infiniteQuery:h=>({...h,type:"infinitequery"})});for(let[h,R]of Object.entries(P)){if(A.overrideExisting!==!0&&h in x.endpointDefinitions){if(A.overrideExisting==="throw")throw new Error(Gt(39));continue}x.endpointDefinitions[h]=R;for(let a of k)a.injectEndpoint(h,R)}return T}return T.injectEndpoints({endpoints:d.endpoints})}}import{formatProdErrorMessage as Yt}from"@reduxjs/toolkit";var Xt=Symbol();function Zt(){return function(){throw new Error(Yt(33))}}import{enablePatches as rn}from"immer";function Y(e,...n){return Object.assign(e,...n)}import{produceWithPatches as en}from"immer";var St=({api:e,queryThunk:n,internalState:d})=>{let g=`${e.reducerPath}/subscriptions`,y=null,x=null,{updateSubscriptionOptions:T,unsubscribeQueryResult:k}=e.internalActions,w=(a,f)=>{if(T.match(f)){let{queryCacheKey:p,requestId:o,options:S}=f.payload;return a?.[p]?.[o]&&(a[p][o]=S),!0}if(k.match(f)){let{queryCacheKey:p,requestId:o}=f.payload;return a[p]&&delete a[p][o],!0}if(e.internalActions.removeQueryResult.match(f))return delete a[f.payload.queryCacheKey],!0;if(n.pending.match(f)){let{meta:{arg:p,requestId:o}}=f,S=a[p.queryCacheKey]??={};return S[`${o}_running`]={},p.subscribe&&(S[o]=p.subscriptionOptions??S[o]??{}),!0}let B=!1;if(n.fulfilled.match(f)||n.rejected.match(f)){let p=a[f.meta.arg.queryCacheKey]||{},o=`${f.meta.requestId}_running`;B||=!!p[o],delete p[o]}if(n.rejected.match(f)){let{meta:{condition:p,arg:o,requestId:S}}=f;if(p&&o.subscribe){let c=a[o.queryCacheKey]??={};c[S]=o.subscriptionOptions??c[S]??{},B=!0}}return B},A=()=>d.currentSubscriptions,R={getSubscriptions:A,getSubscriptionCount:a=>{let B=A()[a]??{};return J(B)},isRequestSubscribed:(a,f)=>!!A()?.[a]?.[f]};return(a,f)=>{if(y||(y=JSON.parse(JSON.stringify(d.currentSubscriptions))),e.util.resetApiState.match(a))return y=d.currentSubscriptions={},x=null,[!0,!1];if(e.internalActions.internal_getRTKQSubscriptions.match(a))return[!1,R];let B=w(d.currentSubscriptions,a),p=!0;if(B){x||(x=setTimeout(()=>{let c=JSON.parse(JSON.stringify(d.currentSubscriptions)),[,u]=en(y,()=>c);f.next(e.internalActions.subscriptionsUpdated(u)),y=c,x=null},500));let o=typeof a.type=="string"&&!!a.type.startsWith(g),S=n.rejected.match(a)&&a.meta.condition&&!!a.meta.arg.subscribe;p=!o&&!S}return[p,!1]}};function tn(e){for(let n in e)return!1;return!0}var nn=2147483647/1e3-1,xt=({reducerPath:e,api:n,queryThunk:d,context:g,internalState:y,selectors:{selectQueryEntry:x,selectConfig:T}})=>{let{removeQueryResult:k,unsubscribeQueryResult:w,cacheEntriesUpserted:A}=n.internalActions,P=oe(w.match,d.fulfilled,d.rejected,A.match);function h(p){let o=y.currentSubscriptions[p];return!!o&&!tn(o)}let R={},a=(p,o,S)=>{let c=o.getState(),u=T(c);if(P(p)){let m;if(A.match(p))m=p.payload.map(D=>D.queryDescription.queryCacheKey);else{let{queryCacheKey:D}=w.match(p)?p.payload:p.meta.arg;m=[D]}f(m,o,u)}if(n.util.resetApiState.match(p))for(let[m,D]of Object.entries(R))D&&clearTimeout(D),delete R[m];if(g.hasRehydrationInfo(p)){let{queries:m}=g.extractRehydrationInfo(p);f(Object.keys(m),o,u)}};function f(p,o,S){let c=o.getState();for(let u of p){let m=x(c,u);B(u,m?.endpointName,o,S)}}function B(p,o,S,c){let m=g.endpointDefinitions[o]?.keepUnusedDataFor??c.keepUnusedDataFor;if(m===1/0)return;let D=Math.max(0,Math.min(m,nn));if(!h(p)){let b=R[p];b&&clearTimeout(b),R[p]=setTimeout(()=>{h(p)||S.dispatch(k({queryCacheKey:p})),delete R[p]},D*1e3)}}return a};var Dt=new Error("Promise never resolved before cacheEntryRemoved."),bt=({api:e,reducerPath:n,context:d,queryThunk:g,mutationThunk:y,internalState:x,selectors:{selectQueryEntry:T,selectApiState:k}})=>{let w=He(g),A=He(y),P=W(g,y),h={};function R(o,S,c){let u=h[o];u?.valueResolved&&(u.valueResolved({data:S,meta:c}),delete u.valueResolved)}function a(o){let S=h[o];S&&(delete h[o],S.cacheEntryRemoved())}let f=(o,S,c)=>{let u=B(o);function m(D,b,I,Q){let s=T(c,b),t=T(S.getState(),b);!s&&t&&p(D,Q,b,S,I)}if(g.pending.match(o))m(o.meta.arg.endpointName,u,o.meta.requestId,o.meta.arg.originalArgs);else if(e.internalActions.cacheEntriesUpserted.match(o))for(let{queryDescription:D,value:b}of o.payload){let{endpointName:I,originalArgs:Q,queryCacheKey:s}=D;m(I,s,o.meta.requestId,Q),R(s,b,{})}else if(y.pending.match(o))S.getState()[n].mutations[u]&&p(o.meta.arg.endpointName,o.meta.arg.originalArgs,u,S,o.meta.requestId);else if(P(o))R(u,o.payload,o.meta.baseQueryMeta);else if(e.internalActions.removeQueryResult.match(o)||e.internalActions.removeMutationResult.match(o))a(u);else if(e.util.resetApiState.match(o))for(let D of Object.keys(h))a(D)};function B(o){return w(o)?o.meta.arg.queryCacheKey:A(o)?o.meta.arg.fixedCacheKey??o.meta.requestId:e.internalActions.removeQueryResult.match(o)?o.payload.queryCacheKey:e.internalActions.removeMutationResult.match(o)?de(o.payload):""}function p(o,S,c,u,m){let D=d.endpointDefinitions[o],b=D?.onCacheEntryAdded;if(!b)return;let I={},Q=new Promise(E=>{I.cacheEntryRemoved=E}),s=Promise.race([new Promise(E=>{I.valueResolved=E}),Q.then(()=>{throw Dt})]);s.catch(()=>{}),h[c]=I;let t=e.endpoints[o].select(he(D)?S:c),r=u.dispatch((E,v,O)=>O),i={...u,getCacheEntry:()=>t(u.getState()),requestId:m,extra:r,updateCachedData:he(D)?E=>u.dispatch(e.util.updateQueryData(o,S,E)):void 0,cacheDataLoaded:s,cacheEntryRemoved:Q},l=b(S,i);Promise.resolve(l).catch(E=>{if(E!==Dt)throw E})}return f};var Et=({api:e,context:{apiUid:n},reducerPath:d})=>(g,y)=>{e.util.resetApiState.match(g)&&y.dispatch(e.internalActions.middlewareRegistered(n))};var Pt=({reducerPath:e,context:n,context:{endpointDefinitions:d},mutationThunk:g,queryThunk:y,api:x,assertTagType:T,refetchQuery:k,internalState:w})=>{let{removeQueryResult:A}=x.internalActions,P=oe(W(g),me(g)),h=oe(W(g,y),fe(g,y)),R=[],a=(p,o)=>{P(p)?B(Fe(p,"invalidatesTags",d,T),o):h(p)?B([],o):x.util.invalidateTags.match(p)&&B(xe(p.payload,void 0,void 0,void 0,void 0,T),o)};function f(p){let{queries:o,mutations:S}=p;for(let c of[o,S])for(let u in c)if(c[u]?.status==="pending")return!0;return!1}function B(p,o){let S=o.getState(),c=S[e];if(R.push(...p),c.config.invalidationBehavior==="delayed"&&f(c))return;let u=R;if(R=[],u.length===0)return;let m=x.util.selectInvalidatedBy(S,u);n.batch(()=>{let D=Array.from(m.values());for(let{queryCacheKey:b}of D){let I=c.queries[b],Q=w.currentSubscriptions[b]??{};I&&(J(Q)===0?o.dispatch(A({queryCacheKey:b})):I.status!=="uninitialized"&&o.dispatch(k(I)))}})}return a};var It=({reducerPath:e,queryThunk:n,api:d,refetchQuery:g,internalState:y})=>{let x={},T=(a,f)=>{(d.internalActions.updateSubscriptionOptions.match(a)||d.internalActions.unsubscribeQueryResult.match(a))&&A(a.payload,f),(n.pending.match(a)||n.rejected.match(a)&&a.meta.condition)&&A(a.meta.arg,f),(n.fulfilled.match(a)||n.rejected.match(a)&&!a.meta.condition)&&w(a.meta.arg,f),d.util.resetApiState.match(a)&&h()};function k(a,f){let p=f.getState()[e].queries[a],o=y.currentSubscriptions[a];if(!(!p||p.status==="uninitialized"))return o}function w({queryCacheKey:a},f){let B=f.getState()[e],p=B.queries[a],o=y.currentSubscriptions[a];if(!p||p.status==="uninitialized")return;let{lowestPollingInterval:S,skipPollingIfUnfocused:c}=R(o);if(!Number.isFinite(S))return;let u=x[a];u?.timeout&&(clearTimeout(u.timeout),u.timeout=void 0);let m=Date.now()+S;x[a]={nextPollTimestamp:m,pollingInterval:S,timeout:setTimeout(()=>{(B.config.focused||!c)&&f.dispatch(g(p)),w({queryCacheKey:a},f)},S)}}function A({queryCacheKey:a},f){let p=f.getState()[e].queries[a],o=y.currentSubscriptions[a];if(!p||p.status==="uninitialized")return;let{lowestPollingInterval:S}=R(o);if(!Number.isFinite(S)){P(a);return}let c=x[a],u=Date.now()+S;(!c||u<c.nextPollTimestamp)&&w({queryCacheKey:a},f)}function P(a){let f=x[a];f?.timeout&&clearTimeout(f.timeout),delete x[a]}function h(){for(let a of Object.keys(x))P(a)}function R(a={}){let f=!1,B=Number.POSITIVE_INFINITY;for(let p in a)a[p].pollingInterval&&(B=Math.min(a[p].pollingInterval,B),f=a[p].skipPollingIfUnfocused||f);return{lowestPollingInterval:B,skipPollingIfUnfocused:f}}return T};var kt=({api:e,context:n,queryThunk:d,mutationThunk:g})=>{let y=Ie(d,g),x=fe(d,g),T=W(d,g),k={};return(A,P)=>{if(y(A)){let{requestId:h,arg:{endpointName:R,originalArgs:a}}=A.meta,f=n.endpointDefinitions[R],B=f?.onQueryStarted;if(B){let p={},o=new Promise((m,D)=>{p.resolve=m,p.reject=D});o.catch(()=>{}),k[h]=p;let S=e.endpoints[R].select(he(f)?a:h),c=P.dispatch((m,D,b)=>b),u={...P,getCacheEntry:()=>S(P.getState()),requestId:h,extra:c,updateCachedData:he(f)?m=>P.dispatch(e.util.updateQueryData(R,a,m)):void 0,queryFulfilled:o};B(a,u)}}else if(T(A)){let{requestId:h,baseQueryMeta:R}=A.meta;k[h]?.resolve({data:A.payload,meta:R}),delete k[h]}else if(x(A)){let{requestId:h,rejectedWithValue:R,baseQueryMeta:a}=A.meta;k[h]?.reject({error:A.payload??A.error,isUnhandledError:!R,meta:a}),delete k[h]}}};var Bt=({reducerPath:e,context:n,api:d,refetchQuery:g,internalState:y})=>{let{removeQueryResult:x}=d.internalActions,T=(w,A)=>{ne.match(w)&&k(A,"refetchOnFocus"),re.match(w)&&k(A,"refetchOnReconnect")};function k(w,A){let P=w.getState()[e],h=P.queries,R=y.currentSubscriptions;n.batch(()=>{for(let a of Object.keys(R)){let f=h[a],B=R[a];if(!B||!f)continue;(Object.values(B).some(o=>o[A]===!0)||Object.values(B).every(o=>o[A]===void 0)&&P.config[A])&&(J(B)===0?w.dispatch(x({queryCacheKey:a})):f.status!=="uninitialized"&&w.dispatch(g(f)))}})}return T};function Mt(e){let{reducerPath:n,queryThunk:d,api:g,context:y}=e,{apiUid:x}=y,T={invalidateTags:X(`${n}/invalidateTags`)},k=h=>h.type.startsWith(`${n}/`),w=[Et,xt,Pt,It,bt,kt];return{middleware:h=>{let R=!1,f={...e,internalState:{currentSubscriptions:{}},refetchQuery:P,isThisApiSliceAction:k},B=w.map(S=>S(f)),p=St(f),o=Bt(f);return S=>c=>{if(!Ze(c))return S(c);R||(R=!0,h.dispatch(g.internalActions.middlewareRegistered(x)));let u={...h,next:S},m=h.getState(),[D,b]=p(c,u,m),I;if(D?I=S(c):I=b,h.getState()[n]&&(o(c,u,m),k(c)||y.hasRehydrationInfo(c)))for(let Q of B)Q(c,u,m);return I}},actions:T};function P(h){return e.api.endpoints[h.endpointName].initiate(h.originalArgs,{subscribe:!1,forceRefetch:!0})}}var Ke=Symbol(),$e=({createSelector:e=Ye}={})=>({name:Ke,init(n,{baseQuery:d,tagTypes:g,reducerPath:y,serializeQueryArgs:x,keepUnusedDataFor:T,refetchOnMountOrArgChange:k,refetchOnFocus:w,refetchOnReconnect:A,invalidationBehavior:P,onSchemaFailure:h,catchSchemaFailure:R,skipSchemaValidation:a},f){rn();let B=F=>F;Object.assign(n,{reducerPath:y,endpoints:{},internalActions:{onOnline:re,onOffline:Te,onFocus:ne,onFocusLost:Qe},util:{}});let p=ht({serializeQueryArgs:x,reducerPath:y,createSelector:e}),{selectInvalidatedBy:o,selectCachedArgsForQuery:S,buildQuerySelector:c,buildInfiniteQuerySelector:u,buildMutationSelector:m}=p;Y(n.util,{selectInvalidatedBy:o,selectCachedArgsForQuery:S});let{queryThunk:D,infiniteQueryThunk:b,mutationThunk:I,patchQueryData:Q,updateQueryData:s,upsertQueryData:t,prefetch:r,buildMatchThunkActions:i}=ct({baseQuery:d,reducerPath:y,context:f,api:n,serializeQueryArgs:x,assertTagType:B,selectors:p,onSchemaFailure:h,catchSchemaFailure:R,skipSchemaValidation:a}),{reducer:l,actions:E}=mt({context:f,queryThunk:D,infiniteQueryThunk:b,mutationThunk:I,serializeQueryArgs:x,reducerPath:y,assertTagType:B,config:{refetchOnFocus:w,refetchOnReconnect:A,refetchOnMountOrArgChange:k,keepUnusedDataFor:T,reducerPath:y,invalidationBehavior:P}});Y(n.util,{patchQueryData:Q,updateQueryData:s,upsertQueryData:t,prefetch:r,resetApiState:E.resetApiState,upsertQueryEntries:E.cacheEntriesUpserted}),Y(n.internalActions,E);let{middleware:v,actions:O}=Mt({reducerPath:y,context:f,queryThunk:D,mutationThunk:I,infiniteQueryThunk:b,api:n,assertTagType:B,selectors:p});Y(n.util,O),Y(n,{reducer:l,middleware:v});let{buildInitiateQuery:C,buildInitiateInfiniteQuery:M,buildInitiateMutation:K,getRunningMutationThunk:j,getRunningMutationsThunk:z,getRunningQueriesThunk:L,getRunningQueryThunk:N}=pt({queryThunk:D,mutationThunk:I,infiniteQueryThunk:b,api:n,serializeQueryArgs:x,context:f});return Y(n.util,{getRunningMutationThunk:j,getRunningMutationsThunk:z,getRunningQueryThunk:N,getRunningQueriesThunk:L}),{name:Ke,injectEndpoint(F,_){let H=n,q=H.endpoints[F]??={};ue(_)&&Y(q,{name:F,select:c(F,_),initiate:C(F,_)},i(D,F)),yt(_)&&Y(q,{name:F,select:m(),initiate:K(F)},i(I,F)),ye(_)&&Y(q,{name:F,select:u(F,_),initiate:M(F,_)},i(D,F))}}}});var an=We($e());export{Re as NamedSchemaError,Ue as QueryStatus,Xt as _NEVER,We as buildCreateApi,Me as copyWithStructuralSharing,$e as coreModule,Ke as coreModuleName,an as createApi,qe as defaultSerializeQueryArgs,Zt as fakeBaseQuery,Nt as fetchBaseQuery,Lt as retry,jt as setupListeners,Ne as skipToken};
+//# sourceMappingURL=rtk-query.browser.mjs.map

frontend/node_modules/@reduxjs/toolkit/dist/query/rtk-query.modern.mjs

@@ -0,0 +1,2885 @@
+// src/query/core/apiState.ts
+var QueryStatus = /* @__PURE__ */ ((QueryStatus2) => {
+  QueryStatus2["uninitialized"] = "uninitialized";
+  QueryStatus2["pending"] = "pending";
+  QueryStatus2["fulfilled"] = "fulfilled";
+  QueryStatus2["rejected"] = "rejected";
+  return QueryStatus2;
+})(QueryStatus || {});
+function getRequestStatusFlags(status) {
+  return {
+    status,
+    isUninitialized: status === "uninitialized" /* uninitialized */,
+    isLoading: status === "pending" /* pending */,
+    isSuccess: status === "fulfilled" /* fulfilled */,
+    isError: status === "rejected" /* rejected */
+  };
+}
+
+// src/query/core/rtkImports.ts
+import { createAction, createSlice, createSelector, createAsyncThunk, combineReducers, createNextState, isAnyOf, isAllOf, isAction, isPending, isRejected, isFulfilled, isRejectedWithValue, isAsyncThunkAction, prepareAutoBatched, SHOULD_AUTOBATCH, isPlainObject, nanoid } from "@reduxjs/toolkit";
+
+// src/query/utils/copyWithStructuralSharing.ts
+var isPlainObject2 = isPlainObject;
+function copyWithStructuralSharing(oldObj, newObj) {
+  if (oldObj === newObj || !(isPlainObject2(oldObj) && isPlainObject2(newObj) || Array.isArray(oldObj) && Array.isArray(newObj))) {
+    return newObj;
+  }
+  const newKeys = Object.keys(newObj);
+  const oldKeys = Object.keys(oldObj);
+  let isSameObject = newKeys.length === oldKeys.length;
+  const mergeObj = Array.isArray(newObj) ? [] : {};
+  for (const key of newKeys) {
+    mergeObj[key] = copyWithStructuralSharing(oldObj[key], newObj[key]);
+    if (isSameObject) isSameObject = oldObj[key] === mergeObj[key];
+  }
+  return isSameObject ? oldObj : mergeObj;
+}
+
+// src/query/utils/countObjectKeys.ts
+function countObjectKeys(obj) {
+  let count = 0;
+  for (const _key in obj) {
+    count++;
+  }
+  return count;
+}
+
+// src/query/utils/flatten.ts
+var flatten = (arr) => [].concat(...arr);
+
+// src/query/utils/isAbsoluteUrl.ts
+function isAbsoluteUrl(url) {
+  return new RegExp(`(^|:)//`).test(url);
+}
+
+// src/query/utils/isDocumentVisible.ts
+function isDocumentVisible() {
+  if (typeof document === "undefined") {
+    return true;
+  }
+  return document.visibilityState !== "hidden";
+}
+
+// src/query/utils/isNotNullish.ts
+function isNotNullish(v) {
+  return v != null;
+}
+
+// src/query/utils/isOnline.ts
+function isOnline() {
+  return typeof navigator === "undefined" ? true : navigator.onLine === void 0 ? true : navigator.onLine;
+}
+
+// src/query/utils/joinUrls.ts
+var withoutTrailingSlash = (url) => url.replace(/\/$/, "");
+var withoutLeadingSlash = (url) => url.replace(/^\//, "");
+function joinUrls(base, url) {
+  if (!base) {
+    return url;
+  }
+  if (!url) {
+    return base;
+  }
+  if (isAbsoluteUrl(url)) {
+    return url;
+  }
+  const delimiter = base.endsWith("/") || !url.startsWith("?") ? "/" : "";
+  base = withoutTrailingSlash(base);
+  url = withoutLeadingSlash(url);
+  return `${base}${delimiter}${url}`;
+}
+
+// src/query/utils/getOrInsert.ts
+function getOrInsert(map, key, value) {
+  if (map.has(key)) return map.get(key);
+  return map.set(key, value).get(key);
+}
+
+// src/query/fetchBaseQuery.ts
+var defaultFetchFn = (...args) => fetch(...args);
+var defaultValidateStatus = (response) => response.status >= 200 && response.status <= 299;
+var defaultIsJsonContentType = (headers) => (
+  /*applicat*/
+  /ion\/(vnd\.api\+)?json/.test(headers.get("content-type") || "")
+);
+function stripUndefined(obj) {
+  if (!isPlainObject(obj)) {
+    return obj;
+  }
+  const copy = {
+    ...obj
+  };
+  for (const [k, v] of Object.entries(copy)) {
+    if (v === void 0) delete copy[k];
+  }
+  return copy;
+}
+function fetchBaseQuery({
+  baseUrl,
+  prepareHeaders = (x) => x,
+  fetchFn = defaultFetchFn,
+  paramsSerializer,
+  isJsonContentType = defaultIsJsonContentType,
+  jsonContentType = "application/json",
+  jsonReplacer,
+  timeout: defaultTimeout,
+  responseHandler: globalResponseHandler,
+  validateStatus: globalValidateStatus,
+  ...baseFetchOptions
+} = {}) {
+  if (typeof fetch === "undefined" && fetchFn === defaultFetchFn) {
+    console.warn("Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments.");
+  }
+  return async (arg, api, extraOptions) => {
+    const {
+      getState,
+      extra,
+      endpoint,
+      forced,
+      type
+    } = api;
+    let meta;
+    let {
+      url,
+      headers = new Headers(baseFetchOptions.headers),
+      params = void 0,
+      responseHandler = globalResponseHandler ?? "json",
+      validateStatus = globalValidateStatus ?? defaultValidateStatus,
+      timeout = defaultTimeout,
+      ...rest
+    } = typeof arg == "string" ? {
+      url: arg
+    } : arg;
+    let abortController, signal = api.signal;
+    if (timeout) {
+      abortController = new AbortController();
+      api.signal.addEventListener("abort", abortController.abort);
+      signal = abortController.signal;
+    }
+    let config = {
+      ...baseFetchOptions,
+      signal,
+      ...rest
+    };
+    headers = new Headers(stripUndefined(headers));
+    config.headers = await prepareHeaders(headers, {
+      getState,
+      arg,
+      extra,
+      endpoint,
+      forced,
+      type,
+      extraOptions
+    }) || headers;
+    const isJsonifiable = (body) => typeof body === "object" && (isPlainObject(body) || Array.isArray(body) || typeof body.toJSON === "function");
+    if (!config.headers.has("content-type") && isJsonifiable(config.body)) {
+      config.headers.set("content-type", jsonContentType);
+    }
+    if (isJsonifiable(config.body) && isJsonContentType(config.headers)) {
+      config.body = JSON.stringify(config.body, jsonReplacer);
+    }
+    if (params) {
+      const divider = ~url.indexOf("?") ? "&" : "?";
+      const query = paramsSerializer ? paramsSerializer(params) : new URLSearchParams(stripUndefined(params));
+      url += divider + query;
+    }
+    url = joinUrls(baseUrl, url);
+    const request = new Request(url, config);
+    const requestClone = new Request(url, config);
+    meta = {
+      request: requestClone
+    };
+    let response, timedOut = false, timeoutId = abortController && setTimeout(() => {
+      timedOut = true;
+      abortController.abort();
+    }, timeout);
+    try {
+      response = await fetchFn(request);
+    } catch (e) {
+      return {
+        error: {
+          status: timedOut ? "TIMEOUT_ERROR" : "FETCH_ERROR",
+          error: String(e)
+        },
+        meta
+      };
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+      abortController?.signal.removeEventListener("abort", abortController.abort);
+    }
+    const responseClone = response.clone();
+    meta.response = responseClone;
+    let resultData;
+    let responseText = "";
+    try {
+      let handleResponseError;
+      await Promise.all([
+        handleResponse(response, responseHandler).then((r) => resultData = r, (e) => handleResponseError = e),
+        // see https://github.com/node-fetch/node-fetch/issues/665#issuecomment-538995182
+        // we *have* to "use up" both streams at the same time or they will stop running in node-fetch scenarios
+        responseClone.text().then((r) => responseText = r, () => {
+        })
+      ]);
+      if (handleResponseError) throw handleResponseError;
+    } catch (e) {
+      return {
+        error: {
+          status: "PARSING_ERROR",
+          originalStatus: response.status,
+          data: responseText,
+          error: String(e)
+        },
+        meta
+      };
+    }
+    return validateStatus(response, resultData) ? {
+      data: resultData,
+      meta
+    } : {
+      error: {
+        status: response.status,
+        data: resultData
+      },
+      meta
+    };
+  };
+  async function handleResponse(response, responseHandler) {
+    if (typeof responseHandler === "function") {
+      return responseHandler(response);
+    }
+    if (responseHandler === "content-type") {
+      responseHandler = isJsonContentType(response.headers) ? "json" : "text";
+    }
+    if (responseHandler === "json") {
+      const text = await response.text();
+      return text.length ? JSON.parse(text) : null;
+    }
+    return response.text();
+  }
+}
+
+// src/query/HandledError.ts
+var HandledError = class {
+  constructor(value, meta = void 0) {
+    this.value = value;
+    this.meta = meta;
+  }
+};
+
+// src/query/retry.ts
+async function defaultBackoff(attempt = 0, maxRetries = 5) {
+  const attempts = Math.min(attempt, maxRetries);
+  const timeout = ~~((Math.random() + 0.4) * (300 << attempts));
+  await new Promise((resolve) => setTimeout((res) => resolve(res), timeout));
+}
+function fail(error, meta) {
+  throw Object.assign(new HandledError({
+    error,
+    meta
+  }), {
+    throwImmediately: true
+  });
+}
+var EMPTY_OPTIONS = {};
+var retryWithBackoff = (baseQuery, defaultOptions) => async (args, api, extraOptions) => {
+  const possibleMaxRetries = [5, (defaultOptions || EMPTY_OPTIONS).maxRetries, (extraOptions || EMPTY_OPTIONS).maxRetries].filter((x) => x !== void 0);
+  const [maxRetries] = possibleMaxRetries.slice(-1);
+  const defaultRetryCondition = (_, __, {
+    attempt
+  }) => attempt <= maxRetries;
+  const options = {
+    maxRetries,
+    backoff: defaultBackoff,
+    retryCondition: defaultRetryCondition,
+    ...defaultOptions,
+    ...extraOptions
+  };
+  let retry2 = 0;
+  while (true) {
+    try {
+      const result = await baseQuery(args, api, extraOptions);
+      if (result.error) {
+        throw new HandledError(result);
+      }
+      return result;
+    } catch (e) {
+      retry2++;
+      if (e.throwImmediately) {
+        if (e instanceof HandledError) {
+          return e.value;
+        }
+        throw e;
+      }
+      if (e instanceof HandledError && !options.retryCondition(e.value.error, args, {
+        attempt: retry2,
+        baseQueryApi: api,
+        extraOptions
+      })) {
+        return e.value;
+      }
+      await options.backoff(retry2, options.maxRetries);
+    }
+  }
+};
+var retry = /* @__PURE__ */ Object.assign(retryWithBackoff, {
+  fail
+});
+
+// src/query/core/setupListeners.ts
+var onFocus = /* @__PURE__ */ createAction("__rtkq/focused");
+var onFocusLost = /* @__PURE__ */ createAction("__rtkq/unfocused");
+var onOnline = /* @__PURE__ */ createAction("__rtkq/online");
+var onOffline = /* @__PURE__ */ createAction("__rtkq/offline");
+var initialized = false;
+function setupListeners(dispatch, customHandler) {
+  function defaultHandler() {
+    const handleFocus = () => dispatch(onFocus());
+    const handleFocusLost = () => dispatch(onFocusLost());
+    const handleOnline = () => dispatch(onOnline());
+    const handleOffline = () => dispatch(onOffline());
+    const handleVisibilityChange = () => {
+      if (window.document.visibilityState === "visible") {
+        handleFocus();
+      } else {
+        handleFocusLost();
+      }
+    };
+    if (!initialized) {
+      if (typeof window !== "undefined" && window.addEventListener) {
+        window.addEventListener("visibilitychange", handleVisibilityChange, false);
+        window.addEventListener("focus", handleFocus, false);
+        window.addEventListener("online", handleOnline, false);
+        window.addEventListener("offline", handleOffline, false);
+        initialized = true;
+      }
+    }
+    const unsubscribe = () => {
+      window.removeEventListener("focus", handleFocus);
+      window.removeEventListener("visibilitychange", handleVisibilityChange);
+      window.removeEventListener("online", handleOnline);
+      window.removeEventListener("offline", handleOffline);
+      initialized = false;
+    };
+    return unsubscribe;
+  }
+  return customHandler ? customHandler(dispatch, {
+    onFocus,
+    onFocusLost,
+    onOffline,
+    onOnline
+  }) : defaultHandler();
+}
+
+// src/query/endpointDefinitions.ts
+function isQueryDefinition(e) {
+  return e.type === "query" /* query */;
+}
+function isMutationDefinition(e) {
+  return e.type === "mutation" /* mutation */;
+}
+function isInfiniteQueryDefinition(e) {
+  return e.type === "infinitequery" /* infinitequery */;
+}
+function isAnyQueryDefinition(e) {
+  return isQueryDefinition(e) || isInfiniteQueryDefinition(e);
+}
+function calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {
+  if (isFunction(description)) {
+    return description(result, error, queryArg, meta).filter(isNotNullish).map(expandTagDescription).map(assertTagTypes);
+  }
+  if (Array.isArray(description)) {
+    return description.map(expandTagDescription).map(assertTagTypes);
+  }
+  return [];
+}
+function isFunction(t) {
+  return typeof t === "function";
+}
+function expandTagDescription(description) {
+  return typeof description === "string" ? {
+    type: description
+  } : description;
+}
+
+// src/query/core/buildThunks.ts
+import { isDraftable, produceWithPatches } from "immer";
+
+// src/query/core/buildInitiate.ts
+import { formatProdErrorMessage as _formatProdErrorMessage } from "@reduxjs/toolkit";
+
+// src/tsHelpers.ts
+function asSafePromise(promise, fallback) {
+  return promise.catch(fallback);
+}
+
+// src/query/core/buildInitiate.ts
+var forceQueryFnSymbol = Symbol("forceQueryFn");
+var isUpsertQuery = (arg) => typeof arg[forceQueryFnSymbol] === "function";
+function buildInitiate({
+  serializeQueryArgs,
+  queryThunk,
+  infiniteQueryThunk,
+  mutationThunk,
+  api,
+  context
+}) {
+  const runningQueries = /* @__PURE__ */ new Map();
+  const runningMutations = /* @__PURE__ */ new Map();
+  const {
+    unsubscribeQueryResult,
+    removeMutationResult,
+    updateSubscriptionOptions
+  } = api.internalActions;
+  return {
+    buildInitiateQuery,
+    buildInitiateInfiniteQuery,
+    buildInitiateMutation,
+    getRunningQueryThunk,
+    getRunningMutationThunk,
+    getRunningQueriesThunk,
+    getRunningMutationsThunk
+  };
+  function getRunningQueryThunk(endpointName, queryArgs) {
+    return (dispatch) => {
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const queryCacheKey = serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      });
+      return runningQueries.get(dispatch)?.[queryCacheKey];
+    };
+  }
+  function getRunningMutationThunk(_endpointName, fixedCacheKeyOrRequestId) {
+    return (dispatch) => {
+      return runningMutations.get(dispatch)?.[fixedCacheKeyOrRequestId];
+    };
+  }
+  function getRunningQueriesThunk() {
+    return (dispatch) => Object.values(runningQueries.get(dispatch) || {}).filter(isNotNullish);
+  }
+  function getRunningMutationsThunk() {
+    return (dispatch) => Object.values(runningMutations.get(dispatch) || {}).filter(isNotNullish);
+  }
+  function middlewareWarning(dispatch) {
+    if (process.env.NODE_ENV !== "production") {
+      if (middlewareWarning.triggered) return;
+      const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());
+      middlewareWarning.triggered = true;
+      if (typeof returnedValue !== "object" || typeof returnedValue?.type === "string") {
+        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.
+You must add the middleware for RTK-Query to function correctly!`);
+      }
+    }
+  }
+  function buildInitiateAnyQuery(endpointName, endpointDefinition) {
+    const queryAction = (arg, {
+      subscribe = true,
+      forceRefetch,
+      subscriptionOptions,
+      [forceQueryFnSymbol]: forceQueryFn,
+      ...rest
+    } = {}) => (dispatch, getState) => {
+      const queryCacheKey = serializeQueryArgs({
+        queryArgs: arg,
+        endpointDefinition,
+        endpointName
+      });
+      let thunk;
+      const commonThunkArgs = {
+        ...rest,
+        type: "query",
+        subscribe,
+        forceRefetch,
+        subscriptionOptions,
+        endpointName,
+        originalArgs: arg,
+        queryCacheKey,
+        [forceQueryFnSymbol]: forceQueryFn
+      };
+      if (isQueryDefinition(endpointDefinition)) {
+        thunk = queryThunk(commonThunkArgs);
+      } else {
+        const {
+          direction,
+          initialPageParam
+        } = rest;
+        thunk = infiniteQueryThunk({
+          ...commonThunkArgs,
+          // Supply these even if undefined. This helps with a field existence
+          // check over in `buildSlice.ts`
+          direction,
+          initialPageParam
+        });
+      }
+      const selector = api.endpoints[endpointName].select(arg);
+      const thunkResult = dispatch(thunk);
+      const stateAfter = selector(getState());
+      middlewareWarning(dispatch);
+      const {
+        requestId,
+        abort
+      } = thunkResult;
+      const skippedSynchronously = stateAfter.requestId !== requestId;
+      const runningQuery = runningQueries.get(dispatch)?.[queryCacheKey];
+      const selectFromState = () => selector(getState());
+      const statePromise = Object.assign(forceQueryFn ? (
+        // a query has been forced (upsertQueryData)
+        // -> we want to resolve it once data has been written with the data that will be written
+        thunkResult.then(selectFromState)
+      ) : skippedSynchronously && !runningQuery ? (
+        // a query has been skipped due to a condition and we do not have any currently running query
+        // -> we want to resolve it immediately with the current data
+        Promise.resolve(stateAfter)
+      ) : (
+        // query just started or one is already in flight
+        // -> wait for the running query, then resolve with data from after that
+        Promise.all([runningQuery, thunkResult]).then(selectFromState)
+      ), {
+        arg,
+        requestId,
+        subscriptionOptions,
+        queryCacheKey,
+        abort,
+        async unwrap() {
+          const result = await statePromise;
+          if (result.isError) {
+            throw result.error;
+          }
+          return result.data;
+        },
+        refetch: () => dispatch(queryAction(arg, {
+          subscribe: false,
+          forceRefetch: true
+        })),
+        unsubscribe() {
+          if (subscribe) dispatch(unsubscribeQueryResult({
+            queryCacheKey,
+            requestId
+          }));
+        },
+        updateSubscriptionOptions(options) {
+          statePromise.subscriptionOptions = options;
+          dispatch(updateSubscriptionOptions({
+            endpointName,
+            requestId,
+            queryCacheKey,
+            options
+          }));
+        }
+      });
+      if (!runningQuery && !skippedSynchronously && !forceQueryFn) {
+        const running = getOrInsert(runningQueries, dispatch, {});
+        running[queryCacheKey] = statePromise;
+        statePromise.then(() => {
+          delete running[queryCacheKey];
+          if (!countObjectKeys(running)) {
+            runningQueries.delete(dispatch);
+          }
+        });
+      }
+      return statePromise;
+    };
+    return queryAction;
+  }
+  function buildInitiateQuery(endpointName, endpointDefinition) {
+    const queryAction = buildInitiateAnyQuery(endpointName, endpointDefinition);
+    return queryAction;
+  }
+  function buildInitiateInfiniteQuery(endpointName, endpointDefinition) {
+    const infiniteQueryAction = buildInitiateAnyQuery(endpointName, endpointDefinition);
+    return infiniteQueryAction;
+  }
+  function buildInitiateMutation(endpointName) {
+    return (arg, {
+      track = true,
+      fixedCacheKey
+    } = {}) => (dispatch, getState) => {
+      const thunk = mutationThunk({
+        type: "mutation",
+        endpointName,
+        originalArgs: arg,
+        track,
+        fixedCacheKey
+      });
+      const thunkResult = dispatch(thunk);
+      middlewareWarning(dispatch);
+      const {
+        requestId,
+        abort,
+        unwrap
+      } = thunkResult;
+      const returnValuePromise = asSafePromise(thunkResult.unwrap().then((data) => ({
+        data
+      })), (error) => ({
+        error
+      }));
+      const reset = () => {
+        dispatch(removeMutationResult({
+          requestId,
+          fixedCacheKey
+        }));
+      };
+      const ret = Object.assign(returnValuePromise, {
+        arg: thunkResult.arg,
+        requestId,
+        abort,
+        unwrap,
+        reset
+      });
+      const running = runningMutations.get(dispatch) || {};
+      runningMutations.set(dispatch, running);
+      running[requestId] = ret;
+      ret.then(() => {
+        delete running[requestId];
+        if (!countObjectKeys(running)) {
+          runningMutations.delete(dispatch);
+        }
+      });
+      if (fixedCacheKey) {
+        running[fixedCacheKey] = ret;
+        ret.then(() => {
+          if (running[fixedCacheKey] === ret) {
+            delete running[fixedCacheKey];
+            if (!countObjectKeys(running)) {
+              runningMutations.delete(dispatch);
+            }
+          }
+        });
+      }
+      return ret;
+    };
+  }
+}
+
+// src/query/standardSchema.ts
+import { SchemaError } from "@standard-schema/utils";
+var NamedSchemaError = class extends SchemaError {
+  constructor(issues, value, schemaName, _bqMeta) {
+    super(issues);
+    this.value = value;
+    this.schemaName = schemaName;
+    this._bqMeta = _bqMeta;
+  }
+};
+async function parseWithSchema(schema, data, schemaName, bqMeta) {
+  const result = await schema["~standard"].validate(data);
+  if (result.issues) {
+    throw new NamedSchemaError(result.issues, data, schemaName, bqMeta);
+  }
+  return result.value;
+}
+
+// src/query/core/buildThunks.ts
+function defaultTransformResponse(baseQueryReturnValue) {
+  return baseQueryReturnValue;
+}
+var addShouldAutoBatch = (arg = {}) => {
+  return {
+    ...arg,
+    [SHOULD_AUTOBATCH]: true
+  };
+};
+function buildThunks({
+  reducerPath,
+  baseQuery,
+  context: {
+    endpointDefinitions
+  },
+  serializeQueryArgs,
+  api,
+  assertTagType,
+  selectors,
+  onSchemaFailure,
+  catchSchemaFailure: globalCatchSchemaFailure,
+  skipSchemaValidation: globalSkipSchemaValidation
+}) {
+  const patchQueryData = (endpointName, arg, patches, updateProvided) => (dispatch, getState) => {
+    const endpointDefinition = endpointDefinitions[endpointName];
+    const queryCacheKey = serializeQueryArgs({
+      queryArgs: arg,
+      endpointDefinition,
+      endpointName
+    });
+    dispatch(api.internalActions.queryResultPatched({
+      queryCacheKey,
+      patches
+    }));
+    if (!updateProvided) {
+      return;
+    }
+    const newValue = api.endpoints[endpointName].select(arg)(
+      // Work around TS 4.1 mismatch
+      getState()
+    );
+    const providedTags = calculateProvidedBy(endpointDefinition.providesTags, newValue.data, void 0, arg, {}, assertTagType);
+    dispatch(api.internalActions.updateProvidedBy([{
+      queryCacheKey,
+      providedTags
+    }]));
+  };
+  function addToStart(items, item, max = 0) {
+    const newItems = [item, ...items];
+    return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
+  }
+  function addToEnd(items, item, max = 0) {
+    const newItems = [...items, item];
+    return max && newItems.length > max ? newItems.slice(1) : newItems;
+  }
+  const updateQueryData = (endpointName, arg, updateRecipe, updateProvided = true) => (dispatch, getState) => {
+    const endpointDefinition = api.endpoints[endpointName];
+    const currentState = endpointDefinition.select(arg)(
+      // Work around TS 4.1 mismatch
+      getState()
+    );
+    const ret = {
+      patches: [],
+      inversePatches: [],
+      undo: () => dispatch(api.util.patchQueryData(endpointName, arg, ret.inversePatches, updateProvided))
+    };
+    if (currentState.status === "uninitialized" /* uninitialized */) {
+      return ret;
+    }
+    let newValue;
+    if ("data" in currentState) {
+      if (isDraftable(currentState.data)) {
+        const [value, patches, inversePatches] = produceWithPatches(currentState.data, updateRecipe);
+        ret.patches.push(...patches);
+        ret.inversePatches.push(...inversePatches);
+        newValue = value;
+      } else {
+        newValue = updateRecipe(currentState.data);
+        ret.patches.push({
+          op: "replace",
+          path: [],
+          value: newValue
+        });
+        ret.inversePatches.push({
+          op: "replace",
+          path: [],
+          value: currentState.data
+        });
+      }
+    }
+    if (ret.patches.length === 0) {
+      return ret;
+    }
+    dispatch(api.util.patchQueryData(endpointName, arg, ret.patches, updateProvided));
+    return ret;
+  };
+  const upsertQueryData = (endpointName, arg, value) => (dispatch) => {
+    const res = dispatch(api.endpoints[endpointName].initiate(arg, {
+      subscribe: false,
+      forceRefetch: true,
+      [forceQueryFnSymbol]: () => ({
+        data: value
+      })
+    }));
+    return res;
+  };
+  const getTransformCallbackForEndpoint = (endpointDefinition, transformFieldName) => {
+    return endpointDefinition.query && endpointDefinition[transformFieldName] ? endpointDefinition[transformFieldName] : defaultTransformResponse;
+  };
+  const executeEndpoint = async (arg, {
+    signal,
+    abort,
+    rejectWithValue,
+    fulfillWithValue,
+    dispatch,
+    getState,
+    extra
+  }) => {
+    const endpointDefinition = endpointDefinitions[arg.endpointName];
+    const {
+      metaSchema,
+      skipSchemaValidation = globalSkipSchemaValidation
+    } = endpointDefinition;
+    try {
+      let transformResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformResponse");
+      const baseQueryApi = {
+        signal,
+        abort,
+        dispatch,
+        getState,
+        extra,
+        endpoint: arg.endpointName,
+        type: arg.type,
+        forced: arg.type === "query" ? isForcedQuery(arg, getState()) : void 0,
+        queryCacheKey: arg.type === "query" ? arg.queryCacheKey : void 0
+      };
+      const forceQueryFn = arg.type === "query" ? arg[forceQueryFnSymbol] : void 0;
+      let finalQueryReturnValue;
+      const fetchPage = async (data, param, maxPages, previous) => {
+        if (param == null && data.pages.length) {
+          return Promise.resolve({
+            data
+          });
+        }
+        const finalQueryArg = {
+          queryArg: arg.originalArgs,
+          pageParam: param
+        };
+        const pageResponse = await executeRequest(finalQueryArg);
+        const addTo = previous ? addToStart : addToEnd;
+        return {
+          data: {
+            pages: addTo(data.pages, pageResponse.data, maxPages),
+            pageParams: addTo(data.pageParams, param, maxPages)
+          },
+          meta: pageResponse.meta
+        };
+      };
+      async function executeRequest(finalQueryArg) {
+        let result;
+        const {
+          extraOptions,
+          argSchema,
+          rawResponseSchema,
+          responseSchema
+        } = endpointDefinition;
+        if (argSchema && !skipSchemaValidation) {
+          finalQueryArg = await parseWithSchema(
+            argSchema,
+            finalQueryArg,
+            "argSchema",
+            {}
+            // we don't have a meta yet, so we can't pass it
+          );
+        }
+        if (forceQueryFn) {
+          result = forceQueryFn();
+        } else if (endpointDefinition.query) {
+          result = await baseQuery(endpointDefinition.query(finalQueryArg), baseQueryApi, extraOptions);
+        } else {
+          result = await endpointDefinition.queryFn(finalQueryArg, baseQueryApi, extraOptions, (arg2) => baseQuery(arg2, baseQueryApi, extraOptions));
+        }
+        if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+          const what = endpointDefinition.query ? "`baseQuery`" : "`queryFn`";
+          let err;
+          if (!result) {
+            err = `${what} did not return anything.`;
+          } else if (typeof result !== "object") {
+            err = `${what} did not return an object.`;
+          } else if (result.error && result.data) {
+            err = `${what} returned an object containing both \`error\` and \`result\`.`;
+          } else if (result.error === void 0 && result.data === void 0) {
+            err = `${what} returned an object containing neither a valid \`error\` and \`result\`. At least one of them should not be \`undefined\``;
+          } else {
+            for (const key of Object.keys(result)) {
+              if (key !== "error" && key !== "data" && key !== "meta") {
+                err = `The object returned by ${what} has the unknown property ${key}.`;
+                break;
+              }
+            }
+          }
+          if (err) {
+            console.error(`Error encountered handling the endpoint ${arg.endpointName}.
+                  ${err}
+                  It needs to return an object with either the shape \`{ data: <value> }\` or \`{ error: <value> }\` that may contain an optional \`meta\` property.
+                  Object returned was:`, result);
+          }
+        }
+        if (result.error) throw new HandledError(result.error, result.meta);
+        let {
+          data
+        } = result;
+        if (rawResponseSchema && !skipSchemaValidation) {
+          data = await parseWithSchema(rawResponseSchema, result.data, "rawResponseSchema", result.meta);
+        }
+        let transformedResponse = await transformResponse(data, result.meta, finalQueryArg);
+        if (responseSchema && !skipSchemaValidation) {
+          transformedResponse = await parseWithSchema(responseSchema, transformedResponse, "responseSchema", result.meta);
+        }
+        return {
+          ...result,
+          data: transformedResponse
+        };
+      }
+      if (arg.type === "query" && "infiniteQueryOptions" in endpointDefinition) {
+        const {
+          infiniteQueryOptions
+        } = endpointDefinition;
+        const {
+          maxPages = Infinity
+        } = infiniteQueryOptions;
+        let result;
+        const blankData = {
+          pages: [],
+          pageParams: []
+        };
+        const cachedData = selectors.selectQueryEntry(getState(), arg.queryCacheKey)?.data;
+        const isForcedQueryNeedingRefetch = (
+          // arg.forceRefetch
+          isForcedQuery(arg, getState()) && !arg.direction
+        );
+        const existingData = isForcedQueryNeedingRefetch || !cachedData ? blankData : cachedData;
+        if ("direction" in arg && arg.direction && existingData.pages.length) {
+          const previous = arg.direction === "backward";
+          const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+          const param = pageParamFn(infiniteQueryOptions, existingData, arg.originalArgs);
+          result = await fetchPage(existingData, param, maxPages, previous);
+        } else {
+          const {
+            initialPageParam = infiniteQueryOptions.initialPageParam
+          } = arg;
+          const cachedPageParams = cachedData?.pageParams ?? [];
+          const firstPageParam = cachedPageParams[0] ?? initialPageParam;
+          const totalPages = cachedPageParams.length;
+          result = await fetchPage(existingData, firstPageParam, maxPages);
+          if (forceQueryFn) {
+            result = {
+              data: result.data.pages[0]
+            };
+          }
+          for (let i = 1; i < totalPages; i++) {
+            const param = getNextPageParam(infiniteQueryOptions, result.data, arg.originalArgs);
+            result = await fetchPage(result.data, param, maxPages);
+          }
+        }
+        finalQueryReturnValue = result;
+      } else {
+        finalQueryReturnValue = await executeRequest(arg.originalArgs);
+      }
+      if (metaSchema && !skipSchemaValidation && finalQueryReturnValue.meta) {
+        finalQueryReturnValue.meta = await parseWithSchema(metaSchema, finalQueryReturnValue.meta, "metaSchema", finalQueryReturnValue.meta);
+      }
+      return fulfillWithValue(finalQueryReturnValue.data, addShouldAutoBatch({
+        fulfilledTimeStamp: Date.now(),
+        baseQueryMeta: finalQueryReturnValue.meta
+      }));
+    } catch (error) {
+      let caughtError = error;
+      if (caughtError instanceof HandledError) {
+        let transformErrorResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformErrorResponse");
+        const {
+          rawErrorResponseSchema,
+          errorResponseSchema
+        } = endpointDefinition;
+        let {
+          value,
+          meta
+        } = caughtError;
+        try {
+          if (rawErrorResponseSchema && !skipSchemaValidation) {
+            value = await parseWithSchema(rawErrorResponseSchema, value, "rawErrorResponseSchema", meta);
+          }
+          if (metaSchema && !skipSchemaValidation) {
+            meta = await parseWithSchema(metaSchema, meta, "metaSchema", meta);
+          }
+          let transformedErrorResponse = await transformErrorResponse(value, meta, arg.originalArgs);
+          if (errorResponseSchema && !skipSchemaValidation) {
+            transformedErrorResponse = await parseWithSchema(errorResponseSchema, transformedErrorResponse, "errorResponseSchema", meta);
+          }
+          return rejectWithValue(transformedErrorResponse, addShouldAutoBatch({
+            baseQueryMeta: meta
+          }));
+        } catch (e) {
+          caughtError = e;
+        }
+      }
+      try {
+        if (caughtError instanceof NamedSchemaError) {
+          const info = {
+            endpoint: arg.endpointName,
+            arg: arg.originalArgs,
+            type: arg.type,
+            queryCacheKey: arg.type === "query" ? arg.queryCacheKey : void 0
+          };
+          endpointDefinition.onSchemaFailure?.(caughtError, info);
+          onSchemaFailure?.(caughtError, info);
+          const {
+            catchSchemaFailure = globalCatchSchemaFailure
+          } = endpointDefinition;
+          if (catchSchemaFailure) {
+            return rejectWithValue(catchSchemaFailure(caughtError, info), addShouldAutoBatch({
+              baseQueryMeta: caughtError._bqMeta
+            }));
+          }
+        }
+      } catch (e) {
+        caughtError = e;
+      }
+      if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+        console.error(`An unhandled error occurred processing a request for the endpoint "${arg.endpointName}".
+In the case of an unhandled error, no tags will be "provided" or "invalidated".`, caughtError);
+      } else {
+        console.error(caughtError);
+      }
+      throw caughtError;
+    }
+  };
+  function isForcedQuery(arg, state) {
+    const requestState = selectors.selectQueryEntry(state, arg.queryCacheKey);
+    const baseFetchOnMountOrArgChange = selectors.selectConfig(state).refetchOnMountOrArgChange;
+    const fulfilledVal = requestState?.fulfilledTimeStamp;
+    const refetchVal = arg.forceRefetch ?? (arg.subscribe && baseFetchOnMountOrArgChange);
+    if (refetchVal) {
+      return refetchVal === true || (Number(/* @__PURE__ */ new Date()) - Number(fulfilledVal)) / 1e3 >= refetchVal;
+    }
+    return false;
+  }
+  const createQueryThunk = () => {
+    const generatedQueryThunk = createAsyncThunk(`${reducerPath}/executeQuery`, executeEndpoint, {
+      getPendingMeta({
+        arg
+      }) {
+        const endpointDefinition = endpointDefinitions[arg.endpointName];
+        return addShouldAutoBatch({
+          startedTimeStamp: Date.now(),
+          ...isInfiniteQueryDefinition(endpointDefinition) ? {
+            direction: arg.direction
+          } : {}
+        });
+      },
+      condition(queryThunkArg, {
+        getState
+      }) {
+        const state = getState();
+        const requestState = selectors.selectQueryEntry(state, queryThunkArg.queryCacheKey);
+        const fulfilledVal = requestState?.fulfilledTimeStamp;
+        const currentArg = queryThunkArg.originalArgs;
+        const previousArg = requestState?.originalArgs;
+        const endpointDefinition = endpointDefinitions[queryThunkArg.endpointName];
+        const direction = queryThunkArg.direction;
+        if (isUpsertQuery(queryThunkArg)) {
+          return true;
+        }
+        if (requestState?.status === "pending") {
+          return false;
+        }
+        if (isForcedQuery(queryThunkArg, state)) {
+          return true;
+        }
+        if (isQueryDefinition(endpointDefinition) && endpointDefinition?.forceRefetch?.({
+          currentArg,
+          previousArg,
+          endpointState: requestState,
+          state
+        })) {
+          return true;
+        }
+        if (fulfilledVal && !direction) {
+          return false;
+        }
+        return true;
+      },
+      dispatchConditionRejection: true
+    });
+    return generatedQueryThunk;
+  };
+  const queryThunk = createQueryThunk();
+  const infiniteQueryThunk = createQueryThunk();
+  const mutationThunk = createAsyncThunk(`${reducerPath}/executeMutation`, executeEndpoint, {
+    getPendingMeta() {
+      return addShouldAutoBatch({
+        startedTimeStamp: Date.now()
+      });
+    }
+  });
+  const hasTheForce = (options) => "force" in options;
+  const hasMaxAge = (options) => "ifOlderThan" in options;
+  const prefetch = (endpointName, arg, options) => (dispatch, getState) => {
+    const force = hasTheForce(options) && options.force;
+    const maxAge = hasMaxAge(options) && options.ifOlderThan;
+    const queryAction = (force2 = true) => {
+      const options2 = {
+        forceRefetch: force2,
+        isPrefetch: true
+      };
+      return api.endpoints[endpointName].initiate(arg, options2);
+    };
+    const latestStateValue = api.endpoints[endpointName].select(arg)(getState());
+    if (force) {
+      dispatch(queryAction());
+    } else if (maxAge) {
+      const lastFulfilledTs = latestStateValue?.fulfilledTimeStamp;
+      if (!lastFulfilledTs) {
+        dispatch(queryAction());
+        return;
+      }
+      const shouldRetrigger = (Number(/* @__PURE__ */ new Date()) - Number(new Date(lastFulfilledTs))) / 1e3 >= maxAge;
+      if (shouldRetrigger) {
+        dispatch(queryAction());
+      }
+    } else {
+      dispatch(queryAction(false));
+    }
+  };
+  function matchesEndpoint(endpointName) {
+    return (action) => action?.meta?.arg?.endpointName === endpointName;
+  }
+  function buildMatchThunkActions(thunk, endpointName) {
+    return {
+      matchPending: isAllOf(isPending(thunk), matchesEndpoint(endpointName)),
+      matchFulfilled: isAllOf(isFulfilled(thunk), matchesEndpoint(endpointName)),
+      matchRejected: isAllOf(isRejected(thunk), matchesEndpoint(endpointName))
+    };
+  }
+  return {
+    queryThunk,
+    mutationThunk,
+    infiniteQueryThunk,
+    prefetch,
+    updateQueryData,
+    upsertQueryData,
+    patchQueryData,
+    buildMatchThunkActions
+  };
+}
+function getNextPageParam(options, {
+  pages,
+  pageParams
+}, queryArg) {
+  const lastIndex = pages.length - 1;
+  return options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams, queryArg);
+}
+function getPreviousPageParam(options, {
+  pages,
+  pageParams
+}, queryArg) {
+  return options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams, queryArg);
+}
+function calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {
+  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);
+}
+
+// src/query/core/buildSlice.ts
+import { isDraft } from "immer";
+import { applyPatches, original } from "immer";
+function updateQuerySubstateIfExists(state, queryCacheKey, update) {
+  const substate = state[queryCacheKey];
+  if (substate) {
+    update(substate);
+  }
+}
+function getMutationCacheKey(id) {
+  return ("arg" in id ? id.arg.fixedCacheKey : id.fixedCacheKey) ?? id.requestId;
+}
+function updateMutationSubstateIfExists(state, id, update) {
+  const substate = state[getMutationCacheKey(id)];
+  if (substate) {
+    update(substate);
+  }
+}
+var initialState = {};
+function buildSlice({
+  reducerPath,
+  queryThunk,
+  mutationThunk,
+  serializeQueryArgs,
+  context: {
+    endpointDefinitions: definitions,
+    apiUid,
+    extractRehydrationInfo,
+    hasRehydrationInfo
+  },
+  assertTagType,
+  config
+}) {
+  const resetApiState = createAction(`${reducerPath}/resetApiState`);
+  function writePendingCacheEntry(draft, arg, upserting, meta) {
+    draft[arg.queryCacheKey] ??= {
+      status: "uninitialized" /* uninitialized */,
+      endpointName: arg.endpointName
+    };
+    updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {
+      substate.status = "pending" /* pending */;
+      substate.requestId = upserting && substate.requestId ? (
+        // for `upsertQuery` **updates**, keep the current `requestId`
+        substate.requestId
+      ) : (
+        // for normal queries or `upsertQuery` **inserts** always update the `requestId`
+        meta.requestId
+      );
+      if (arg.originalArgs !== void 0) {
+        substate.originalArgs = arg.originalArgs;
+      }
+      substate.startedTimeStamp = meta.startedTimeStamp;
+      const endpointDefinition = definitions[meta.arg.endpointName];
+      if (isInfiniteQueryDefinition(endpointDefinition) && "direction" in arg) {
+        ;
+        substate.direction = arg.direction;
+      }
+    });
+  }
+  function writeFulfilledCacheEntry(draft, meta, payload, upserting) {
+    updateQuerySubstateIfExists(draft, meta.arg.queryCacheKey, (substate) => {
+      if (substate.requestId !== meta.requestId && !upserting) return;
+      const {
+        merge
+      } = definitions[meta.arg.endpointName];
+      substate.status = "fulfilled" /* fulfilled */;
+      if (merge) {
+        if (substate.data !== void 0) {
+          const {
+            fulfilledTimeStamp,
+            arg,
+            baseQueryMeta,
+            requestId
+          } = meta;
+          let newData = createNextState(substate.data, (draftSubstateData) => {
+            return merge(draftSubstateData, payload, {
+              arg: arg.originalArgs,
+              baseQueryMeta,
+              fulfilledTimeStamp,
+              requestId
+            });
+          });
+          substate.data = newData;
+        } else {
+          substate.data = payload;
+        }
+      } else {
+        substate.data = definitions[meta.arg.endpointName].structuralSharing ?? true ? copyWithStructuralSharing(isDraft(substate.data) ? original(substate.data) : substate.data, payload) : payload;
+      }
+      delete substate.error;
+      substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;
+    });
+  }
+  const querySlice = createSlice({
+    name: `${reducerPath}/queries`,
+    initialState,
+    reducers: {
+      removeQueryResult: {
+        reducer(draft, {
+          payload: {
+            queryCacheKey
+          }
+        }) {
+          delete draft[queryCacheKey];
+        },
+        prepare: prepareAutoBatched()
+      },
+      cacheEntriesUpserted: {
+        reducer(draft, action) {
+          for (const entry of action.payload) {
+            const {
+              queryDescription: arg,
+              value
+            } = entry;
+            writePendingCacheEntry(draft, arg, true, {
+              arg,
+              requestId: action.meta.requestId,
+              startedTimeStamp: action.meta.timestamp
+            });
+            writeFulfilledCacheEntry(
+              draft,
+              {
+                arg,
+                requestId: action.meta.requestId,
+                fulfilledTimeStamp: action.meta.timestamp,
+                baseQueryMeta: {}
+              },
+              value,
+              // We know we're upserting here
+              true
+            );
+          }
+        },
+        prepare: (payload) => {
+          const queryDescriptions = payload.map((entry) => {
+            const {
+              endpointName,
+              arg,
+              value
+            } = entry;
+            const endpointDefinition = definitions[endpointName];
+            const queryDescription = {
+              type: "query",
+              endpointName,
+              originalArgs: entry.arg,
+              queryCacheKey: serializeQueryArgs({
+                queryArgs: arg,
+                endpointDefinition,
+                endpointName
+              })
+            };
+            return {
+              queryDescription,
+              value
+            };
+          });
+          const result = {
+            payload: queryDescriptions,
+            meta: {
+              [SHOULD_AUTOBATCH]: true,
+              requestId: nanoid(),
+              timestamp: Date.now()
+            }
+          };
+          return result;
+        }
+      },
+      queryResultPatched: {
+        reducer(draft, {
+          payload: {
+            queryCacheKey,
+            patches
+          }
+        }) {
+          updateQuerySubstateIfExists(draft, queryCacheKey, (substate) => {
+            substate.data = applyPatches(substate.data, patches.concat());
+          });
+        },
+        prepare: prepareAutoBatched()
+      }
+    },
+    extraReducers(builder) {
+      builder.addCase(queryThunk.pending, (draft, {
+        meta,
+        meta: {
+          arg
+        }
+      }) => {
+        const upserting = isUpsertQuery(arg);
+        writePendingCacheEntry(draft, arg, upserting, meta);
+      }).addCase(queryThunk.fulfilled, (draft, {
+        meta,
+        payload
+      }) => {
+        const upserting = isUpsertQuery(meta.arg);
+        writeFulfilledCacheEntry(draft, meta, payload, upserting);
+      }).addCase(queryThunk.rejected, (draft, {
+        meta: {
+          condition,
+          arg,
+          requestId
+        },
+        error,
+        payload
+      }) => {
+        updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {
+          if (condition) {
+          } else {
+            if (substate.requestId !== requestId) return;
+            substate.status = "rejected" /* rejected */;
+            substate.error = payload ?? error;
+          }
+        });
+      }).addMatcher(hasRehydrationInfo, (draft, action) => {
+        const {
+          queries
+        } = extractRehydrationInfo(action);
+        for (const [key, entry] of Object.entries(queries)) {
+          if (
+            // do not rehydrate entries that were currently in flight.
+            entry?.status === "fulfilled" /* fulfilled */ || entry?.status === "rejected" /* rejected */
+          ) {
+            draft[key] = entry;
+          }
+        }
+      });
+    }
+  });
+  const mutationSlice = createSlice({
+    name: `${reducerPath}/mutations`,
+    initialState,
+    reducers: {
+      removeMutationResult: {
+        reducer(draft, {
+          payload
+        }) {
+          const cacheKey = getMutationCacheKey(payload);
+          if (cacheKey in draft) {
+            delete draft[cacheKey];
+          }
+        },
+        prepare: prepareAutoBatched()
+      }
+    },
+    extraReducers(builder) {
+      builder.addCase(mutationThunk.pending, (draft, {
+        meta,
+        meta: {
+          requestId,
+          arg,
+          startedTimeStamp
+        }
+      }) => {
+        if (!arg.track) return;
+        draft[getMutationCacheKey(meta)] = {
+          requestId,
+          status: "pending" /* pending */,
+          endpointName: arg.endpointName,
+          startedTimeStamp
+        };
+      }).addCase(mutationThunk.fulfilled, (draft, {
+        payload,
+        meta
+      }) => {
+        if (!meta.arg.track) return;
+        updateMutationSubstateIfExists(draft, meta, (substate) => {
+          if (substate.requestId !== meta.requestId) return;
+          substate.status = "fulfilled" /* fulfilled */;
+          substate.data = payload;
+          substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;
+        });
+      }).addCase(mutationThunk.rejected, (draft, {
+        payload,
+        error,
+        meta
+      }) => {
+        if (!meta.arg.track) return;
+        updateMutationSubstateIfExists(draft, meta, (substate) => {
+          if (substate.requestId !== meta.requestId) return;
+          substate.status = "rejected" /* rejected */;
+          substate.error = payload ?? error;
+        });
+      }).addMatcher(hasRehydrationInfo, (draft, action) => {
+        const {
+          mutations
+        } = extractRehydrationInfo(action);
+        for (const [key, entry] of Object.entries(mutations)) {
+          if (
+            // do not rehydrate entries that were currently in flight.
+            (entry?.status === "fulfilled" /* fulfilled */ || entry?.status === "rejected" /* rejected */) && // only rehydrate endpoints that were persisted using a `fixedCacheKey`
+            key !== entry?.requestId
+          ) {
+            draft[key] = entry;
+          }
+        }
+      });
+    }
+  });
+  const initialInvalidationState = {
+    tags: {},
+    keys: {}
+  };
+  const invalidationSlice = createSlice({
+    name: `${reducerPath}/invalidation`,
+    initialState: initialInvalidationState,
+    reducers: {
+      updateProvidedBy: {
+        reducer(draft, action) {
+          for (const {
+            queryCacheKey,
+            providedTags
+          } of action.payload) {
+            removeCacheKeyFromTags(draft, queryCacheKey);
+            for (const {
+              type,
+              id
+            } of providedTags) {
+              const subscribedQueries = (draft.tags[type] ??= {})[id || "__internal_without_id"] ??= [];
+              const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
+              if (!alreadySubscribed) {
+                subscribedQueries.push(queryCacheKey);
+              }
+            }
+            draft.keys[queryCacheKey] = providedTags;
+          }
+        },
+        prepare: prepareAutoBatched()
+      }
+    },
+    extraReducers(builder) {
+      builder.addCase(querySlice.actions.removeQueryResult, (draft, {
+        payload: {
+          queryCacheKey
+        }
+      }) => {
+        removeCacheKeyFromTags(draft, queryCacheKey);
+      }).addMatcher(hasRehydrationInfo, (draft, action) => {
+        const {
+          provided
+        } = extractRehydrationInfo(action);
+        for (const [type, incomingTags] of Object.entries(provided)) {
+          for (const [id, cacheKeys] of Object.entries(incomingTags)) {
+            const subscribedQueries = (draft.tags[type] ??= {})[id || "__internal_without_id"] ??= [];
+            for (const queryCacheKey of cacheKeys) {
+              const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
+              if (!alreadySubscribed) {
+                subscribedQueries.push(queryCacheKey);
+              }
+            }
+          }
+        }
+      }).addMatcher(isAnyOf(isFulfilled(queryThunk), isRejectedWithValue(queryThunk)), (draft, action) => {
+        writeProvidedTagsForQueries(draft, [action]);
+      }).addMatcher(querySlice.actions.cacheEntriesUpserted.match, (draft, action) => {
+        const mockActions = action.payload.map(({
+          queryDescription,
+          value
+        }) => {
+          return {
+            type: "UNKNOWN",
+            payload: value,
+            meta: {
+              requestStatus: "fulfilled",
+              requestId: "UNKNOWN",
+              arg: queryDescription
+            }
+          };
+        });
+        writeProvidedTagsForQueries(draft, mockActions);
+      });
+    }
+  });
+  function removeCacheKeyFromTags(draft, queryCacheKey) {
+    const existingTags = draft.keys[queryCacheKey] ?? [];
+    for (const tag of existingTags) {
+      const tagType = tag.type;
+      const tagId = tag.id ?? "__internal_without_id";
+      const tagSubscriptions = draft.tags[tagType]?.[tagId];
+      if (tagSubscriptions) {
+        draft.tags[tagType][tagId] = tagSubscriptions.filter((qc) => qc !== queryCacheKey);
+      }
+    }
+    delete draft.keys[queryCacheKey];
+  }
+  function writeProvidedTagsForQueries(draft, actions2) {
+    const providedByEntries = actions2.map((action) => {
+      const providedTags = calculateProvidedByThunk(action, "providesTags", definitions, assertTagType);
+      const {
+        queryCacheKey
+      } = action.meta.arg;
+      return {
+        queryCacheKey,
+        providedTags
+      };
+    });
+    invalidationSlice.caseReducers.updateProvidedBy(draft, invalidationSlice.actions.updateProvidedBy(providedByEntries));
+  }
+  const subscriptionSlice = createSlice({
+    name: `${reducerPath}/subscriptions`,
+    initialState,
+    reducers: {
+      updateSubscriptionOptions(d, a) {
+      },
+      unsubscribeQueryResult(d, a) {
+      },
+      internal_getRTKQSubscriptions() {
+      }
+    }
+  });
+  const internalSubscriptionsSlice = createSlice({
+    name: `${reducerPath}/internalSubscriptions`,
+    initialState,
+    reducers: {
+      subscriptionsUpdated: {
+        reducer(state, action) {
+          return applyPatches(state, action.payload);
+        },
+        prepare: prepareAutoBatched()
+      }
+    }
+  });
+  const configSlice = createSlice({
+    name: `${reducerPath}/config`,
+    initialState: {
+      online: isOnline(),
+      focused: isDocumentVisible(),
+      middlewareRegistered: false,
+      ...config
+    },
+    reducers: {
+      middlewareRegistered(state, {
+        payload
+      }) {
+        state.middlewareRegistered = state.middlewareRegistered === "conflict" || apiUid !== payload ? "conflict" : true;
+      }
+    },
+    extraReducers: (builder) => {
+      builder.addCase(onOnline, (state) => {
+        state.online = true;
+      }).addCase(onOffline, (state) => {
+        state.online = false;
+      }).addCase(onFocus, (state) => {
+        state.focused = true;
+      }).addCase(onFocusLost, (state) => {
+        state.focused = false;
+      }).addMatcher(hasRehydrationInfo, (draft) => ({
+        ...draft
+      }));
+    }
+  });
+  const combinedReducer = combineReducers({
+    queries: querySlice.reducer,
+    mutations: mutationSlice.reducer,
+    provided: invalidationSlice.reducer,
+    subscriptions: internalSubscriptionsSlice.reducer,
+    config: configSlice.reducer
+  });
+  const reducer = (state, action) => combinedReducer(resetApiState.match(action) ? void 0 : state, action);
+  const actions = {
+    ...configSlice.actions,
+    ...querySlice.actions,
+    ...subscriptionSlice.actions,
+    ...internalSubscriptionsSlice.actions,
+    ...mutationSlice.actions,
+    ...invalidationSlice.actions,
+    resetApiState
+  };
+  return {
+    reducer,
+    actions
+  };
+}
+
+// src/query/core/buildSelectors.ts
+var skipToken = /* @__PURE__ */ Symbol.for("RTKQ/skipToken");
+var initialSubState = {
+  status: "uninitialized" /* uninitialized */
+};
+var defaultQuerySubState = /* @__PURE__ */ createNextState(initialSubState, () => {
+});
+var defaultMutationSubState = /* @__PURE__ */ createNextState(initialSubState, () => {
+});
+function buildSelectors({
+  serializeQueryArgs,
+  reducerPath,
+  createSelector: createSelector2
+}) {
+  const selectSkippedQuery = (state) => defaultQuerySubState;
+  const selectSkippedMutation = (state) => defaultMutationSubState;
+  return {
+    buildQuerySelector,
+    buildInfiniteQuerySelector,
+    buildMutationSelector,
+    selectInvalidatedBy,
+    selectCachedArgsForQuery,
+    selectApiState,
+    selectQueries,
+    selectMutations,
+    selectQueryEntry,
+    selectConfig
+  };
+  function withRequestFlags(substate) {
+    return {
+      ...substate,
+      ...getRequestStatusFlags(substate.status)
+    };
+  }
+  function selectApiState(rootState) {
+    const state = rootState[reducerPath];
+    if (process.env.NODE_ENV !== "production") {
+      if (!state) {
+        if (selectApiState.triggered) return state;
+        selectApiState.triggered = true;
+        console.error(`Error: No data found at \`state.${reducerPath}\`. Did you forget to add the reducer to the store?`);
+      }
+    }
+    return state;
+  }
+  function selectQueries(rootState) {
+    return selectApiState(rootState)?.queries;
+  }
+  function selectQueryEntry(rootState, cacheKey) {
+    return selectQueries(rootState)?.[cacheKey];
+  }
+  function selectMutations(rootState) {
+    return selectApiState(rootState)?.mutations;
+  }
+  function selectConfig(rootState) {
+    return selectApiState(rootState)?.config;
+  }
+  function buildAnyQuerySelector(endpointName, endpointDefinition, combiner) {
+    return (queryArgs) => {
+      if (queryArgs === skipToken) {
+        return createSelector2(selectSkippedQuery, combiner);
+      }
+      const serializedArgs = serializeQueryArgs({
+        queryArgs,
+        endpointDefinition,
+        endpointName
+      });
+      const selectQuerySubstate = (state) => selectQueryEntry(state, serializedArgs) ?? defaultQuerySubState;
+      return createSelector2(selectQuerySubstate, combiner);
+    };
+  }
+  function buildQuerySelector(endpointName, endpointDefinition) {
+    return buildAnyQuerySelector(endpointName, endpointDefinition, withRequestFlags);
+  }
+  function buildInfiniteQuerySelector(endpointName, endpointDefinition) {
+    const {
+      infiniteQueryOptions
+    } = endpointDefinition;
+    function withInfiniteQueryResultFlags(substate) {
+      const stateWithRequestFlags = {
+        ...substate,
+        ...getRequestStatusFlags(substate.status)
+      };
+      const {
+        isLoading,
+        isError,
+        direction
+      } = stateWithRequestFlags;
+      const isForward = direction === "forward";
+      const isBackward = direction === "backward";
+      return {
+        ...stateWithRequestFlags,
+        hasNextPage: getHasNextPage(infiniteQueryOptions, stateWithRequestFlags.data, stateWithRequestFlags.originalArgs),
+        hasPreviousPage: getHasPreviousPage(infiniteQueryOptions, stateWithRequestFlags.data, stateWithRequestFlags.originalArgs),
+        isFetchingNextPage: isLoading && isForward,
+        isFetchingPreviousPage: isLoading && isBackward,
+        isFetchNextPageError: isError && isForward,
+        isFetchPreviousPageError: isError && isBackward
+      };
+    }
+    return buildAnyQuerySelector(endpointName, endpointDefinition, withInfiniteQueryResultFlags);
+  }
+  function buildMutationSelector() {
+    return (id) => {
+      let mutationId;
+      if (typeof id === "object") {
+        mutationId = getMutationCacheKey(id) ?? skipToken;
+      } else {
+        mutationId = id;
+      }
+      const selectMutationSubstate = (state) => selectApiState(state)?.mutations?.[mutationId] ?? defaultMutationSubState;
+      const finalSelectMutationSubstate = mutationId === skipToken ? selectSkippedMutation : selectMutationSubstate;
+      return createSelector2(finalSelectMutationSubstate, withRequestFlags);
+    };
+  }
+  function selectInvalidatedBy(state, tags) {
+    const apiState = state[reducerPath];
+    const toInvalidate = /* @__PURE__ */ new Set();
+    for (const tag of tags.filter(isNotNullish).map(expandTagDescription)) {
+      const provided = apiState.provided.tags[tag.type];
+      if (!provided) {
+        continue;
+      }
+      let invalidateSubscriptions = (tag.id !== void 0 ? (
+        // id given: invalidate all queries that provide this type & id
+        provided[tag.id]
+      ) : (
+        // no id: invalidate all queries that provide this type
+        flatten(Object.values(provided))
+      )) ?? [];
+      for (const invalidate of invalidateSubscriptions) {
+        toInvalidate.add(invalidate);
+      }
+    }
+    return flatten(Array.from(toInvalidate.values()).map((queryCacheKey) => {
+      const querySubState = apiState.queries[queryCacheKey];
+      return querySubState ? [{
+        queryCacheKey,
+        endpointName: querySubState.endpointName,
+        originalArgs: querySubState.originalArgs
+      }] : [];
+    }));
+  }
+  function selectCachedArgsForQuery(state, queryName) {
+    return Object.values(selectQueries(state)).filter((entry) => entry?.endpointName === queryName && entry.status !== "uninitialized" /* uninitialized */).map((entry) => entry.originalArgs);
+  }
+  function getHasNextPage(options, data, queryArg) {
+    if (!data) return false;
+    return getNextPageParam(options, data, queryArg) != null;
+  }
+  function getHasPreviousPage(options, data, queryArg) {
+    if (!data || !options.getPreviousPageParam) return false;
+    return getPreviousPageParam(options, data, queryArg) != null;
+  }
+}
+
+// src/query/createApi.ts
+import { formatProdErrorMessage as _formatProdErrorMessage2, formatProdErrorMessage as _formatProdErrorMessage22, formatProdErrorMessage as _formatProdErrorMessage3 } from "@reduxjs/toolkit";
+
+// src/query/defaultSerializeQueryArgs.ts
+var cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;
+var defaultSerializeQueryArgs = ({
+  endpointName,
+  queryArgs
+}) => {
+  let serialized = "";
+  const cached = cache?.get(queryArgs);
+  if (typeof cached === "string") {
+    serialized = cached;
+  } else {
+    const stringified = JSON.stringify(queryArgs, (key, value) => {
+      value = typeof value === "bigint" ? {
+        $bigint: value.toString()
+      } : value;
+      value = isPlainObject(value) ? Object.keys(value).sort().reduce((acc, key2) => {
+        acc[key2] = value[key2];
+        return acc;
+      }, {}) : value;
+      return value;
+    });
+    if (isPlainObject(queryArgs)) {
+      cache?.set(queryArgs, stringified);
+    }
+    serialized = stringified;
+  }
+  return `${endpointName}(${serialized})`;
+};
+
+// src/query/createApi.ts
+import { weakMapMemoize } from "reselect";
+function buildCreateApi(...modules) {
+  return function baseCreateApi(options) {
+    const extractRehydrationInfo = weakMapMemoize((action) => options.extractRehydrationInfo?.(action, {
+      reducerPath: options.reducerPath ?? "api"
+    }));
+    const optionsWithDefaults = {
+      reducerPath: "api",
+      keepUnusedDataFor: 60,
+      refetchOnMountOrArgChange: false,
+      refetchOnFocus: false,
+      refetchOnReconnect: false,
+      invalidationBehavior: "delayed",
+      ...options,
+      extractRehydrationInfo,
+      serializeQueryArgs(queryArgsApi) {
+        let finalSerializeQueryArgs = defaultSerializeQueryArgs;
+        if ("serializeQueryArgs" in queryArgsApi.endpointDefinition) {
+          const endpointSQA = queryArgsApi.endpointDefinition.serializeQueryArgs;
+          finalSerializeQueryArgs = (queryArgsApi2) => {
+            const initialResult = endpointSQA(queryArgsApi2);
+            if (typeof initialResult === "string") {
+              return initialResult;
+            } else {
+              return defaultSerializeQueryArgs({
+                ...queryArgsApi2,
+                queryArgs: initialResult
+              });
+            }
+          };
+        } else if (options.serializeQueryArgs) {
+          finalSerializeQueryArgs = options.serializeQueryArgs;
+        }
+        return finalSerializeQueryArgs(queryArgsApi);
+      },
+      tagTypes: [...options.tagTypes || []]
+    };
+    const context = {
+      endpointDefinitions: {},
+      batch(fn) {
+        fn();
+      },
+      apiUid: nanoid(),
+      extractRehydrationInfo,
+      hasRehydrationInfo: weakMapMemoize((action) => extractRehydrationInfo(action) != null)
+    };
+    const api = {
+      injectEndpoints,
+      enhanceEndpoints({
+        addTagTypes,
+        endpoints
+      }) {
+        if (addTagTypes) {
+          for (const eT of addTagTypes) {
+            if (!optionsWithDefaults.tagTypes.includes(eT)) {
+              ;
+              optionsWithDefaults.tagTypes.push(eT);
+            }
+          }
+        }
+        if (endpoints) {
+          for (const [endpointName, partialDefinition] of Object.entries(endpoints)) {
+            if (typeof partialDefinition === "function") {
+              partialDefinition(context.endpointDefinitions[endpointName]);
+            } else {
+              Object.assign(context.endpointDefinitions[endpointName] || {}, partialDefinition);
+            }
+          }
+        }
+        return api;
+      }
+    };
+    const initializedModules = modules.map((m) => m.init(api, optionsWithDefaults, context));
+    function injectEndpoints(inject) {
+      const evaluatedEndpoints = inject.endpoints({
+        query: (x) => ({
+          ...x,
+          type: "query" /* query */
+        }),
+        mutation: (x) => ({
+          ...x,
+          type: "mutation" /* mutation */
+        }),
+        infiniteQuery: (x) => ({
+          ...x,
+          type: "infinitequery" /* infinitequery */
+        })
+      });
+      for (const [endpointName, definition] of Object.entries(evaluatedEndpoints)) {
+        if (inject.overrideExisting !== true && endpointName in context.endpointDefinitions) {
+          if (inject.overrideExisting === "throw") {
+            throw new Error(process.env.NODE_ENV === "production" ? _formatProdErrorMessage2(39) : `called \`injectEndpoints\` to override already-existing endpointName ${endpointName} without specifying \`overrideExisting: true\``);
+          } else if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+            console.error(`called \`injectEndpoints\` to override already-existing endpointName ${endpointName} without specifying \`overrideExisting: true\``);
+          }
+          continue;
+        }
+        if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+          if (isInfiniteQueryDefinition(definition)) {
+            const {
+              infiniteQueryOptions
+            } = definition;
+            const {
+              maxPages,
+              getPreviousPageParam: getPreviousPageParam2
+            } = infiniteQueryOptions;
+            if (typeof maxPages === "number") {
+              if (maxPages < 1) {
+                throw new Error(process.env.NODE_ENV === "production" ? _formatProdErrorMessage22(40) : `maxPages for endpoint '${endpointName}' must be a number greater than 0`);
+              }
+              if (typeof getPreviousPageParam2 !== "function") {
+                throw new Error(process.env.NODE_ENV === "production" ? _formatProdErrorMessage3(41) : `getPreviousPageParam for endpoint '${endpointName}' must be a function if maxPages is used`);
+              }
+            }
+          }
+        }
+        context.endpointDefinitions[endpointName] = definition;
+        for (const m of initializedModules) {
+          m.injectEndpoint(endpointName, definition);
+        }
+      }
+      return api;
+    }
+    return api.injectEndpoints({
+      endpoints: options.endpoints
+    });
+  };
+}
+
+// src/query/fakeBaseQuery.ts
+import { formatProdErrorMessage as _formatProdErrorMessage4 } from "@reduxjs/toolkit";
+var _NEVER = /* @__PURE__ */ Symbol();
+function fakeBaseQuery() {
+  return function() {
+    throw new Error(process.env.NODE_ENV === "production" ? _formatProdErrorMessage4(33) : "When using `fakeBaseQuery`, all queries & mutations must use the `queryFn` definition syntax.");
+  };
+}
+
+// src/query/core/module.ts
+import { enablePatches } from "immer";
+
+// src/query/tsHelpers.ts
+function assertCast(v) {
+}
+function safeAssign(target, ...args) {
+  return Object.assign(target, ...args);
+}
+
+// src/query/core/buildMiddleware/batchActions.ts
+import { produceWithPatches as produceWithPatches2 } from "immer";
+var buildBatchedActionsHandler = ({
+  api,
+  queryThunk,
+  internalState
+}) => {
+  const subscriptionsPrefix = `${api.reducerPath}/subscriptions`;
+  let previousSubscriptions = null;
+  let updateSyncTimer = null;
+  const {
+    updateSubscriptionOptions,
+    unsubscribeQueryResult
+  } = api.internalActions;
+  const actuallyMutateSubscriptions = (mutableState, action) => {
+    if (updateSubscriptionOptions.match(action)) {
+      const {
+        queryCacheKey,
+        requestId,
+        options
+      } = action.payload;
+      if (mutableState?.[queryCacheKey]?.[requestId]) {
+        mutableState[queryCacheKey][requestId] = options;
+      }
+      return true;
+    }
+    if (unsubscribeQueryResult.match(action)) {
+      const {
+        queryCacheKey,
+        requestId
+      } = action.payload;
+      if (mutableState[queryCacheKey]) {
+        delete mutableState[queryCacheKey][requestId];
+      }
+      return true;
+    }
+    if (api.internalActions.removeQueryResult.match(action)) {
+      delete mutableState[action.payload.queryCacheKey];
+      return true;
+    }
+    if (queryThunk.pending.match(action)) {
+      const {
+        meta: {
+          arg,
+          requestId
+        }
+      } = action;
+      const substate = mutableState[arg.queryCacheKey] ??= {};
+      substate[`${requestId}_running`] = {};
+      if (arg.subscribe) {
+        substate[requestId] = arg.subscriptionOptions ?? substate[requestId] ?? {};
+      }
+      return true;
+    }
+    let mutated = false;
+    if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action)) {
+      const state = mutableState[action.meta.arg.queryCacheKey] || {};
+      const key = `${action.meta.requestId}_running`;
+      mutated ||= !!state[key];
+      delete state[key];
+    }
+    if (queryThunk.rejected.match(action)) {
+      const {
+        meta: {
+          condition,
+          arg,
+          requestId
+        }
+      } = action;
+      if (condition && arg.subscribe) {
+        const substate = mutableState[arg.queryCacheKey] ??= {};
+        substate[requestId] = arg.subscriptionOptions ?? substate[requestId] ?? {};
+        mutated = true;
+      }
+    }
+    return mutated;
+  };
+  const getSubscriptions = () => internalState.currentSubscriptions;
+  const getSubscriptionCount = (queryCacheKey) => {
+    const subscriptions = getSubscriptions();
+    const subscriptionsForQueryArg = subscriptions[queryCacheKey] ?? {};
+    return countObjectKeys(subscriptionsForQueryArg);
+  };
+  const isRequestSubscribed = (queryCacheKey, requestId) => {
+    const subscriptions = getSubscriptions();
+    return !!subscriptions?.[queryCacheKey]?.[requestId];
+  };
+  const subscriptionSelectors = {
+    getSubscriptions,
+    getSubscriptionCount,
+    isRequestSubscribed
+  };
+  return (action, mwApi) => {
+    if (!previousSubscriptions) {
+      previousSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));
+    }
+    if (api.util.resetApiState.match(action)) {
+      previousSubscriptions = internalState.currentSubscriptions = {};
+      updateSyncTimer = null;
+      return [true, false];
+    }
+    if (api.internalActions.internal_getRTKQSubscriptions.match(action)) {
+      return [false, subscriptionSelectors];
+    }
+    const didMutate = actuallyMutateSubscriptions(internalState.currentSubscriptions, action);
+    let actionShouldContinue = true;
+    if (didMutate) {
+      if (!updateSyncTimer) {
+        updateSyncTimer = setTimeout(() => {
+          const newSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));
+          const [, patches] = produceWithPatches2(previousSubscriptions, () => newSubscriptions);
+          mwApi.next(api.internalActions.subscriptionsUpdated(patches));
+          previousSubscriptions = newSubscriptions;
+          updateSyncTimer = null;
+        }, 500);
+      }
+      const isSubscriptionSliceAction = typeof action.type == "string" && !!action.type.startsWith(subscriptionsPrefix);
+      const isAdditionalSubscriptionAction = queryThunk.rejected.match(action) && action.meta.condition && !!action.meta.arg.subscribe;
+      actionShouldContinue = !isSubscriptionSliceAction && !isAdditionalSubscriptionAction;
+    }
+    return [actionShouldContinue, false];
+  };
+};
+
+// src/query/core/buildMiddleware/cacheCollection.ts
+function isObjectEmpty(obj) {
+  for (const k in obj) {
+    return false;
+  }
+  return true;
+}
+var THIRTY_TWO_BIT_MAX_TIMER_SECONDS = 2147483647 / 1e3 - 1;
+var buildCacheCollectionHandler = ({
+  reducerPath,
+  api,
+  queryThunk,
+  context,
+  internalState,
+  selectors: {
+    selectQueryEntry,
+    selectConfig
+  }
+}) => {
+  const {
+    removeQueryResult,
+    unsubscribeQueryResult,
+    cacheEntriesUpserted
+  } = api.internalActions;
+  const canTriggerUnsubscribe = isAnyOf(unsubscribeQueryResult.match, queryThunk.fulfilled, queryThunk.rejected, cacheEntriesUpserted.match);
+  function anySubscriptionsRemainingForKey(queryCacheKey) {
+    const subscriptions = internalState.currentSubscriptions[queryCacheKey];
+    return !!subscriptions && !isObjectEmpty(subscriptions);
+  }
+  const currentRemovalTimeouts = {};
+  const handler = (action, mwApi, internalState2) => {
+    const state = mwApi.getState();
+    const config = selectConfig(state);
+    if (canTriggerUnsubscribe(action)) {
+      let queryCacheKeys;
+      if (cacheEntriesUpserted.match(action)) {
+        queryCacheKeys = action.payload.map((entry) => entry.queryDescription.queryCacheKey);
+      } else {
+        const {
+          queryCacheKey
+        } = unsubscribeQueryResult.match(action) ? action.payload : action.meta.arg;
+        queryCacheKeys = [queryCacheKey];
+      }
+      handleUnsubscribeMany(queryCacheKeys, mwApi, config);
+    }
+    if (api.util.resetApiState.match(action)) {
+      for (const [key, timeout] of Object.entries(currentRemovalTimeouts)) {
+        if (timeout) clearTimeout(timeout);
+        delete currentRemovalTimeouts[key];
+      }
+    }
+    if (context.hasRehydrationInfo(action)) {
+      const {
+        queries
+      } = context.extractRehydrationInfo(action);
+      handleUnsubscribeMany(Object.keys(queries), mwApi, config);
+    }
+  };
+  function handleUnsubscribeMany(cacheKeys, api2, config) {
+    const state = api2.getState();
+    for (const queryCacheKey of cacheKeys) {
+      const entry = selectQueryEntry(state, queryCacheKey);
+      handleUnsubscribe(queryCacheKey, entry?.endpointName, api2, config);
+    }
+  }
+  function handleUnsubscribe(queryCacheKey, endpointName, api2, config) {
+    const endpointDefinition = context.endpointDefinitions[endpointName];
+    const keepUnusedDataFor = endpointDefinition?.keepUnusedDataFor ?? config.keepUnusedDataFor;
+    if (keepUnusedDataFor === Infinity) {
+      return;
+    }
+    const finalKeepUnusedDataFor = Math.max(0, Math.min(keepUnusedDataFor, THIRTY_TWO_BIT_MAX_TIMER_SECONDS));
+    if (!anySubscriptionsRemainingForKey(queryCacheKey)) {
+      const currentTimeout = currentRemovalTimeouts[queryCacheKey];
+      if (currentTimeout) {
+        clearTimeout(currentTimeout);
+      }
+      currentRemovalTimeouts[queryCacheKey] = setTimeout(() => {
+        if (!anySubscriptionsRemainingForKey(queryCacheKey)) {
+          api2.dispatch(removeQueryResult({
+            queryCacheKey
+          }));
+        }
+        delete currentRemovalTimeouts[queryCacheKey];
+      }, finalKeepUnusedDataFor * 1e3);
+    }
+  }
+  return handler;
+};
+
+// src/query/core/buildMiddleware/cacheLifecycle.ts
+var neverResolvedError = new Error("Promise never resolved before cacheEntryRemoved.");
+var buildCacheLifecycleHandler = ({
+  api,
+  reducerPath,
+  context,
+  queryThunk,
+  mutationThunk,
+  internalState,
+  selectors: {
+    selectQueryEntry,
+    selectApiState
+  }
+}) => {
+  const isQueryThunk = isAsyncThunkAction(queryThunk);
+  const isMutationThunk = isAsyncThunkAction(mutationThunk);
+  const isFulfilledThunk = isFulfilled(queryThunk, mutationThunk);
+  const lifecycleMap = {};
+  function resolveLifecycleEntry(cacheKey, data, meta) {
+    const lifecycle = lifecycleMap[cacheKey];
+    if (lifecycle?.valueResolved) {
+      lifecycle.valueResolved({
+        data,
+        meta
+      });
+      delete lifecycle.valueResolved;
+    }
+  }
+  function removeLifecycleEntry(cacheKey) {
+    const lifecycle = lifecycleMap[cacheKey];
+    if (lifecycle) {
+      delete lifecycleMap[cacheKey];
+      lifecycle.cacheEntryRemoved();
+    }
+  }
+  const handler = (action, mwApi, stateBefore) => {
+    const cacheKey = getCacheKey(action);
+    function checkForNewCacheKey(endpointName, cacheKey2, requestId, originalArgs) {
+      const oldEntry = selectQueryEntry(stateBefore, cacheKey2);
+      const newEntry = selectQueryEntry(mwApi.getState(), cacheKey2);
+      if (!oldEntry && newEntry) {
+        handleNewKey(endpointName, originalArgs, cacheKey2, mwApi, requestId);
+      }
+    }
+    if (queryThunk.pending.match(action)) {
+      checkForNewCacheKey(action.meta.arg.endpointName, cacheKey, action.meta.requestId, action.meta.arg.originalArgs);
+    } else if (api.internalActions.cacheEntriesUpserted.match(action)) {
+      for (const {
+        queryDescription,
+        value
+      } of action.payload) {
+        const {
+          endpointName,
+          originalArgs,
+          queryCacheKey
+        } = queryDescription;
+        checkForNewCacheKey(endpointName, queryCacheKey, action.meta.requestId, originalArgs);
+        resolveLifecycleEntry(queryCacheKey, value, {});
+      }
+    } else if (mutationThunk.pending.match(action)) {
+      const state = mwApi.getState()[reducerPath].mutations[cacheKey];
+      if (state) {
+        handleNewKey(action.meta.arg.endpointName, action.meta.arg.originalArgs, cacheKey, mwApi, action.meta.requestId);
+      }
+    } else if (isFulfilledThunk(action)) {
+      resolveLifecycleEntry(cacheKey, action.payload, action.meta.baseQueryMeta);
+    } else if (api.internalActions.removeQueryResult.match(action) || api.internalActions.removeMutationResult.match(action)) {
+      removeLifecycleEntry(cacheKey);
+    } else if (api.util.resetApiState.match(action)) {
+      for (const cacheKey2 of Object.keys(lifecycleMap)) {
+        removeLifecycleEntry(cacheKey2);
+      }
+    }
+  };
+  function getCacheKey(action) {
+    if (isQueryThunk(action)) return action.meta.arg.queryCacheKey;
+    if (isMutationThunk(action)) {
+      return action.meta.arg.fixedCacheKey ?? action.meta.requestId;
+    }
+    if (api.internalActions.removeQueryResult.match(action)) return action.payload.queryCacheKey;
+    if (api.internalActions.removeMutationResult.match(action)) return getMutationCacheKey(action.payload);
+    return "";
+  }
+  function handleNewKey(endpointName, originalArgs, queryCacheKey, mwApi, requestId) {
+    const endpointDefinition = context.endpointDefinitions[endpointName];
+    const onCacheEntryAdded = endpointDefinition?.onCacheEntryAdded;
+    if (!onCacheEntryAdded) return;
+    const lifecycle = {};
+    const cacheEntryRemoved = new Promise((resolve) => {
+      lifecycle.cacheEntryRemoved = resolve;
+    });
+    const cacheDataLoaded = Promise.race([new Promise((resolve) => {
+      lifecycle.valueResolved = resolve;
+    }), cacheEntryRemoved.then(() => {
+      throw neverResolvedError;
+    })]);
+    cacheDataLoaded.catch(() => {
+    });
+    lifecycleMap[queryCacheKey] = lifecycle;
+    const selector = api.endpoints[endpointName].select(isAnyQueryDefinition(endpointDefinition) ? originalArgs : queryCacheKey);
+    const extra = mwApi.dispatch((_, __, extra2) => extra2);
+    const lifecycleApi = {
+      ...mwApi,
+      getCacheEntry: () => selector(mwApi.getState()),
+      requestId,
+      extra,
+      updateCachedData: isAnyQueryDefinition(endpointDefinition) ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
+      cacheDataLoaded,
+      cacheEntryRemoved
+    };
+    const runningHandler = onCacheEntryAdded(originalArgs, lifecycleApi);
+    Promise.resolve(runningHandler).catch((e) => {
+      if (e === neverResolvedError) return;
+      throw e;
+    });
+  }
+  return handler;
+};
+
+// src/query/core/buildMiddleware/devMiddleware.ts
+var buildDevCheckHandler = ({
+  api,
+  context: {
+    apiUid
+  },
+  reducerPath
+}) => {
+  return (action, mwApi) => {
+    if (api.util.resetApiState.match(action)) {
+      mwApi.dispatch(api.internalActions.middlewareRegistered(apiUid));
+    }
+    if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+      if (api.internalActions.middlewareRegistered.match(action) && action.payload === apiUid && mwApi.getState()[reducerPath]?.config?.middlewareRegistered === "conflict") {
+        console.warn(`There is a mismatch between slice and middleware for the reducerPath "${reducerPath}".
+You can only have one api per reducer path, this will lead to crashes in various situations!${reducerPath === "api" ? `
+If you have multiple apis, you *have* to specify the reducerPath option when using createApi!` : ""}`);
+      }
+    }
+  };
+};
+
+// src/query/core/buildMiddleware/invalidationByTags.ts
+var buildInvalidationByTagsHandler = ({
+  reducerPath,
+  context,
+  context: {
+    endpointDefinitions
+  },
+  mutationThunk,
+  queryThunk,
+  api,
+  assertTagType,
+  refetchQuery,
+  internalState
+}) => {
+  const {
+    removeQueryResult
+  } = api.internalActions;
+  const isThunkActionWithTags = isAnyOf(isFulfilled(mutationThunk), isRejectedWithValue(mutationThunk));
+  const isQueryEnd = isAnyOf(isFulfilled(mutationThunk, queryThunk), isRejected(mutationThunk, queryThunk));
+  let pendingTagInvalidations = [];
+  const handler = (action, mwApi) => {
+    if (isThunkActionWithTags(action)) {
+      invalidateTags(calculateProvidedByThunk(action, "invalidatesTags", endpointDefinitions, assertTagType), mwApi);
+    } else if (isQueryEnd(action)) {
+      invalidateTags([], mwApi);
+    } else if (api.util.invalidateTags.match(action)) {
+      invalidateTags(calculateProvidedBy(action.payload, void 0, void 0, void 0, void 0, assertTagType), mwApi);
+    }
+  };
+  function hasPendingRequests(state) {
+    const {
+      queries,
+      mutations
+    } = state;
+    for (const cacheRecord of [queries, mutations]) {
+      for (const key in cacheRecord) {
+        if (cacheRecord[key]?.status === "pending" /* pending */) return true;
+      }
+    }
+    return false;
+  }
+  function invalidateTags(newTags, mwApi) {
+    const rootState = mwApi.getState();
+    const state = rootState[reducerPath];
+    pendingTagInvalidations.push(...newTags);
+    if (state.config.invalidationBehavior === "delayed" && hasPendingRequests(state)) {
+      return;
+    }
+    const tags = pendingTagInvalidations;
+    pendingTagInvalidations = [];
+    if (tags.length === 0) return;
+    const toInvalidate = api.util.selectInvalidatedBy(rootState, tags);
+    context.batch(() => {
+      const valuesArray = Array.from(toInvalidate.values());
+      for (const {
+        queryCacheKey
+      } of valuesArray) {
+        const querySubState = state.queries[queryCacheKey];
+        const subscriptionSubState = internalState.currentSubscriptions[queryCacheKey] ?? {};
+        if (querySubState) {
+          if (countObjectKeys(subscriptionSubState) === 0) {
+            mwApi.dispatch(removeQueryResult({
+              queryCacheKey
+            }));
+          } else if (querySubState.status !== "uninitialized" /* uninitialized */) {
+            mwApi.dispatch(refetchQuery(querySubState));
+          }
+        }
+      }
+    });
+  }
+  return handler;
+};
+
+// src/query/core/buildMiddleware/polling.ts
+var buildPollingHandler = ({
+  reducerPath,
+  queryThunk,
+  api,
+  refetchQuery,
+  internalState
+}) => {
+  const currentPolls = {};
+  const handler = (action, mwApi) => {
+    if (api.internalActions.updateSubscriptionOptions.match(action) || api.internalActions.unsubscribeQueryResult.match(action)) {
+      updatePollingInterval(action.payload, mwApi);
+    }
+    if (queryThunk.pending.match(action) || queryThunk.rejected.match(action) && action.meta.condition) {
+      updatePollingInterval(action.meta.arg, mwApi);
+    }
+    if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action) && !action.meta.condition) {
+      startNextPoll(action.meta.arg, mwApi);
+    }
+    if (api.util.resetApiState.match(action)) {
+      clearPolls();
+    }
+  };
+  function getCacheEntrySubscriptions(queryCacheKey, api2) {
+    const state = api2.getState()[reducerPath];
+    const querySubState = state.queries[queryCacheKey];
+    const subscriptions = internalState.currentSubscriptions[queryCacheKey];
+    if (!querySubState || querySubState.status === "uninitialized" /* uninitialized */) return;
+    return subscriptions;
+  }
+  function startNextPoll({
+    queryCacheKey
+  }, api2) {
+    const state = api2.getState()[reducerPath];
+    const querySubState = state.queries[queryCacheKey];
+    const subscriptions = internalState.currentSubscriptions[queryCacheKey];
+    if (!querySubState || querySubState.status === "uninitialized" /* uninitialized */) return;
+    const {
+      lowestPollingInterval,
+      skipPollingIfUnfocused
+    } = findLowestPollingInterval(subscriptions);
+    if (!Number.isFinite(lowestPollingInterval)) return;
+    const currentPoll = currentPolls[queryCacheKey];
+    if (currentPoll?.timeout) {
+      clearTimeout(currentPoll.timeout);
+      currentPoll.timeout = void 0;
+    }
+    const nextPollTimestamp = Date.now() + lowestPollingInterval;
+    currentPolls[queryCacheKey] = {
+      nextPollTimestamp,
+      pollingInterval: lowestPollingInterval,
+      timeout: setTimeout(() => {
+        if (state.config.focused || !skipPollingIfUnfocused) {
+          api2.dispatch(refetchQuery(querySubState));
+        }
+        startNextPoll({
+          queryCacheKey
+        }, api2);
+      }, lowestPollingInterval)
+    };
+  }
+  function updatePollingInterval({
+    queryCacheKey
+  }, api2) {
+    const state = api2.getState()[reducerPath];
+    const querySubState = state.queries[queryCacheKey];
+    const subscriptions = internalState.currentSubscriptions[queryCacheKey];
+    if (!querySubState || querySubState.status === "uninitialized" /* uninitialized */) {
+      return;
+    }
+    const {
+      lowestPollingInterval
+    } = findLowestPollingInterval(subscriptions);
+    if (!Number.isFinite(lowestPollingInterval)) {
+      cleanupPollForKey(queryCacheKey);
+      return;
+    }
+    const currentPoll = currentPolls[queryCacheKey];
+    const nextPollTimestamp = Date.now() + lowestPollingInterval;
+    if (!currentPoll || nextPollTimestamp < currentPoll.nextPollTimestamp) {
+      startNextPoll({
+        queryCacheKey
+      }, api2);
+    }
+  }
+  function cleanupPollForKey(key) {
+    const existingPoll = currentPolls[key];
+    if (existingPoll?.timeout) {
+      clearTimeout(existingPoll.timeout);
+    }
+    delete currentPolls[key];
+  }
+  function clearPolls() {
+    for (const key of Object.keys(currentPolls)) {
+      cleanupPollForKey(key);
+    }
+  }
+  function findLowestPollingInterval(subscribers = {}) {
+    let skipPollingIfUnfocused = false;
+    let lowestPollingInterval = Number.POSITIVE_INFINITY;
+    for (let key in subscribers) {
+      if (!!subscribers[key].pollingInterval) {
+        lowestPollingInterval = Math.min(subscribers[key].pollingInterval, lowestPollingInterval);
+        skipPollingIfUnfocused = subscribers[key].skipPollingIfUnfocused || skipPollingIfUnfocused;
+      }
+    }
+    return {
+      lowestPollingInterval,
+      skipPollingIfUnfocused
+    };
+  }
+  return handler;
+};
+
+// src/query/core/buildMiddleware/queryLifecycle.ts
+var buildQueryLifecycleHandler = ({
+  api,
+  context,
+  queryThunk,
+  mutationThunk
+}) => {
+  const isPendingThunk = isPending(queryThunk, mutationThunk);
+  const isRejectedThunk = isRejected(queryThunk, mutationThunk);
+  const isFullfilledThunk = isFulfilled(queryThunk, mutationThunk);
+  const lifecycleMap = {};
+  const handler = (action, mwApi) => {
+    if (isPendingThunk(action)) {
+      const {
+        requestId,
+        arg: {
+          endpointName,
+          originalArgs
+        }
+      } = action.meta;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const onQueryStarted = endpointDefinition?.onQueryStarted;
+      if (onQueryStarted) {
+        const lifecycle = {};
+        const queryFulfilled = new Promise((resolve, reject) => {
+          lifecycle.resolve = resolve;
+          lifecycle.reject = reject;
+        });
+        queryFulfilled.catch(() => {
+        });
+        lifecycleMap[requestId] = lifecycle;
+        const selector = api.endpoints[endpointName].select(isAnyQueryDefinition(endpointDefinition) ? originalArgs : requestId);
+        const extra = mwApi.dispatch((_, __, extra2) => extra2);
+        const lifecycleApi = {
+          ...mwApi,
+          getCacheEntry: () => selector(mwApi.getState()),
+          requestId,
+          extra,
+          updateCachedData: isAnyQueryDefinition(endpointDefinition) ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
+          queryFulfilled
+        };
+        onQueryStarted(originalArgs, lifecycleApi);
+      }
+    } else if (isFullfilledThunk(action)) {
+      const {
+        requestId,
+        baseQueryMeta
+      } = action.meta;
+      lifecycleMap[requestId]?.resolve({
+        data: action.payload,
+        meta: baseQueryMeta
+      });
+      delete lifecycleMap[requestId];
+    } else if (isRejectedThunk(action)) {
+      const {
+        requestId,
+        rejectedWithValue,
+        baseQueryMeta
+      } = action.meta;
+      lifecycleMap[requestId]?.reject({
+        error: action.payload ?? action.error,
+        isUnhandledError: !rejectedWithValue,
+        meta: baseQueryMeta
+      });
+      delete lifecycleMap[requestId];
+    }
+  };
+  return handler;
+};
+
+// src/query/core/buildMiddleware/windowEventHandling.ts
+var buildWindowEventHandler = ({
+  reducerPath,
+  context,
+  api,
+  refetchQuery,
+  internalState
+}) => {
+  const {
+    removeQueryResult
+  } = api.internalActions;
+  const handler = (action, mwApi) => {
+    if (onFocus.match(action)) {
+      refetchValidQueries(mwApi, "refetchOnFocus");
+    }
+    if (onOnline.match(action)) {
+      refetchValidQueries(mwApi, "refetchOnReconnect");
+    }
+  };
+  function refetchValidQueries(api2, type) {
+    const state = api2.getState()[reducerPath];
+    const queries = state.queries;
+    const subscriptions = internalState.currentSubscriptions;
+    context.batch(() => {
+      for (const queryCacheKey of Object.keys(subscriptions)) {
+        const querySubState = queries[queryCacheKey];
+        const subscriptionSubState = subscriptions[queryCacheKey];
+        if (!subscriptionSubState || !querySubState) continue;
+        const shouldRefetch = Object.values(subscriptionSubState).some((sub) => sub[type] === true) || Object.values(subscriptionSubState).every((sub) => sub[type] === void 0) && state.config[type];
+        if (shouldRefetch) {
+          if (countObjectKeys(subscriptionSubState) === 0) {
+            api2.dispatch(removeQueryResult({
+              queryCacheKey
+            }));
+          } else if (querySubState.status !== "uninitialized" /* uninitialized */) {
+            api2.dispatch(refetchQuery(querySubState));
+          }
+        }
+      }
+    });
+  }
+  return handler;
+};
+
+// src/query/core/buildMiddleware/index.ts
+function buildMiddleware(input) {
+  const {
+    reducerPath,
+    queryThunk,
+    api,
+    context
+  } = input;
+  const {
+    apiUid
+  } = context;
+  const actions = {
+    invalidateTags: createAction(`${reducerPath}/invalidateTags`)
+  };
+  const isThisApiSliceAction = (action) => action.type.startsWith(`${reducerPath}/`);
+  const handlerBuilders = [buildDevCheckHandler, buildCacheCollectionHandler, buildInvalidationByTagsHandler, buildPollingHandler, buildCacheLifecycleHandler, buildQueryLifecycleHandler];
+  const middleware = (mwApi) => {
+    let initialized2 = false;
+    const internalState = {
+      currentSubscriptions: {}
+    };
+    const builderArgs = {
+      ...input,
+      internalState,
+      refetchQuery,
+      isThisApiSliceAction
+    };
+    const handlers = handlerBuilders.map((build) => build(builderArgs));
+    const batchedActionsHandler = buildBatchedActionsHandler(builderArgs);
+    const windowEventsHandler = buildWindowEventHandler(builderArgs);
+    return (next) => {
+      return (action) => {
+        if (!isAction(action)) {
+          return next(action);
+        }
+        if (!initialized2) {
+          initialized2 = true;
+          mwApi.dispatch(api.internalActions.middlewareRegistered(apiUid));
+        }
+        const mwApiWithNext = {
+          ...mwApi,
+          next
+        };
+        const stateBefore = mwApi.getState();
+        const [actionShouldContinue, internalProbeResult] = batchedActionsHandler(action, mwApiWithNext, stateBefore);
+        let res;
+        if (actionShouldContinue) {
+          res = next(action);
+        } else {
+          res = internalProbeResult;
+        }
+        if (!!mwApi.getState()[reducerPath]) {
+          windowEventsHandler(action, mwApiWithNext, stateBefore);
+          if (isThisApiSliceAction(action) || context.hasRehydrationInfo(action)) {
+            for (const handler of handlers) {
+              handler(action, mwApiWithNext, stateBefore);
+            }
+          }
+        }
+        return res;
+      };
+    };
+  };
+  return {
+    middleware,
+    actions
+  };
+  function refetchQuery(querySubState) {
+    return input.api.endpoints[querySubState.endpointName].initiate(querySubState.originalArgs, {
+      subscribe: false,
+      forceRefetch: true
+    });
+  }
+}
+
+// src/query/core/module.ts
+var coreModuleName = /* @__PURE__ */ Symbol();
+var coreModule = ({
+  createSelector: createSelector2 = createSelector
+} = {}) => ({
+  name: coreModuleName,
+  init(api, {
+    baseQuery,
+    tagTypes,
+    reducerPath,
+    serializeQueryArgs,
+    keepUnusedDataFor,
+    refetchOnMountOrArgChange,
+    refetchOnFocus,
+    refetchOnReconnect,
+    invalidationBehavior,
+    onSchemaFailure,
+    catchSchemaFailure,
+    skipSchemaValidation
+  }, context) {
+    enablePatches();
+    assertCast(serializeQueryArgs);
+    const assertTagType = (tag) => {
+      if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+        if (!tagTypes.includes(tag.type)) {
+          console.error(`Tag type '${tag.type}' was used, but not specified in \`tagTypes\`!`);
+        }
+      }
+      return tag;
+    };
+    Object.assign(api, {
+      reducerPath,
+      endpoints: {},
+      internalActions: {
+        onOnline,
+        onOffline,
+        onFocus,
+        onFocusLost
+      },
+      util: {}
+    });
+    const selectors = buildSelectors({
+      serializeQueryArgs,
+      reducerPath,
+      createSelector: createSelector2
+    });
+    const {
+      selectInvalidatedBy,
+      selectCachedArgsForQuery,
+      buildQuerySelector,
+      buildInfiniteQuerySelector,
+      buildMutationSelector
+    } = selectors;
+    safeAssign(api.util, {
+      selectInvalidatedBy,
+      selectCachedArgsForQuery
+    });
+    const {
+      queryThunk,
+      infiniteQueryThunk,
+      mutationThunk,
+      patchQueryData,
+      updateQueryData,
+      upsertQueryData,
+      prefetch,
+      buildMatchThunkActions
+    } = buildThunks({
+      baseQuery,
+      reducerPath,
+      context,
+      api,
+      serializeQueryArgs,
+      assertTagType,
+      selectors,
+      onSchemaFailure,
+      catchSchemaFailure,
+      skipSchemaValidation
+    });
+    const {
+      reducer,
+      actions: sliceActions
+    } = buildSlice({
+      context,
+      queryThunk,
+      infiniteQueryThunk,
+      mutationThunk,
+      serializeQueryArgs,
+      reducerPath,
+      assertTagType,
+      config: {
+        refetchOnFocus,
+        refetchOnReconnect,
+        refetchOnMountOrArgChange,
+        keepUnusedDataFor,
+        reducerPath,
+        invalidationBehavior
+      }
+    });
+    safeAssign(api.util, {
+      patchQueryData,
+      updateQueryData,
+      upsertQueryData,
+      prefetch,
+      resetApiState: sliceActions.resetApiState,
+      upsertQueryEntries: sliceActions.cacheEntriesUpserted
+    });
+    safeAssign(api.internalActions, sliceActions);
+    const {
+      middleware,
+      actions: middlewareActions
+    } = buildMiddleware({
+      reducerPath,
+      context,
+      queryThunk,
+      mutationThunk,
+      infiniteQueryThunk,
+      api,
+      assertTagType,
+      selectors
+    });
+    safeAssign(api.util, middlewareActions);
+    safeAssign(api, {
+      reducer,
+      middleware
+    });
+    const {
+      buildInitiateQuery,
+      buildInitiateInfiniteQuery,
+      buildInitiateMutation,
+      getRunningMutationThunk,
+      getRunningMutationsThunk,
+      getRunningQueriesThunk,
+      getRunningQueryThunk
+    } = buildInitiate({
+      queryThunk,
+      mutationThunk,
+      infiniteQueryThunk,
+      api,
+      serializeQueryArgs,
+      context
+    });
+    safeAssign(api.util, {
+      getRunningMutationThunk,
+      getRunningMutationsThunk,
+      getRunningQueryThunk,
+      getRunningQueriesThunk
+    });
+    return {
+      name: coreModuleName,
+      injectEndpoint(endpointName, definition) {
+        const anyApi = api;
+        const endpoint = anyApi.endpoints[endpointName] ??= {};
+        if (isQueryDefinition(definition)) {
+          safeAssign(endpoint, {
+            name: endpointName,
+            select: buildQuerySelector(endpointName, definition),
+            initiate: buildInitiateQuery(endpointName, definition)
+          }, buildMatchThunkActions(queryThunk, endpointName));
+        }
+        if (isMutationDefinition(definition)) {
+          safeAssign(endpoint, {
+            name: endpointName,
+            select: buildMutationSelector(),
+            initiate: buildInitiateMutation(endpointName)
+          }, buildMatchThunkActions(mutationThunk, endpointName));
+        }
+        if (isInfiniteQueryDefinition(definition)) {
+          safeAssign(endpoint, {
+            name: endpointName,
+            select: buildInfiniteQuerySelector(endpointName, definition),
+            initiate: buildInitiateInfiniteQuery(endpointName, definition)
+          }, buildMatchThunkActions(queryThunk, endpointName));
+        }
+      }
+    };
+  }
+});
+
+// src/query/core/index.ts
+var createApi = /* @__PURE__ */ buildCreateApi(coreModule());
+export {
+  NamedSchemaError,
+  QueryStatus,
+  _NEVER,
+  buildCreateApi,
+  copyWithStructuralSharing,
+  coreModule,
+  coreModuleName,
+  createApi,
+  defaultSerializeQueryArgs,
+  fakeBaseQuery,
+  fetchBaseQuery,
+  retry,
+  setupListeners,
+  skipToken
+};
+//# sourceMappingURL=rtk-query.modern.mjs.map

frontend/node_modules/@reduxjs/toolkit/dist/react/cjs/index.js

@@ -0,0 +1,6 @@
+'use strict'
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./redux-toolkit-react.production.min.cjs')
+} else {
+  module.exports = require('./redux-toolkit-react.development.cjs')
+}

frontend/node_modules/@reduxjs/toolkit/dist/react/cjs/redux-toolkit-react.development.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  createDynamicMiddleware: () => createDynamicMiddleware
+});
+module.exports = __toCommonJS(react_exports);
+__reExport(react_exports, require("@reduxjs/toolkit"), module.exports);
+
+// src/dynamicMiddleware/react/index.ts
+var import_toolkit = require("@reduxjs/toolkit");
+var import_react_redux = require("react-redux");
+var createDynamicMiddleware = () => {
+  const instance = (0, import_toolkit.createDynamicMiddleware)();
+  const createDispatchWithMiddlewareHookFactory = (context = import_react_redux.ReactReduxContext) => {
+    const useDispatch = context === import_react_redux.ReactReduxContext ? import_react_redux.useDispatch : (0, import_react_redux.createDispatchHook)(context);
+    function createDispatchWithMiddlewareHook2(...middlewares) {
+      instance.addMiddleware(...middlewares);
+      return useDispatch;
+    }
+    createDispatchWithMiddlewareHook2.withTypes = () => createDispatchWithMiddlewareHook2;
+    return createDispatchWithMiddlewareHook2;
+  };
+  const createDispatchWithMiddlewareHook = createDispatchWithMiddlewareHookFactory();
+  return {
+    ...instance,
+    createDispatchWithMiddlewareHookFactory,
+    createDispatchWithMiddlewareHook
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDynamicMiddleware,
+  ...require("@reduxjs/toolkit")
+});
+//# sourceMappingURL=redux-toolkit-react.development.cjs.map

frontend/node_modules/@reduxjs/toolkit/dist/react/cjs/redux-toolkit-react.development.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/react/index.ts","../../../src/dynamicMiddleware/react/index.ts"],"sourcesContent":["// This must remain here so that the `mangleErrors.cjs` build script\n// does not have to import this into each source file it rewrites.\nimport { formatProdErrorMessage } from '@reduxjs/toolkit';\nexport * from '@reduxjs/toolkit';\nexport { createDynamicMiddleware } from '../dynamicMiddleware/react';\nexport type { CreateDispatchWithMiddlewareHook } from '../dynamicMiddleware/react/index';","import type { DynamicMiddlewareInstance, GetDispatch, GetState, MiddlewareApiConfig, TSHelpersExtractDispatchExtensions } from '@reduxjs/toolkit';\nimport { createDynamicMiddleware as cDM } from '@reduxjs/toolkit';\nimport type { Context } from 'react';\nimport type { ReactReduxContextValue } from 'react-redux';\nimport { createDispatchHook, ReactReduxContext, useDispatch as useDefaultDispatch } from 'react-redux';\nimport type { Action, Dispatch, Middleware, UnknownAction } from 'redux';\nexport type UseDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[] = [], State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = () => TSHelpersExtractDispatchExtensions<Middlewares> & DispatchType;\nexport type CreateDispatchWithMiddlewareHook<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = {\n  <Middlewares extends [Middleware<any, State, DispatchType>, ...Middleware<any, State, DispatchType>[]]>(...middlewares: Middlewares): UseDispatchWithMiddlewareHook<Middlewares, State, DispatchType>;\n  withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): CreateDispatchWithMiddlewareHook<GetState<MiddlewareConfig>, GetDispatch<MiddlewareConfig>>;\n};\ntype ActionFromDispatch<DispatchType extends Dispatch<Action>> = DispatchType extends Dispatch<infer Action> ? Action : never;\ntype ReactDynamicMiddlewareInstance<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = DynamicMiddlewareInstance<State, DispatchType> & {\n  createDispatchWithMiddlewareHookFactory: (context?: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null>) => CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<State, DispatchType>;\n};\nexport const createDynamicMiddleware = <State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>>(): ReactDynamicMiddlewareInstance<State, DispatchType> => {\n  const instance = cDM<State, DispatchType>();\n  const createDispatchWithMiddlewareHookFactory = (\n  // @ts-ignore\n  context: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null> = ReactReduxContext) => {\n    const useDispatch = context === ReactReduxContext ? useDefaultDispatch : createDispatchHook(context);\n    function createDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[]>(...middlewares: Middlewares) {\n      instance.addMiddleware(...middlewares);\n      return useDispatch;\n    }\n    createDispatchWithMiddlewareHook.withTypes = () => createDispatchWithMiddlewareHook;\n    return createDispatchWithMiddlewareHook as CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  };\n  const createDispatchWithMiddlewareHook = createDispatchWithMiddlewareHookFactory();\n  return {\n    ...instance,\n    createDispatchWithMiddlewareHookFactory,\n    createDispatchWithMiddlewareHook\n  };\n};"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,0BAAc,6BAHd;;;ACCA,qBAA+C;AAG/C,yBAAyF;AAYlF,IAAM,0BAA0B,MAAgJ;AACrL,QAAM,eAAW,eAAAA,yBAAyB;AAC1C,QAAM,0CAA0C,CAEhD,UAA2F,yCAAsB;AAC/G,UAAM,cAAc,YAAY,uCAAoB,mBAAAC,kBAAqB,uCAAmB,OAAO;AACnG,aAASC,qCAAgG,aAA0B;AACjI,eAAS,cAAc,GAAG,WAAW;AACrC,aAAO;AAAA,IACT;AACA,IAAAA,kCAAiC,YAAY,MAAMA;AACnD,WAAOA;AAAA,EACT;AACA,QAAM,mCAAmC,wCAAwC;AACjF,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,EACF;AACF;","names":["cDM","useDefaultDispatch","createDispatchWithMiddlewareHook"]}

frontend/node_modules/@reduxjs/toolkit/dist/react/cjs/redux-toolkit-react.production.min.cjs

@@ -0,0 +1,2 @@
+"use strict";var s=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var x=(t,e)=>{for(var a in e)s(t,a,{get:e[a],enumerable:!0})},d=(t,e,a,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of y(e))!M.call(t,i)&&i!==a&&s(t,i,{get:()=>e[i],enumerable:!(n=w(e,i))||n.enumerable});return t},r=(t,e,a)=>(d(t,e,"default"),a&&d(a,e,"default"));var m=t=>d(s({},"__esModule",{value:!0}),t);var o={};x(o,{createDynamicMiddleware:()=>D});module.exports=m(o);r(o,require("@reduxjs/toolkit"),module.exports);var h=require("@reduxjs/toolkit"),c=require("react-redux"),D=()=>{let t=(0,h.createDynamicMiddleware)(),e=(n=c.ReactReduxContext)=>{let i=n===c.ReactReduxContext?c.useDispatch:(0,c.createDispatchHook)(n);function p(...l){return t.addMiddleware(...l),i}return p.withTypes=()=>p,p},a=e();return{...t,createDispatchWithMiddlewareHookFactory:e,createDispatchWithMiddlewareHook:a}};0&&(module.exports={createDynamicMiddleware,...require("@reduxjs/toolkit")});
+//# sourceMappingURL=redux-toolkit-react.production.min.cjs.map

frontend/node_modules/@reduxjs/toolkit/dist/react/cjs/redux-toolkit-react.production.min.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/react/index.ts","../../../src/dynamicMiddleware/react/index.ts"],"sourcesContent":["// This must remain here so that the `mangleErrors.cjs` build script\n// does not have to import this into each source file it rewrites.\nimport { formatProdErrorMessage } from '@reduxjs/toolkit';\nexport * from '@reduxjs/toolkit';\nexport { createDynamicMiddleware } from '../dynamicMiddleware/react';\nexport type { CreateDispatchWithMiddlewareHook } from '../dynamicMiddleware/react/index';","import type { DynamicMiddlewareInstance, GetDispatch, GetState, MiddlewareApiConfig, TSHelpersExtractDispatchExtensions } from '@reduxjs/toolkit';\nimport { createDynamicMiddleware as cDM } from '@reduxjs/toolkit';\nimport type { Context } from 'react';\nimport type { ReactReduxContextValue } from 'react-redux';\nimport { createDispatchHook, ReactReduxContext, useDispatch as useDefaultDispatch } from 'react-redux';\nimport type { Action, Dispatch, Middleware, UnknownAction } from 'redux';\nexport type UseDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[] = [], State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = () => TSHelpersExtractDispatchExtensions<Middlewares> & DispatchType;\nexport type CreateDispatchWithMiddlewareHook<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = {\n  <Middlewares extends [Middleware<any, State, DispatchType>, ...Middleware<any, State, DispatchType>[]]>(...middlewares: Middlewares): UseDispatchWithMiddlewareHook<Middlewares, State, DispatchType>;\n  withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): CreateDispatchWithMiddlewareHook<GetState<MiddlewareConfig>, GetDispatch<MiddlewareConfig>>;\n};\ntype ActionFromDispatch<DispatchType extends Dispatch<Action>> = DispatchType extends Dispatch<infer Action> ? Action : never;\ntype ReactDynamicMiddlewareInstance<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = DynamicMiddlewareInstance<State, DispatchType> & {\n  createDispatchWithMiddlewareHookFactory: (context?: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null>) => CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<State, DispatchType>;\n};\nexport const createDynamicMiddleware = <State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>>(): ReactDynamicMiddlewareInstance<State, DispatchType> => {\n  const instance = cDM<State, DispatchType>();\n  const createDispatchWithMiddlewareHookFactory = (\n  // @ts-ignore\n  context: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null> = ReactReduxContext) => {\n    const useDispatch = context === ReactReduxContext ? useDefaultDispatch : createDispatchHook(context);\n    function createDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[]>(...middlewares: Middlewares) {\n      instance.addMiddleware(...middlewares);\n      return useDispatch;\n    }\n    createDispatchWithMiddlewareHook.withTypes = () => createDispatchWithMiddlewareHook;\n    return createDispatchWithMiddlewareHook as CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  };\n  const createDispatchWithMiddlewareHook = createDispatchWithMiddlewareHookFactory();\n  return {\n    ...instance,\n    createDispatchWithMiddlewareHookFactory,\n    createDispatchWithMiddlewareHook\n  };\n};"],"mappings":"2dAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,6BAAAE,IAAA,eAAAC,EAAAH,GAGAI,EAAAJ,EAAc,4BAHd,gBCCA,IAAAK,EAA+C,4BAG/CC,EAAyF,uBAY5EC,EAA0B,IAAgJ,CACrL,IAAMC,KAAW,EAAAC,yBAAyB,EACpCC,EAA0C,CAEhDC,EAA2F,sBAAsB,CAC/G,IAAMC,EAAcD,IAAY,oBAAoB,EAAAE,eAAqB,sBAAmBF,CAAO,EACnG,SAASG,KAAgGC,EAA0B,CACjI,OAAAP,EAAS,cAAc,GAAGO,CAAW,EAC9BH,CACT,CACA,OAAAE,EAAiC,UAAY,IAAMA,EAC5CA,CACT,EACMA,EAAmCJ,EAAwC,EACjF,MAAO,CACL,GAAGF,EACH,wCAAAE,EACA,iCAAAI,CACF,CACF","names":["react_exports","__export","createDynamicMiddleware","__toCommonJS","__reExport","import_toolkit","import_react_redux","createDynamicMiddleware","instance","cDM","createDispatchWithMiddlewareHookFactory","context","useDispatch","useDefaultDispatch","createDispatchWithMiddlewareHook","middlewares"]}

frontend/node_modules/@reduxjs/toolkit/dist/react/index.d.mts

@@ -0,0 +1,22 @@
+import { DynamicMiddlewareInstance, TSHelpersExtractDispatchExtensions, MiddlewareApiConfig, GetState, GetDispatch } from '@reduxjs/toolkit';
+export * from '@reduxjs/toolkit';
+import { Context } from 'react';
+import { ReactReduxContextValue } from 'react-redux';
+import { Dispatch, UnknownAction, Action, Middleware } from 'redux';
+
+type UseDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[] = [], State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = () => TSHelpersExtractDispatchExtensions<Middlewares> & DispatchType;
+type CreateDispatchWithMiddlewareHook<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = {
+    <Middlewares extends [
+        Middleware<any, State, DispatchType>,
+        ...Middleware<any, State, DispatchType>[]
+    ]>(...middlewares: Middlewares): UseDispatchWithMiddlewareHook<Middlewares, State, DispatchType>;
+    withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): CreateDispatchWithMiddlewareHook<GetState<MiddlewareConfig>, GetDispatch<MiddlewareConfig>>;
+};
+type ActionFromDispatch<DispatchType extends Dispatch<Action>> = DispatchType extends Dispatch<infer Action> ? Action : never;
+type ReactDynamicMiddlewareInstance<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = DynamicMiddlewareInstance<State, DispatchType> & {
+    createDispatchWithMiddlewareHookFactory: (context?: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null>) => CreateDispatchWithMiddlewareHook<State, DispatchType>;
+    createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<State, DispatchType>;
+};
+declare const createDynamicMiddleware: <State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>>() => ReactDynamicMiddlewareInstance<State, DispatchType>;
+
+export { type CreateDispatchWithMiddlewareHook, createDynamicMiddleware };

frontend/node_modules/@reduxjs/toolkit/dist/react/index.d.ts

@@ -0,0 +1,22 @@
+import { DynamicMiddlewareInstance, TSHelpersExtractDispatchExtensions, MiddlewareApiConfig, GetState, GetDispatch } from '@reduxjs/toolkit';
+export * from '@reduxjs/toolkit';
+import { Context } from 'react';
+import { ReactReduxContextValue } from 'react-redux';
+import { Dispatch, UnknownAction, Action, Middleware } from 'redux';
+
+type UseDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[] = [], State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = () => TSHelpersExtractDispatchExtensions<Middlewares> & DispatchType;
+type CreateDispatchWithMiddlewareHook<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = {
+    <Middlewares extends [
+        Middleware<any, State, DispatchType>,
+        ...Middleware<any, State, DispatchType>[]
+    ]>(...middlewares: Middlewares): UseDispatchWithMiddlewareHook<Middlewares, State, DispatchType>;
+    withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): CreateDispatchWithMiddlewareHook<GetState<MiddlewareConfig>, GetDispatch<MiddlewareConfig>>;
+};
+type ActionFromDispatch<DispatchType extends Dispatch<Action>> = DispatchType extends Dispatch<infer Action> ? Action : never;
+type ReactDynamicMiddlewareInstance<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = DynamicMiddlewareInstance<State, DispatchType> & {
+    createDispatchWithMiddlewareHookFactory: (context?: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null>) => CreateDispatchWithMiddlewareHook<State, DispatchType>;
+    createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<State, DispatchType>;
+};
+declare const createDynamicMiddleware: <State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>>() => ReactDynamicMiddlewareInstance<State, DispatchType>;
+
+export { type CreateDispatchWithMiddlewareHook, createDynamicMiddleware };

frontend/node_modules/@reduxjs/toolkit/dist/react/redux-toolkit-react.browser.mjs

@@ -0,0 +1,2 @@
+export*from"@reduxjs/toolkit";import{createDynamicMiddleware as p}from"@reduxjs/toolkit";import{createDispatchHook as d,ReactReduxContext as c,useDispatch as s}from"react-redux";var h=()=>{let t=p(),a=(i=c)=>{let o=i===c?s:d(i);function e(...r){return t.addMiddleware(...r),o}return e.withTypes=()=>e,e},n=a();return{...t,createDispatchWithMiddlewareHookFactory:a,createDispatchWithMiddlewareHook:n}};export{h as createDynamicMiddleware};
+//# sourceMappingURL=redux-toolkit-react.browser.mjs.map

frontend/node_modules/@reduxjs/toolkit/dist/react/redux-toolkit-react.browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/index.ts","../../src/dynamicMiddleware/react/index.ts"],"sourcesContent":["// This must remain here so that the `mangleErrors.cjs` build script\n// does not have to import this into each source file it rewrites.\nimport { formatProdErrorMessage } from '@reduxjs/toolkit';\nexport * from '@reduxjs/toolkit';\nexport { createDynamicMiddleware } from '../dynamicMiddleware/react';\nexport type { CreateDispatchWithMiddlewareHook } from '../dynamicMiddleware/react/index';","import type { DynamicMiddlewareInstance, GetDispatch, GetState, MiddlewareApiConfig, TSHelpersExtractDispatchExtensions } from '@reduxjs/toolkit';\nimport { createDynamicMiddleware as cDM } from '@reduxjs/toolkit';\nimport type { Context } from 'react';\nimport type { ReactReduxContextValue } from 'react-redux';\nimport { createDispatchHook, ReactReduxContext, useDispatch as useDefaultDispatch } from 'react-redux';\nimport type { Action, Dispatch, Middleware, UnknownAction } from 'redux';\nexport type UseDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[] = [], State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = () => TSHelpersExtractDispatchExtensions<Middlewares> & DispatchType;\nexport type CreateDispatchWithMiddlewareHook<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = {\n  <Middlewares extends [Middleware<any, State, DispatchType>, ...Middleware<any, State, DispatchType>[]]>(...middlewares: Middlewares): UseDispatchWithMiddlewareHook<Middlewares, State, DispatchType>;\n  withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): CreateDispatchWithMiddlewareHook<GetState<MiddlewareConfig>, GetDispatch<MiddlewareConfig>>;\n};\ntype ActionFromDispatch<DispatchType extends Dispatch<Action>> = DispatchType extends Dispatch<infer Action> ? Action : never;\ntype ReactDynamicMiddlewareInstance<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = DynamicMiddlewareInstance<State, DispatchType> & {\n  createDispatchWithMiddlewareHookFactory: (context?: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null>) => CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<State, DispatchType>;\n};\nexport const createDynamicMiddleware = <State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>>(): ReactDynamicMiddlewareInstance<State, DispatchType> => {\n  const instance = cDM<State, DispatchType>();\n  const createDispatchWithMiddlewareHookFactory = (\n  // @ts-ignore\n  context: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null> = ReactReduxContext) => {\n    const useDispatch = context === ReactReduxContext ? useDefaultDispatch : createDispatchHook(context);\n    function createDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[]>(...middlewares: Middlewares) {\n      instance.addMiddleware(...middlewares);\n      return useDispatch;\n    }\n    createDispatchWithMiddlewareHook.withTypes = () => createDispatchWithMiddlewareHook;\n    return createDispatchWithMiddlewareHook as CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  };\n  const createDispatchWithMiddlewareHook = createDispatchWithMiddlewareHookFactory();\n  return {\n    ...instance,\n    createDispatchWithMiddlewareHookFactory,\n    createDispatchWithMiddlewareHook\n  };\n};"],"mappings":"AAGA,WAAc,mBCFd,OAAS,2BAA2BA,MAAW,mBAG/C,OAAS,sBAAAC,EAAoB,qBAAAC,EAAmB,eAAeC,MAA0B,cAYlF,IAAMC,EAA0B,IAAgJ,CACrL,IAAMC,EAAWL,EAAyB,EACpCM,EAA0C,CAEhDC,EAA2FL,IAAsB,CAC/G,IAAMM,EAAcD,IAAYL,EAAoBC,EAAqBF,EAAmBM,CAAO,EACnG,SAASE,KAAgGC,EAA0B,CACjI,OAAAL,EAAS,cAAc,GAAGK,CAAW,EAC9BF,CACT,CACA,OAAAC,EAAiC,UAAY,IAAMA,EAC5CA,CACT,EACMA,EAAmCH,EAAwC,EACjF,MAAO,CACL,GAAGD,EACH,wCAAAC,EACA,iCAAAG,CACF,CACF","names":["cDM","createDispatchHook","ReactReduxContext","useDefaultDispatch","createDynamicMiddleware","instance","createDispatchWithMiddlewareHookFactory","context","useDispatch","createDispatchWithMiddlewareHook","middlewares"]}

frontend/node_modules/@reduxjs/toolkit/dist/react/redux-toolkit-react.legacy-esm.js

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/react/index.ts
+export * from "@reduxjs/toolkit";
+
+// src/dynamicMiddleware/react/index.ts
+import { createDynamicMiddleware as cDM } from "@reduxjs/toolkit";
+import { createDispatchHook, ReactReduxContext, useDispatch as useDefaultDispatch } from "react-redux";
+var createDynamicMiddleware = () => {
+  const instance = cDM();
+  const createDispatchWithMiddlewareHookFactory = (context = ReactReduxContext) => {
+    const useDispatch = context === ReactReduxContext ? useDefaultDispatch : createDispatchHook(context);
+    function createDispatchWithMiddlewareHook2(...middlewares) {
+      instance.addMiddleware(...middlewares);
+      return useDispatch;
+    }
+    createDispatchWithMiddlewareHook2.withTypes = () => createDispatchWithMiddlewareHook2;
+    return createDispatchWithMiddlewareHook2;
+  };
+  const createDispatchWithMiddlewareHook = createDispatchWithMiddlewareHookFactory();
+  return __spreadProps(__spreadValues({}, instance), {
+    createDispatchWithMiddlewareHookFactory,
+    createDispatchWithMiddlewareHook
+  });
+};
+export {
+  createDynamicMiddleware
+};
+//# sourceMappingURL=redux-toolkit-react.legacy-esm.js.map

frontend/node_modules/@reduxjs/toolkit/dist/react/redux-toolkit-react.legacy-esm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/index.ts","../../src/dynamicMiddleware/react/index.ts"],"sourcesContent":["// This must remain here so that the `mangleErrors.cjs` build script\n// does not have to import this into each source file it rewrites.\nimport { formatProdErrorMessage } from '@reduxjs/toolkit';\nexport * from '@reduxjs/toolkit';\nexport { createDynamicMiddleware } from '../dynamicMiddleware/react';\nexport type { CreateDispatchWithMiddlewareHook } from '../dynamicMiddleware/react/index';","import type { DynamicMiddlewareInstance, GetDispatch, GetState, MiddlewareApiConfig, TSHelpersExtractDispatchExtensions } from '@reduxjs/toolkit';\nimport { createDynamicMiddleware as cDM } from '@reduxjs/toolkit';\nimport type { Context } from 'react';\nimport type { ReactReduxContextValue } from 'react-redux';\nimport { createDispatchHook, ReactReduxContext, useDispatch as useDefaultDispatch } from 'react-redux';\nimport type { Action, Dispatch, Middleware, UnknownAction } from 'redux';\nexport type UseDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[] = [], State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = () => TSHelpersExtractDispatchExtensions<Middlewares> & DispatchType;\nexport type CreateDispatchWithMiddlewareHook<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = {\n  <Middlewares extends [Middleware<any, State, DispatchType>, ...Middleware<any, State, DispatchType>[]]>(...middlewares: Middlewares): UseDispatchWithMiddlewareHook<Middlewares, State, DispatchType>;\n  withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): CreateDispatchWithMiddlewareHook<GetState<MiddlewareConfig>, GetDispatch<MiddlewareConfig>>;\n};\ntype ActionFromDispatch<DispatchType extends Dispatch<Action>> = DispatchType extends Dispatch<infer Action> ? Action : never;\ntype ReactDynamicMiddlewareInstance<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = DynamicMiddlewareInstance<State, DispatchType> & {\n  createDispatchWithMiddlewareHookFactory: (context?: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null>) => CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<State, DispatchType>;\n};\nexport const createDynamicMiddleware = <State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>>(): ReactDynamicMiddlewareInstance<State, DispatchType> => {\n  const instance = cDM<State, DispatchType>();\n  const createDispatchWithMiddlewareHookFactory = (\n  // @ts-ignore\n  context: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null> = ReactReduxContext) => {\n    const useDispatch = context === ReactReduxContext ? useDefaultDispatch : createDispatchHook(context);\n    function createDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[]>(...middlewares: Middlewares) {\n      instance.addMiddleware(...middlewares);\n      return useDispatch;\n    }\n    createDispatchWithMiddlewareHook.withTypes = () => createDispatchWithMiddlewareHook;\n    return createDispatchWithMiddlewareHook as CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  };\n  const createDispatchWithMiddlewareHook = createDispatchWithMiddlewareHookFactory();\n  return {\n    ...instance,\n    createDispatchWithMiddlewareHookFactory,\n    createDispatchWithMiddlewareHook\n  };\n};"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAGA,cAAc;;;ACFd,SAAS,2BAA2B,WAAW;AAG/C,SAAS,oBAAoB,mBAAmB,eAAe,0BAA0B;AAYlF,IAAM,0BAA0B,MAAgJ;AACrL,QAAM,WAAW,IAAyB;AAC1C,QAAM,0CAA0C,CAEhD,UAA2F,sBAAsB;AAC/G,UAAM,cAAc,YAAY,oBAAoB,qBAAqB,mBAAmB,OAAO;AACnG,aAASA,qCAAgG,aAA0B;AACjI,eAAS,cAAc,GAAG,WAAW;AACrC,aAAO;AAAA,IACT;AACA,IAAAA,kCAAiC,YAAY,MAAMA;AACnD,WAAOA;AAAA,EACT;AACA,QAAM,mCAAmC,wCAAwC;AACjF,SAAO,iCACF,WADE;AAAA,IAEL;AAAA,IACA;AAAA,EACF;AACF;","names":["createDispatchWithMiddlewareHook"]}

frontend/node_modules/@reduxjs/toolkit/dist/react/redux-toolkit-react.modern.mjs

@@ -0,0 +1,28 @@
+// src/react/index.ts
+export * from "@reduxjs/toolkit";
+
+// src/dynamicMiddleware/react/index.ts
+import { createDynamicMiddleware as cDM } from "@reduxjs/toolkit";
+import { createDispatchHook, ReactReduxContext, useDispatch as useDefaultDispatch } from "react-redux";
+var createDynamicMiddleware = () => {
+  const instance = cDM();
+  const createDispatchWithMiddlewareHookFactory = (context = ReactReduxContext) => {
+    const useDispatch = context === ReactReduxContext ? useDefaultDispatch : createDispatchHook(context);
+    function createDispatchWithMiddlewareHook2(...middlewares) {
+      instance.addMiddleware(...middlewares);
+      return useDispatch;
+    }
+    createDispatchWithMiddlewareHook2.withTypes = () => createDispatchWithMiddlewareHook2;
+    return createDispatchWithMiddlewareHook2;
+  };
+  const createDispatchWithMiddlewareHook = createDispatchWithMiddlewareHookFactory();
+  return {
+    ...instance,
+    createDispatchWithMiddlewareHookFactory,
+    createDispatchWithMiddlewareHook
+  };
+};
+export {
+  createDynamicMiddleware
+};
+//# sourceMappingURL=redux-toolkit-react.modern.mjs.map

frontend/node_modules/@reduxjs/toolkit/dist/react/redux-toolkit-react.modern.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/index.ts","../../src/dynamicMiddleware/react/index.ts"],"sourcesContent":["// This must remain here so that the `mangleErrors.cjs` build script\n// does not have to import this into each source file it rewrites.\nimport { formatProdErrorMessage } from '@reduxjs/toolkit';\nexport * from '@reduxjs/toolkit';\nexport { createDynamicMiddleware } from '../dynamicMiddleware/react';\nexport type { CreateDispatchWithMiddlewareHook } from '../dynamicMiddleware/react/index';","import type { DynamicMiddlewareInstance, GetDispatch, GetState, MiddlewareApiConfig, TSHelpersExtractDispatchExtensions } from '@reduxjs/toolkit';\nimport { createDynamicMiddleware as cDM } from '@reduxjs/toolkit';\nimport type { Context } from 'react';\nimport type { ReactReduxContextValue } from 'react-redux';\nimport { createDispatchHook, ReactReduxContext, useDispatch as useDefaultDispatch } from 'react-redux';\nimport type { Action, Dispatch, Middleware, UnknownAction } from 'redux';\nexport type UseDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[] = [], State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = () => TSHelpersExtractDispatchExtensions<Middlewares> & DispatchType;\nexport type CreateDispatchWithMiddlewareHook<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = {\n  <Middlewares extends [Middleware<any, State, DispatchType>, ...Middleware<any, State, DispatchType>[]]>(...middlewares: Middlewares): UseDispatchWithMiddlewareHook<Middlewares, State, DispatchType>;\n  withTypes<MiddlewareConfig extends MiddlewareApiConfig>(): CreateDispatchWithMiddlewareHook<GetState<MiddlewareConfig>, GetDispatch<MiddlewareConfig>>;\n};\ntype ActionFromDispatch<DispatchType extends Dispatch<Action>> = DispatchType extends Dispatch<infer Action> ? Action : never;\ntype ReactDynamicMiddlewareInstance<State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>> = DynamicMiddlewareInstance<State, DispatchType> & {\n  createDispatchWithMiddlewareHookFactory: (context?: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null>) => CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  createDispatchWithMiddlewareHook: CreateDispatchWithMiddlewareHook<State, DispatchType>;\n};\nexport const createDynamicMiddleware = <State = any, DispatchType extends Dispatch<UnknownAction> = Dispatch<UnknownAction>>(): ReactDynamicMiddlewareInstance<State, DispatchType> => {\n  const instance = cDM<State, DispatchType>();\n  const createDispatchWithMiddlewareHookFactory = (\n  // @ts-ignore\n  context: Context<ReactReduxContextValue<State, ActionFromDispatch<DispatchType>> | null> = ReactReduxContext) => {\n    const useDispatch = context === ReactReduxContext ? useDefaultDispatch : createDispatchHook(context);\n    function createDispatchWithMiddlewareHook<Middlewares extends Middleware<any, State, DispatchType>[]>(...middlewares: Middlewares) {\n      instance.addMiddleware(...middlewares);\n      return useDispatch;\n    }\n    createDispatchWithMiddlewareHook.withTypes = () => createDispatchWithMiddlewareHook;\n    return createDispatchWithMiddlewareHook as CreateDispatchWithMiddlewareHook<State, DispatchType>;\n  };\n  const createDispatchWithMiddlewareHook = createDispatchWithMiddlewareHookFactory();\n  return {\n    ...instance,\n    createDispatchWithMiddlewareHookFactory,\n    createDispatchWithMiddlewareHook\n  };\n};"],"mappings":";AAGA,cAAc;;;ACFd,SAAS,2BAA2B,WAAW;AAG/C,SAAS,oBAAoB,mBAAmB,eAAe,0BAA0B;AAYlF,IAAM,0BAA0B,MAAgJ;AACrL,QAAM,WAAW,IAAyB;AAC1C,QAAM,0CAA0C,CAEhD,UAA2F,sBAAsB;AAC/G,UAAM,cAAc,YAAY,oBAAoB,qBAAqB,mBAAmB,OAAO;AACnG,aAASA,qCAAgG,aAA0B;AACjI,eAAS,cAAc,GAAG,WAAW;AACrC,aAAO;AAAA,IACT;AACA,IAAAA,kCAAiC,YAAY,MAAMA;AACnD,WAAOA;AAAA,EACT;AACA,QAAM,mCAAmC,wCAAwC;AACjF,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,IACA;AAAA,EACF;AACF;","names":["createDispatchWithMiddlewareHook"]}

frontend/node_modules/@reduxjs/toolkit/dist/redux-toolkit.browser.mjs

@@ -0,0 +1,3 @@
+export*from"redux";import{produce as Io,current as vo,freeze as Do,original as Oo,isDraft as No}from"immer";import{createSelector as Fo,createSelectorCreator as Vo,lruMemoize as _o,weakMapMemoize as Lo}from"reselect";import{current as at,isDraft as it}from"immer";import{createSelectorCreator as st,weakMapMemoize as ct}from"reselect";var xe=(...e)=>{let t=st(...e),r=Object.assign((...n)=>{let o=t(...n),a=(s,...y)=>o(it(s)?at(s):s,...y);return Object.assign(a,o),a},{withTypes:()=>r});return r},ie=xe(ct);import{applyMiddleware as xt,createStore as Ct,compose as Et,combineReducers as Rt,isPlainObject as wt}from"redux";import{compose as Ce}from"redux";var Ee=typeof window<"u"&&window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__?window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__:function(){if(arguments.length!==0)return typeof arguments[0]=="object"?Ce:Ce.apply(null,arguments)},Rn=typeof window<"u"&&window.__REDUX_DEVTOOLS_EXTENSION__?window.__REDUX_DEVTOOLS_EXTENSION__:function(){return function(e){return e}};import{thunk as mt,withExtraArgument as gt}from"redux-thunk";import{isAction as Re}from"redux";var q=e=>e&&typeof e.match=="function";function M(e,t){function r(...n){if(t){let o=t(...n);if(!o)throw new Error(x(0));return{type:e,payload:o.payload,..."meta"in o&&{meta:o.meta},..."error"in o&&{error:o.error}}}return{type:e,payload:n[0]}}return r.toString=()=>`${e}`,r.type=e,r.match=n=>Re(n)&&n.type===e,r}function se(e){return typeof e=="function"&&"type"in e&&q(e)}function ce(e){return Re(e)&&Object.keys(e).every(dt)}function dt(e){return["type","payload","error","meta"].indexOf(e)>-1}function ut(e){let t=e?`${e}`.split("/"):[],r=t[t.length-1]||"actionCreator";return`Detected an action creator with type "${e||"unknown"}" being dispatched. 
+Make sure you're calling the action creator before dispatching, i.e. \`dispatch(${r}())\` instead of \`dispatch(${r})\`. This is necessary even if the action has no payload.`}function lt(e={}){return()=>r=>n=>r(n)}import{produce as pt,isDraftable as ft}from"immer";var F=class e extends Array{constructor(...t){super(...t),Object.setPrototypeOf(this,e.prototype)}static get[Symbol.species](){return e}concat(...t){return super.concat.apply(this,t)}prepend(...t){return t.length===1&&Array.isArray(t[0])?new e(...t[0].concat(this)):new e(...t.concat(this))}};function de(e){return ft(e)?pt(e,()=>{}):e}function P(e,t,r){return e.has(t)?e.get(t):e.set(t,r(t)).get(t)}function yt(e){return typeof e!="object"||e==null||Object.isFrozen(e)}function ht(e={}){if(1)return()=>n=>o=>n(o);var t,r}import{isPlainObject as At}from"redux";function we(e){let t=typeof e;return e==null||t==="string"||t==="boolean"||t==="number"||Array.isArray(e)||At(e)}function Me(e,t="",r=we,n,o=[],a){let s;if(!r(e))return{keyPath:t||"<root>",value:e};if(typeof e!="object"||e===null||a?.has(e))return!1;let y=n!=null?n(e):Object.entries(e),c=o.length>0;for(let[l,i]of y){let d=t?t+"."+l:l;if(!(c&&o.some(g=>g instanceof RegExp?g.test(d):d===g))){if(!r(i))return{keyPath:d,value:i};if(typeof i=="object"&&(s=Me(i,d,r,n,o,a),s))return s}}return a&&Pe(e)&&a.add(e),!1}function Pe(e){if(!Object.isFrozen(e))return!1;for(let t of Object.values(e))if(!(typeof t!="object"||t===null)&&!Pe(t))return!1;return!0}function Tt(e={}){return()=>t=>r=>t(r)}function St(e){return typeof e=="boolean"}var be=()=>function(t){let{thunk:r=!0,immutableCheck:n=!0,serializableCheck:o=!0,actionCreatorCheck:a=!0}=t??{},s=new F;return r&&(St(r)?s.push(mt):s.push(gt(r.extraArgument))),s};var ue="RTK_autoBatch",kt=()=>e=>({payload:e,meta:{[ue]:!0}}),Ie=e=>t=>{setTimeout(t,e)},le=(e={type:"raf"})=>t=>(...r)=>{let n=t(...r),o=!0,a=!1,s=!1,y=new Set,c=e.type==="tick"?queueMicrotask:e.type==="raf"?typeof window<"u"&&window.requestAnimationFrame?window.requestAnimationFrame:Ie(10):e.type==="callback"?e.queueNotification:Ie(e.timeout),l=()=>{s=!1,a&&(a=!1,y.forEach(i=>i()))};return Object.assign({},n,{subscribe(i){let d=()=>o&&i(),T=n.subscribe(d);return y.add(i),()=>{T(),y.delete(i)}},dispatch(i){try{return o=!i?.meta?.[ue],a=!o,a&&(s||(s=!0,c(l))),n.dispatch(i)}finally{o=!0}}})};var ve=e=>function(r){let{autoBatch:n=!0}=r??{},o=new F(e);return n&&o.push(le(typeof n=="object"?n:void 0)),o};function Mt(e){let t=be(),{reducer:r=void 0,middleware:n,devTools:o=!0,duplicateMiddlewareCheck:a=!0,preloadedState:s=void 0,enhancers:y=void 0}=e||{},c;if(typeof r=="function")c=r;else if(wt(r))c=Rt(r);else throw new Error(x(1));let l;typeof n=="function"?l=n(t):l=t();let i=Et;o&&(i=Ee({trace:!1,...typeof o=="object"&&o}));let d=xt(...l),T=ve(d),g=typeof y=="function"?y(T):T(),p=i(...g);return Ct(c,s,p)}import{produce as Pt,isDraft as bt,isDraftable as It}from"immer";function $(e){let t={},r=[],n,o={addCase(a,s){let y=typeof a=="string"?a:a.type;if(!y)throw new Error(x(28));if(y in t)throw new Error(x(29));return t[y]=s,o},addMatcher(a,s){return r.push({matcher:a,reducer:s}),o},addDefaultCase(a){return n=a,o}};return e(o),[t,r,n]}function vt(e){return typeof e=="function"}function pe(e,t){let[r,n,o]=$(t),a;if(vt(e))a=()=>de(e());else{let y=de(e);a=()=>y}function s(y=a(),c){let l=[r[c.type],...n.filter(({matcher:i})=>i(c)).map(({reducer:i})=>i)];return l.filter(i=>!!i).length===0&&(l=[o]),l.reduce((i,d)=>{if(d)if(bt(i)){let g=d(i,c);return g===void 0?i:g}else{if(It(i))return Pt(i,T=>d(T,c));{let T=d(i,c);if(T===void 0){if(i===null)return i;throw Error("A case reducer on a non-draftable value must not return undefined")}return T}}return i},y)}return s.getInitialState=a,s}var De=(e,t)=>q(e)?e.match(t):e(t);function V(...e){return t=>e.some(r=>De(r,t))}function W(...e){return t=>e.every(r=>De(r,t))}function J(e,t){if(!e||!e.meta)return!1;let r=typeof e.meta.requestId=="string",n=t.indexOf(e.meta.requestStatus)>-1;return r&&n}function z(e){return typeof e[0]=="function"&&"pending"in e[0]&&"fulfilled"in e[0]&&"rejected"in e[0]}function Oe(...e){return e.length===0?t=>J(t,["pending"]):z(e)?V(...e.map(t=>t.pending)):Oe()(e[0])}function X(...e){return e.length===0?t=>J(t,["rejected"]):z(e)?V(...e.map(t=>t.rejected)):X()(e[0])}function Ne(...e){let t=r=>r&&r.meta&&r.meta.rejectedWithValue;return e.length===0?W(X(...e),t):z(e)?W(X(...e),t):Ne()(e[0])}function je(...e){return e.length===0?t=>J(t,["fulfilled"]):z(e)?V(...e.map(t=>t.fulfilled)):je()(e[0])}function Fe(...e){return e.length===0?t=>J(t,["pending","fulfilled","rejected"]):z(e)?V(...e.flatMap(t=>[t.pending,t.rejected,t.fulfilled])):Fe()(e[0])}var Dt="ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW",I=(e=21)=>{let t="",r=e;for(;r--;)t+=Dt[Math.random()*64|0];return t};var Ot=["name","message","stack","code"],G=class{constructor(t,r){this.payload=t;this.meta=r}_type},Q=class{constructor(t,r){this.payload=t;this.meta=r}_type},_e=e=>{if(typeof e=="object"&&e!==null){let t={};for(let r of Ot)typeof e[r]=="string"&&(t[r]=e[r]);return t}return{message:String(e)}},Ve="External signal was aborted",fe=(()=>{function e(t,r,n){let o=M(t+"/fulfilled",(c,l,i,d)=>({payload:c,meta:{...d||{},arg:i,requestId:l,requestStatus:"fulfilled"}})),a=M(t+"/pending",(c,l,i)=>({payload:void 0,meta:{...i||{},arg:l,requestId:c,requestStatus:"pending"}})),s=M(t+"/rejected",(c,l,i,d,T)=>({payload:d,error:(n&&n.serializeError||_e)(c||"Rejected"),meta:{...T||{},arg:i,requestId:l,rejectedWithValue:!!d,requestStatus:"rejected",aborted:c?.name==="AbortError",condition:c?.name==="ConditionError"}}));function y(c,{signal:l}={}){return(i,d,T)=>{let g=n?.idGenerator?n.idGenerator(c):I(),p=new AbortController,h,u;function f(A){u=A,p.abort()}l&&(l.aborted?f(Ve):l.addEventListener("abort",()=>f(Ve),{once:!0}));let k=async function(){let A;try{let S=n?.condition?.(c,{getState:d,extra:T});if(Nt(S)&&(S=await S),S===!1||p.signal.aborted)throw{name:"ConditionError",message:"Aborted due to condition callback returning false."};let w=new Promise((C,E)=>{h=()=>{E({name:"AbortError",message:u||"Aborted"})},p.signal.addEventListener("abort",h)});i(a(g,c,n?.getPendingMeta?.({requestId:g,arg:c},{getState:d,extra:T}))),A=await Promise.race([w,Promise.resolve(r(c,{dispatch:i,getState:d,extra:T,requestId:g,signal:p.signal,abort:f,rejectWithValue:(C,E)=>new G(C,E),fulfillWithValue:(C,E)=>new Q(C,E)})).then(C=>{if(C instanceof G)throw C;return C instanceof Q?o(C.payload,g,c,C.meta):o(C,g,c)})])}catch(S){A=S instanceof G?s(null,g,c,S.payload,S.meta):s(S,g,c)}finally{h&&p.signal.removeEventListener("abort",h)}return n&&!n.dispatchConditionRejection&&s.match(A)&&A.meta.condition||i(A),A}();return Object.assign(k,{abort:f,requestId:g,arg:c,unwrap(){return k.then(Le)}})}}return Object.assign(y,{pending:a,rejected:s,fulfilled:o,settled:V(s,o),typePrefix:t})}return e.withTypes=()=>e,e})();function Le(e){if(e.meta&&e.meta.rejectedWithValue)throw e.payload;if(e.error)throw e.error;return e.payload}function Nt(e){return e!==null&&typeof e=="object"&&typeof e.then=="function"}var Ue=Symbol.for("rtk-slice-createasyncthunk"),jt={[Ue]:fe},We=(n=>(n.reducer="reducer",n.reducerWithPrepare="reducerWithPrepare",n.asyncThunk="asyncThunk",n))(We||{});function Ft(e,t){return`${e}/${t}`}function ze({creators:e}={}){let t=e?.asyncThunk?.[Ue];return function(n){let{name:o,reducerPath:a=o}=n;if(!o)throw new Error(x(11));let s=(typeof n.reducers=="function"?n.reducers(Lt()):n.reducers)||{},y=Object.keys(s),c={sliceCaseReducersByName:{},sliceCaseReducersByType:{},actionCreators:{},sliceMatchers:[]},l={addCase(A,m){let S=typeof A=="string"?A:A.type;if(!S)throw new Error(x(12));if(S in c.sliceCaseReducersByType)throw new Error(x(13));return c.sliceCaseReducersByType[S]=m,l},addMatcher(A,m){return c.sliceMatchers.push({matcher:A,reducer:m}),l},exposeAction(A,m){return c.actionCreators[A]=m,l},exposeCaseReducer(A,m){return c.sliceCaseReducersByName[A]=m,l}};y.forEach(A=>{let m=s[A],S={reducerName:A,type:Ft(o,A),createNotation:typeof n.reducers=="function"};Wt(m)?Gt(S,m,l,t):Ut(S,m,l)});function i(){let[A={},m=[],S=void 0]=typeof n.extraReducers=="function"?$(n.extraReducers):[n.extraReducers],w={...A,...c.sliceCaseReducersByType};return pe(n.initialState,C=>{for(let E in w)C.addCase(E,w[E]);for(let E of c.sliceMatchers)C.addMatcher(E.matcher,E.reducer);for(let E of m)C.addMatcher(E.matcher,E.reducer);S&&C.addDefaultCase(S)})}let d=A=>A,T=new Map,g=new WeakMap,p;function h(A,m){return p||(p=i()),p(A,m)}function u(){return p||(p=i()),p.getInitialState()}function f(A,m=!1){function S(C){let E=C[A];return typeof E>"u"&&m&&(E=P(g,S,u)),E}function w(C=d){let E=P(T,m,()=>new WeakMap);return P(E,C,()=>{let U={};for(let[H,j]of Object.entries(n.selectors??{}))U[H]=Vt(j,C,()=>P(g,C,u),m);return U})}return{reducerPath:A,getSelectors:w,get selectors(){return w(S)},selectSlice:S}}let k={name:o,reducer:h,actions:c.actionCreators,caseReducers:c.sliceCaseReducersByName,getInitialState:u,...f(a),injectInto(A,{reducerPath:m,...S}={}){let w=m??a;return A.inject({reducerPath:w,reducer:h},S),{...k,...f(w,!0)}}};return k}}function Vt(e,t,r,n){function o(a,...s){let y=t(a);return typeof y>"u"&&n&&(y=r()),e(y,...s)}return o.unwrapped=e,o}var _t=ze();function Lt(){function e(t,r){return{_reducerDefinitionType:"asyncThunk",payloadCreator:t,...r}}return e.withTypes=()=>e,{reducer(t){return Object.assign({[t.name](...r){return t(...r)}}[t.name],{_reducerDefinitionType:"reducer"})},preparedReducer(t,r){return{_reducerDefinitionType:"reducerWithPrepare",prepare:t,reducer:r}},asyncThunk:e}}function Ut({type:e,reducerName:t,createNotation:r},n,o){let a,s;if("reducer"in n){if(r&&!zt(n))throw new Error(x(17));a=n.reducer,s=n.prepare}else a=n;o.addCase(e,a).exposeCaseReducer(t,a).exposeAction(t,s?M(e,s):M(e))}function Wt(e){return e._reducerDefinitionType==="asyncThunk"}function zt(e){return e._reducerDefinitionType==="reducerWithPrepare"}function Gt({type:e,reducerName:t},r,n,o){if(!o)throw new Error(x(18));let{payloadCreator:a,fulfilled:s,pending:y,rejected:c,settled:l,options:i}=r,d=o(e,a,i);n.exposeAction(t,d),s&&n.addCase(d.fulfilled,s),y&&n.addCase(d.pending,y),c&&n.addCase(d.rejected,c),l&&n.addMatcher(d.settled,l),n.exposeCaseReducer(t,{fulfilled:s||Y,pending:y||Y,rejected:c||Y,settled:l||Y})}function Y(){}function Bt(){return{ids:[],entities:{}}}function Ge(e){function t(r={},n){let o=Object.assign(Bt(),r);return n?e.setAll(o,n):o}return{getInitialState:t}}function Be(){function e(t,r={}){let{createSelector:n=ie}=r,o=d=>d.ids,a=d=>d.entities,s=n(o,a,(d,T)=>d.map(g=>T[g])),y=(d,T)=>T,c=(d,T)=>d[T],l=n(o,d=>d.length);if(!t)return{selectIds:o,selectEntities:a,selectAll:s,selectTotal:l,selectById:n(a,y,c)};let i=n(t,a);return{selectIds:n(t,o),selectEntities:i,selectAll:n(t,s),selectTotal:n(t,l),selectById:n(i,y,c)}}return{getSelectors:e}}import{produce as Kt,isDraft as Ht}from"immer";var qt=Ht;function Ke(e){let t=R((r,n)=>e(n));return function(n){return t(n,void 0)}}function R(e){return function(r,n){function o(s){return ce(s)}let a=s=>{o(n)?e(n.payload,s):e(n,s)};return qt(r)?(a(r),r):Kt(r,a)}}import{current as $t,isDraft as Xt}from"immer";function D(e,t){return t(e)}function v(e){return Array.isArray(e)||(e=Object.values(e)),e}function B(e){return Xt(e)?$t(e):e}function Z(e,t,r){e=v(e);let n=B(r.ids),o=new Set(n),a=[],s=new Set([]),y=[];for(let c of e){let l=D(c,t);o.has(l)||s.has(l)?y.push({id:l,changes:c}):(s.add(l),a.push(c))}return[a,y,n]}function ee(e){function t(p,h){let u=D(p,e);u in h.entities||(h.ids.push(u),h.entities[u]=p)}function r(p,h){p=v(p);for(let u of p)t(u,h)}function n(p,h){let u=D(p,e);u in h.entities||h.ids.push(u),h.entities[u]=p}function o(p,h){p=v(p);for(let u of p)n(u,h)}function a(p,h){p=v(p),h.ids=[],h.entities={},r(p,h)}function s(p,h){return y([p],h)}function y(p,h){let u=!1;p.forEach(f=>{f in h.entities&&(delete h.entities[f],u=!0)}),u&&(h.ids=h.ids.filter(f=>f in h.entities))}function c(p){Object.assign(p,{ids:[],entities:{}})}function l(p,h,u){let f=u.entities[h.id];if(f===void 0)return!1;let k=Object.assign({},f,h.changes),A=D(k,e),m=A!==h.id;return m&&(p[h.id]=A,delete u.entities[h.id]),u.entities[A]=k,m}function i(p,h){return d([p],h)}function d(p,h){let u={},f={};p.forEach(A=>{A.id in h.entities&&(f[A.id]={id:A.id,changes:{...f[A.id]?.changes,...A.changes}})}),p=Object.values(f),p.length>0&&p.filter(m=>l(u,m,h)).length>0&&(h.ids=Object.values(h.entities).map(m=>D(m,e)))}function T(p,h){return g([p],h)}function g(p,h){let[u,f]=Z(p,e,h);r(u,h),d(f,h)}return{removeAll:Ke(c),addOne:R(t),addMany:R(r),setOne:R(n),setMany:R(o),setAll:R(a),updateOne:R(i),updateMany:R(d),upsertOne:R(T),upsertMany:R(g),removeOne:R(s),removeMany:R(y)}}function Jt(e,t,r){let n=0,o=e.length;for(;n<o;){let a=n+o>>>1,s=e[a];r(t,s)>=0?n=a+1:o=a}return n}function Qt(e,t,r){let n=Jt(e,t,r);return e.splice(n,0,t),e}function He(e,t){let{removeOne:r,removeMany:n,removeAll:o}=ee(e);function a(u,f){return s([u],f)}function s(u,f,k){u=v(u);let A=new Set(k??B(f.ids)),m=u.filter(S=>!A.has(D(S,e)));m.length!==0&&h(f,m)}function y(u,f){return c([u],f)}function c(u,f){if(u=v(u),u.length!==0){for(let k of u)delete f.entities[e(k)];h(f,u)}}function l(u,f){u=v(u),f.entities={},f.ids=[],s(u,f,[])}function i(u,f){return d([u],f)}function d(u,f){let k=!1,A=!1;for(let m of u){let S=f.entities[m.id];if(!S)continue;k=!0,Object.assign(S,m.changes);let w=e(S);if(m.id!==w){A=!0,delete f.entities[m.id];let C=f.ids.indexOf(m.id);f.ids[C]=w,f.entities[w]=S}}k&&h(f,[],k,A)}function T(u,f){return g([u],f)}function g(u,f){let[k,A,m]=Z(u,e,f);k.length&&s(k,f,m),A.length&&d(A,f)}function p(u,f){if(u.length!==f.length)return!1;for(let k=0;k<u.length;k++)if(u[k]!==f[k])return!1;return!0}let h=(u,f,k,A)=>{let m=B(u.entities),S=B(u.ids),w=u.entities,C=S;A&&(C=new Set(S));let E=[];for(let j of C){let ke=m[j];ke&&E.push(ke)}let U=E.length===0;for(let j of f)w[e(j)]=j,U||Qt(E,j,t);U?E=f.slice().sort(t):k&&E.sort(t);let H=E.map(e);p(S,H)||(u.ids=H)};return{removeOne:r,removeMany:n,removeAll:o,addOne:R(a),updateOne:R(i),upsertOne:R(T),setOne:R(y),setMany:R(c),setAll:R(l),addMany:R(s),updateMany:R(d),upsertMany:R(g)}}function Yt(e={}){let{selectId:t,sortComparer:r}={sortComparer:!1,selectId:s=>s.id,...e},n=r?He(t,r):ee(t),o=Ge(n),a=Be();return{selectId:t,sortComparer:r,...o,...a,...n}}import{isAction as en}from"redux";var Zt="task",qe="listener",$e="completed",ye="cancelled",Xe=`task-${ye}`,Je=`task-${$e}`,te=`${qe}-${ye}`,Qe=`${qe}-${$e}`,b=class{constructor(t){this.code=t;this.message=`${Zt} ${ye} (reason: ${t})`}name="TaskAbortError";message};var ne=(e,t)=>{if(typeof e!="function")throw new TypeError(x(32))},_=()=>{},re=(e,t=_)=>(e.catch(t),e),oe=(e,t)=>(e.addEventListener("abort",t,{once:!0}),()=>e.removeEventListener("abort",t)),O=(e,t)=>{let r=e.signal;r.aborted||("reason"in r||Object.defineProperty(r,"reason",{enumerable:!0,value:t,configurable:!0,writable:!0}),e.abort(t))};var N=e=>{if(e.aborted){let{reason:t}=e;throw new b(t)}};function he(e,t){let r=_;return new Promise((n,o)=>{let a=()=>o(new b(e.reason));if(e.aborted){a();return}r=oe(e,a),t.finally(()=>r()).then(n,o)}).finally(()=>{r=_})}var Ye=async(e,t)=>{try{return await Promise.resolve(),{status:"ok",value:await e()}}catch(r){return{status:r instanceof b?"cancelled":"rejected",error:r}}finally{t?.()}},K=e=>t=>re(he(e,t).then(r=>(N(e),r))),Ae=e=>{let t=K(e);return r=>t(new Promise(n=>setTimeout(n,r)))};var{assign:L}=Object,Ze={},ae="listenerMiddleware",tn=(e,t)=>{let r=n=>oe(e,()=>O(n,e.reason));return(n,o)=>{ne(n,"taskExecutor");let a=new AbortController;r(a);let s=Ye(async()=>{N(e),N(a.signal);let y=await n({pause:K(a.signal),delay:Ae(a.signal),signal:a.signal});return N(a.signal),y},()=>O(a,Je));return o?.autoJoin&&t.push(s.catch(_)),{result:K(e)(s),cancel(){O(a,Xe)}}}},nn=(e,t)=>{let r=async(n,o)=>{N(t);let a=()=>{},y=[new Promise((c,l)=>{let i=e({predicate:n,effect:(d,T)=>{T.unsubscribe(),c([d,T.getState(),T.getOriginalState()])}});a=()=>{i(),l()}})];o!=null&&y.push(new Promise(c=>setTimeout(c,o,null)));try{let c=await he(t,Promise.race(y));return N(t),c}finally{a()}};return(n,o)=>re(r(n,o))},nt=e=>{let{type:t,actionCreator:r,matcher:n,predicate:o,effect:a}=e;if(t)o=M(t).match;else if(r)t=r.type,o=r.match;else if(n)o=n;else if(!o)throw new Error(x(21));return ne(a,"options.listener"),{predicate:o,type:t,effect:a}},rt=L(e=>{let{type:t,predicate:r,effect:n}=nt(e);return{id:I(),effect:n,type:t,predicate:r,pending:new Set,unsubscribe:()=>{throw new Error(x(22))}}},{withTypes:()=>rt}),et=(e,t)=>{let{type:r,effect:n,predicate:o}=nt(t);return Array.from(e.values()).find(a=>(typeof r=="string"?a.type===r:a.predicate===o)&&a.effect===n)},Te=e=>{e.pending.forEach(t=>{O(t,te)})},rn=e=>()=>{e.forEach(Te),e.clear()},tt=(e,t,r)=>{try{e(t,r)}catch(n){setTimeout(()=>{throw n},0)}},me=L(M(`${ae}/add`),{withTypes:()=>me}),ot=M(`${ae}/removeAll`),ge=L(M(`${ae}/remove`),{withTypes:()=>ge}),on=(...e)=>{console.error(`${ae}/error`,...e)},an=(e={})=>{let t=new Map,{extra:r,onError:n=on}=e;ne(n,"onError");let o=i=>(i.unsubscribe=()=>t.delete(i.id),t.set(i.id,i),d=>{i.unsubscribe(),d?.cancelActive&&Te(i)}),a=i=>{let d=et(t,i)??rt(i);return o(d)};L(a,{withTypes:()=>a});let s=i=>{let d=et(t,i);return d&&(d.unsubscribe(),i.cancelActive&&Te(d)),!!d};L(s,{withTypes:()=>s});let y=async(i,d,T,g)=>{let p=new AbortController,h=nn(a,p.signal),u=[];try{i.pending.add(p),await Promise.resolve(i.effect(d,L({},T,{getOriginalState:g,condition:(f,k)=>h(f,k).then(Boolean),take:h,delay:Ae(p.signal),pause:K(p.signal),extra:r,signal:p.signal,fork:tn(p.signal,u),unsubscribe:i.unsubscribe,subscribe:()=>{t.set(i.id,i)},cancelActiveListeners:()=>{i.pending.forEach((f,k,A)=>{f!==p&&(O(f,te),A.delete(f))})},cancel:()=>{O(p,te),i.pending.delete(p)},throwIfCancelled:()=>{N(p.signal)}})))}catch(f){f instanceof b||tt(n,f,{raisedBy:"effect"})}finally{await Promise.all(u),O(p,Qe),i.pending.delete(p)}},c=rn(t);return{middleware:i=>d=>T=>{if(!en(T))return d(T);if(me.match(T))return a(T.payload);if(ot.match(T)){c();return}if(ge.match(T))return s(T.payload);let g=i.getState(),p=()=>{if(g===Ze)throw new Error(x(23));return g},h;try{if(h=d(T),t.size>0){let u=i.getState(),f=Array.from(t.values());for(let k of f){let A=!1;try{A=k.predicate(T,u,g)}catch(m){A=!1,tt(n,m,{raisedBy:"predicate"})}A&&y(k,T,i,p)}}}finally{g=Ze}return h},startListening:a,stopListening:s,clearListeners:c}};import{compose as sn}from"redux";var cn=e=>({middleware:e,applied:new Map}),dn=e=>t=>t?.meta?.instanceId===e,un=()=>{let e=I(),t=new Map,r=Object.assign(M("dynamicMiddleware/add",(...y)=>({payload:y,meta:{instanceId:e}})),{withTypes:()=>r}),n=Object.assign(function(...c){c.forEach(l=>{P(t,l,cn)})},{withTypes:()=>n}),o=y=>{let c=Array.from(t.values()).map(l=>P(l.applied,y,l.middleware));return sn(...c)},a=W(r,dn(e));return{middleware:y=>c=>l=>a(l)?(n(...l.payload),y.dispatch):o(y)(c)(l),addMiddleware:n,withMiddleware:r,instanceId:e}};import{combineReducers as ln}from"redux";var pn=e=>"reducerPath"in e&&typeof e.reducerPath=="string",fn=e=>e.flatMap(t=>pn(t)?[[t.reducerPath,t.reducer]]:Object.entries(t)),Se=Symbol.for("rtk-state-proxy-original"),yn=e=>!!e&&!!e[Se],hn=new WeakMap,An=(e,t,r)=>P(hn,e,()=>new Proxy(e,{get:(n,o,a)=>{if(o===Se)return n;let s=Reflect.get(n,o,a);if(typeof s>"u"){let y=r[o];if(typeof y<"u")return y;let c=t[o];if(c){let l=c(void 0,{type:I()});if(typeof l>"u")throw new Error(x(24));return r[o]=l,l}}return s}})),Tn=e=>{if(!yn(e))throw new Error(x(25));return e[Se]},mn={},gn=(e=mn)=>e;function Sn(...e){let t=Object.fromEntries(fn(e)),r=()=>Object.keys(t).length?ln(t):gn,n=r();function o(c,l){return n(c,l)}o.withLazyLoadedSlices=()=>o;let a={},s=(c,l={})=>{let{reducerPath:i,reducer:d}=c,T=t[i];return!l.overrideExisting&&T&&T!==d||(l.overrideExisting&&T!==d&&delete a[i],t[i]=d,n=r()),o},y=Object.assign(function(l,i){return function(T,...g){return l(An(i?i(T,...g):T,t,a),...g)}},{original:Tn});return Object.assign(o,{inject:s,selector:y})}function x(e){return`Minified Redux Toolkit error #${e}; visit https://redux-toolkit.js.org/Errors?code=${e} for the full message or use the non-minified dev environment for full errors. `}export{We as ReducerType,ue as SHOULD_AUTOBATCH,b as TaskAbortError,F as Tuple,me as addListener,jt as asyncThunkCreator,le as autoBatchEnhancer,ze as buildCreateSlice,ot as clearAllListeners,Sn as combineSlices,Mt as configureStore,M as createAction,lt as createActionCreatorInvariantMiddleware,fe as createAsyncThunk,ie as createDraftSafeSelector,xe as createDraftSafeSelectorCreator,un as createDynamicMiddleware,Yt as createEntityAdapter,ht as createImmutableStateInvariantMiddleware,an as createListenerMiddleware,Io as createNextState,pe as createReducer,Fo as createSelector,Vo as createSelectorCreator,Tt as createSerializableStateInvariantMiddleware,_t as createSlice,vo as current,Me as findNonSerializableValue,x as formatProdErrorMessage,Do as freeze,se as isActionCreator,W as isAllOf,V as isAnyOf,Fe as isAsyncThunkAction,No as isDraft,ce as isFluxStandardAction,je as isFulfilled,yt as isImmutableDefault,Oe as isPending,we as isPlain,X as isRejected,Ne as isRejectedWithValue,_o as lruMemoize,_e as miniSerializeError,I as nanoid,Oo as original,kt as prepareAutoBatched,ge as removeListener,Le as unwrapResult,Lo as weakMapMemoize};
+//# sourceMappingURL=redux-toolkit.browser.mjs.map