@me1a/ui 1.2.12 → 1.2.13

package/dist/redux-toolkit/index.cjs.js

@@ -1,5 +1,26 @@
 'use strict';
 
+var ReactOriginal = require('react');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ReactOriginal__namespace = /*#__PURE__*/_interopNamespaceDefault(ReactOriginal);
+
 // src/utils/formatProdErrorMessage.ts
 function formatProdErrorMessage$1(code) {
   return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
@@ -490,7 +511,7 @@ function set(thing, propOrOldValue, value) {
   } else
     thing[propOrOldValue] = value;
 }
-function is(x, y) {
+function is$1(x, y) {
   if (x === y) {
     return x !== 0 || 1 / x === 1 / y;
   } else {
@@ -804,7 +825,7 @@ var objectTraps = {
         state.assigned_[prop] = false;
         return true;
       }
-      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
+      if (is$1(value, current2) && (value !== void 0 || has(state.base_, prop)))
         return true;
       prepareCopy(state);
       markChanged(state);
@@ -3995,7 +4016,7 @@ function copyWithStructuralSharing(oldObj, newObj) {
 }
 
 // src/query/utils/countObjectKeys.ts
-function countObjectKeys(obj) {
+function countObjectKeys$1(obj) {
   let count = 0;
   for (const _key in obj) {
     count++;
@@ -4323,10 +4344,10 @@ function setupListeners(dispatch, customHandler) {
 }
 
 // src/query/endpointDefinitions.ts
-function isQueryDefinition(e) {
+function isQueryDefinition$1(e) {
   return e.type === "query" /* query */;
 }
-function isMutationDefinition(e) {
+function isMutationDefinition$1(e) {
   return e.type === "mutation" /* mutation */;
 }
 function calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {
@@ -4496,7 +4517,7 @@ You must add the middleware for RTK-Query to function correctly!`);
         runningQueries.set(dispatch, running);
         statePromise.then(() => {
           delete running[queryCacheKey];
-          if (!countObjectKeys(running)) {
+          if (!countObjectKeys$1(running)) {
             runningQueries.delete(dispatch);
           }
         });
@@ -4547,7 +4568,7 @@ You must add the middleware for RTK-Query to function correctly!`);
       running[requestId] = ret;
       ret.then(() => {
         delete running[requestId];
-        if (!countObjectKeys(running)) {
+        if (!countObjectKeys$1(running)) {
           runningMutations.delete(dispatch);
         }
       });
@@ -4556,7 +4577,7 @@ You must add the middleware for RTK-Query to function correctly!`);
         ret.then(() => {
           if (running[fixedCacheKey] === ret) {
             delete running[fixedCacheKey];
-            if (!countObjectKeys(running)) {
+            if (!countObjectKeys$1(running)) {
               runningMutations.delete(dispatch);
             }
           }
@@ -4782,7 +4803,7 @@ In the case of an unhandled error, no tags will be "provided" or "invalidated".`
       if (isForcedQuery(queryThunkArgs, state)) {
         return true;
       }
-      if (isQueryDefinition(endpointDefinition) && endpointDefinition?.forceRefetch?.({
+      if (isQueryDefinition$1(endpointDefinition) && endpointDefinition?.forceRefetch?.({
         currentArg,
         previousArg,
         endpointState: requestState,
@@ -5386,13 +5407,13 @@ function buildSelectors({
 }
 
 // src/query/defaultSerializeQueryArgs.ts
-var cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;
-var defaultSerializeQueryArgs = ({
+var cache$1 = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;
+var defaultSerializeQueryArgs$1 = ({
   endpointName,
   queryArgs
 }) => {
   let serialized = "";
-  const cached = cache?.get(queryArgs);
+  const cached = cache$1?.get(queryArgs);
   if (typeof cached === "string") {
     serialized = cached;
   } else {
@@ -5407,7 +5428,7 @@ var defaultSerializeQueryArgs = ({
       return value;
     });
     if (isPlainObject$1(queryArgs)) {
-      cache?.set(queryArgs, stringified);
+      cache$1?.set(queryArgs, stringified);
     }
     serialized = stringified;
   }
@@ -5428,7 +5449,7 @@ function buildCreateApi(...modules) {
       ...options,
       extractRehydrationInfo,
       serializeQueryArgs(queryArgsApi) {
-        let finalSerializeQueryArgs = defaultSerializeQueryArgs;
+        let finalSerializeQueryArgs = defaultSerializeQueryArgs$1;
         if ("serializeQueryArgs" in queryArgsApi.endpointDefinition) {
           const endpointSQA = queryArgsApi.endpointDefinition.serializeQueryArgs;
           finalSerializeQueryArgs = (queryArgsApi2) => {
@@ -5436,7 +5457,7 @@ function buildCreateApi(...modules) {
             if (typeof initialResult === "string") {
               return initialResult;
             } else {
-              return defaultSerializeQueryArgs({
+              return defaultSerializeQueryArgs$1({
                 ...queryArgsApi2,
                 queryArgs: initialResult
               });
@@ -5522,7 +5543,7 @@ function fakeBaseQuery() {
     throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(33) : "When using `fakeBaseQuery`, all queries & mutations must use the `queryFn` definition syntax.");
   };
 }
-function safeAssign(target, ...args) {
+function safeAssign$1(target, ...args) {
   return Object.assign(target, ...args);
 }
 var buildBatchedActionsHandler = ({
@@ -5604,7 +5625,7 @@ var buildBatchedActionsHandler = ({
   const getSubscriptionCount = (queryCacheKey) => {
     const subscriptions = getSubscriptions();
     const subscriptionsForQueryArg = subscriptions[queryCacheKey] ?? {};
-    return countObjectKeys(subscriptionsForQueryArg);
+    return countObjectKeys$1(subscriptionsForQueryArg);
   };
   const isRequestSubscribed = (queryCacheKey, requestId) => {
     const subscriptions = getSubscriptions();
@@ -5924,7 +5945,7 @@ var buildInvalidationByTagsHandler = ({
         const querySubState = state.queries[queryCacheKey];
         const subscriptionSubState = internalState.currentSubscriptions[queryCacheKey] ?? {};
         if (querySubState) {
-          if (countObjectKeys(subscriptionSubState) === 0) {
+          if (countObjectKeys$1(subscriptionSubState) === 0) {
             mwApi.dispatch(removeQueryResult({
               queryCacheKey
             }));
@@ -6145,7 +6166,7 @@ var buildWindowEventHandler = ({
         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) {
+          if (countObjectKeys$1(subscriptionSubState) === 0) {
             api2.dispatch(removeQueryResult({
               queryCacheKey
             }));
@@ -6306,7 +6327,7 @@ var coreModule = ({
         invalidationBehavior
       }
     });
-    safeAssign(api.util, {
+    safeAssign$1(api.util, {
       patchQueryData,
       updateQueryData,
       upsertQueryData,
@@ -6314,7 +6335,7 @@ var coreModule = ({
       resetApiState: sliceActions.resetApiState,
       upsertQueryEntries: sliceActions.cacheEntriesUpserted
     });
-    safeAssign(api.internalActions, sliceActions);
+    safeAssign$1(api.internalActions, sliceActions);
     const {
       middleware,
       actions: middlewareActions
@@ -6326,8 +6347,8 @@ var coreModule = ({
       api,
       assertTagType
     });
-    safeAssign(api.util, middlewareActions);
-    safeAssign(api, {
+    safeAssign$1(api.util, middlewareActions);
+    safeAssign$1(api, {
       reducer,
       middleware
     });
@@ -6341,7 +6362,7 @@ var coreModule = ({
       reducerPath,
       createSelector: createSelector2
     });
-    safeAssign(api.util, {
+    safeAssign$1(api.util, {
       selectInvalidatedBy,
       selectCachedArgsForQuery
     });
@@ -6359,7 +6380,7 @@ var coreModule = ({
       serializeQueryArgs,
       context
     });
-    safeAssign(api.util, {
+    safeAssign$1(api.util, {
       getRunningMutationThunk,
       getRunningMutationsThunk,
       getRunningQueryThunk,
@@ -6370,14 +6391,14 @@ var coreModule = ({
       injectEndpoint(endpointName, definition) {
         const anyApi = api;
         anyApi.endpoints[endpointName] ??= {};
-        if (isQueryDefinition(definition)) {
-          safeAssign(anyApi.endpoints[endpointName], {
+        if (isQueryDefinition$1(definition)) {
+          safeAssign$1(anyApi.endpoints[endpointName], {
             name: endpointName,
             select: buildQuerySelector(endpointName, definition),
             initiate: buildInitiateQuery(endpointName, definition)
           }, buildMatchThunkActions(queryThunk, endpointName));
-        } else if (isMutationDefinition(definition)) {
-          safeAssign(anyApi.endpoints[endpointName], {
+        } else if (isMutationDefinition$1(definition)) {
+          safeAssign$1(anyApi.endpoints[endpointName], {
             name: endpointName,
             select: buildMutationSelector(),
             initiate: buildInitiateMutation(endpointName)
@@ -6388,21 +6409,1197 @@ var coreModule = ({
   }
 });
 
-// src/query/core/index.ts
-var createApi = /* @__PURE__ */ buildCreateApi(coreModule());
+var withSelector = {exports: {}};
+
+var useSyncExternalStoreWithSelector_production_min = {};
+
+/**
+ * @license React
+ * use-sync-external-store-with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreWithSelector_production_min;
+
+function requireUseSyncExternalStoreWithSelector_production_min () {
+	if (hasRequiredUseSyncExternalStoreWithSelector_production_min) return useSyncExternalStoreWithSelector_production_min;
+	hasRequiredUseSyncExternalStoreWithSelector_production_min = 1;
+var g=ReactOriginal;function n(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var p="function"===typeof Object.is?Object.is:n,q=g.useSyncExternalStore,r=g.useRef,t=g.useEffect,u=g.useMemo,v=g.useDebugValue;
+	useSyncExternalStoreWithSelector_production_min.useSyncExternalStoreWithSelector=function(a,b,e,l,h){var c=r(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f;}else f=c.current;c=u(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==h&&f.hasValue){var b=f.value;if(h(b,a))return k=b}return k=a}b=k;if(p(d,a))return b;var e=l(a);if(void 0!==h&&h(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return [function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,h]);var d=q(a,c[0],c[1]);
+	t(function(){f.hasValue=!0;f.value=d;},[d]);v(d);return d};
+	return useSyncExternalStoreWithSelector_production_min;
+}
+
+var useSyncExternalStoreWithSelector_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-with-selector.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreWithSelector_development;
+
+function requireUseSyncExternalStoreWithSelector_development () {
+	if (hasRequiredUseSyncExternalStoreWithSelector_development) return useSyncExternalStoreWithSelector_development;
+	hasRequiredUseSyncExternalStoreWithSelector_development = 1;
+
+	if (process.env.NODE_ENV !== "production") {
+	  (function() {
+
+	/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+	if (
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+	    'function'
+	) {
+	  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+	}
+	          var React = ReactOriginal;
+
+	/**
+	 * inlined Object.is polyfill to avoid requiring consumers ship their own
+	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+	 */
+	function is(x, y) {
+	  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+	  ;
+	}
+
+	var objectIs = typeof Object.is === 'function' ? Object.is : is;
+
+	var useSyncExternalStore = React.useSyncExternalStore;
+
+	// for CommonJS interop.
+
+	var useRef = React.useRef,
+	    useEffect = React.useEffect,
+	    useMemo = React.useMemo,
+	    useDebugValue = React.useDebugValue; // Same as useSyncExternalStore, but supports selector and isEqual arguments.
+
+	function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+	  // Use this to track the rendered snapshot.
+	  var instRef = useRef(null);
+	  var inst;
+
+	  if (instRef.current === null) {
+	    inst = {
+	      hasValue: false,
+	      value: null
+	    };
+	    instRef.current = inst;
+	  } else {
+	    inst = instRef.current;
+	  }
+
+	  var _useMemo = useMemo(function () {
+	    // Track the memoized state using closure variables that are local to this
+	    // memoized instance of a getSnapshot function. Intentionally not using a
+	    // useRef hook, because that state would be shared across all concurrent
+	    // copies of the hook/component.
+	    var hasMemo = false;
+	    var memoizedSnapshot;
+	    var memoizedSelection;
+
+	    var memoizedSelector = function (nextSnapshot) {
+	      if (!hasMemo) {
+	        // The first time the hook is called, there is no memoized result.
+	        hasMemo = true;
+	        memoizedSnapshot = nextSnapshot;
+
+	        var _nextSelection = selector(nextSnapshot);
+
+	        if (isEqual !== undefined) {
+	          // Even if the selector has changed, the currently rendered selection
+	          // may be equal to the new selection. We should attempt to reuse the
+	          // current value if possible, to preserve downstream memoizations.
+	          if (inst.hasValue) {
+	            var currentSelection = inst.value;
+
+	            if (isEqual(currentSelection, _nextSelection)) {
+	              memoizedSelection = currentSelection;
+	              return currentSelection;
+	            }
+	          }
+	        }
+
+	        memoizedSelection = _nextSelection;
+	        return _nextSelection;
+	      } // We may be able to reuse the previous invocation's result.
+
+
+	      // We may be able to reuse the previous invocation's result.
+	      var prevSnapshot = memoizedSnapshot;
+	      var prevSelection = memoizedSelection;
+
+	      if (objectIs(prevSnapshot, nextSnapshot)) {
+	        // The snapshot is the same as last time. Reuse the previous selection.
+	        return prevSelection;
+	      } // The snapshot has changed, so we need to compute a new selection.
+
+
+	      // The snapshot has changed, so we need to compute a new selection.
+	      var nextSelection = selector(nextSnapshot); // If a custom isEqual function is provided, use that to check if the data
+	      // has changed. If it hasn't, return the previous selection. That signals
+	      // to React that the selections are conceptually equal, and we can bail
+	      // out of rendering.
+
+	      // If a custom isEqual function is provided, use that to check if the data
+	      // has changed. If it hasn't, return the previous selection. That signals
+	      // to React that the selections are conceptually equal, and we can bail
+	      // out of rendering.
+	      if (isEqual !== undefined && isEqual(prevSelection, nextSelection)) {
+	        return prevSelection;
+	      }
+
+	      memoizedSnapshot = nextSnapshot;
+	      memoizedSelection = nextSelection;
+	      return nextSelection;
+	    }; // Assigning this to a constant so that Flow knows it can't change.
+
+
+	    // Assigning this to a constant so that Flow knows it can't change.
+	    var maybeGetServerSnapshot = getServerSnapshot === undefined ? null : getServerSnapshot;
+
+	    var getSnapshotWithSelector = function () {
+	      return memoizedSelector(getSnapshot());
+	    };
+
+	    var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? undefined : function () {
+	      return memoizedSelector(maybeGetServerSnapshot());
+	    };
+	    return [getSnapshotWithSelector, getServerSnapshotWithSelector];
+	  }, [getSnapshot, getServerSnapshot, selector, isEqual]),
+	      getSelection = _useMemo[0],
+	      getServerSelection = _useMemo[1];
+
+	  var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
+	  useEffect(function () {
+	    inst.hasValue = true;
+	    inst.value = value;
+	  }, [value]);
+	  useDebugValue(value);
+	  return value;
+	}
+
+	useSyncExternalStoreWithSelector_development.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;
+	          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+	if (
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+	    'function'
+	) {
+	  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+	}
+	        
+	  })();
+	}
+	return useSyncExternalStoreWithSelector_development;
+}
+
+var hasRequiredWithSelector;
+
+function requireWithSelector () {
+	if (hasRequiredWithSelector) return withSelector.exports;
+	hasRequiredWithSelector = 1;
+
+	if (process.env.NODE_ENV === 'production') {
+	  withSelector.exports = requireUseSyncExternalStoreWithSelector_production_min();
+	} else {
+	  withSelector.exports = requireUseSyncExternalStoreWithSelector_development();
+	}
+	return withSelector.exports;
+}
+
+var withSelectorExports = requireWithSelector();
+
+// src/index.ts
+var React = (
+  // prettier-ignore
+  // @ts-ignore
+  "default" in ReactOriginal__namespace ? ReactOriginal__namespace["default"] : ReactOriginal__namespace
+);
+
+// src/components/Context.ts
+var ContextKey = Symbol.for(`react-redux-context`);
+var gT = typeof globalThis !== "undefined" ? globalThis : (
+  /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
+  {}
+);
+function getContext() {
+  if (!React.createContext)
+    return {};
+  const contextMap = gT[ContextKey] ?? (gT[ContextKey] = /* @__PURE__ */ new Map());
+  let realContext = contextMap.get(React.createContext);
+  if (!realContext) {
+    realContext = React.createContext(
+      null
+    );
+    if (process.env.NODE_ENV !== "production") {
+      realContext.displayName = "ReactRedux";
+    }
+    contextMap.set(React.createContext, realContext);
+  }
+  return realContext;
+}
+var ReactReduxContext = /* @__PURE__ */ getContext();
+
+// src/utils/useSyncExternalStore.ts
+var notInitialized = () => {
+  throw new Error("uSES not initialized!");
+};
+
+// src/hooks/useReduxContext.ts
+function createReduxContextHook(context = ReactReduxContext) {
+  return function useReduxContext2() {
+    const contextValue = React.useContext(context);
+    if (process.env.NODE_ENV !== "production" && !contextValue) {
+      throw new Error(
+        "could not find react-redux context value; please ensure the component is wrapped in a <Provider>"
+      );
+    }
+    return contextValue;
+  };
+}
+var useReduxContext = /* @__PURE__ */ createReduxContextHook();
+
+// src/hooks/useSelector.ts
+var useSyncExternalStoreWithSelector = notInitialized;
+var initializeUseSelector = (fn) => {
+  useSyncExternalStoreWithSelector = fn;
+};
+var refEquality = (a, b) => a === b;
+function createSelectorHook(context = ReactReduxContext) {
+  const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
+  const useSelector2 = (selector, equalityFnOrOptions = {}) => {
+    const { equalityFn = refEquality, devModeChecks = {} } = typeof equalityFnOrOptions === "function" ? { equalityFn: equalityFnOrOptions } : equalityFnOrOptions;
+    if (process.env.NODE_ENV !== "production") {
+      if (!selector) {
+        throw new Error(`You must pass a selector to useSelector`);
+      }
+      if (typeof selector !== "function") {
+        throw new Error(`You must pass a function as a selector to useSelector`);
+      }
+      if (typeof equalityFn !== "function") {
+        throw new Error(
+          `You must pass a function as an equality function to useSelector`
+        );
+      }
+    }
+    const {
+      store,
+      subscription,
+      getServerState,
+      stabilityCheck,
+      identityFunctionCheck
+    } = useReduxContext2();
+    const firstRun = React.useRef(true);
+    const wrappedSelector = React.useCallback(
+      {
+        [selector.name](state) {
+          const selected = selector(state);
+          if (process.env.NODE_ENV !== "production") {
+            const {
+              identityFunctionCheck: finalIdentityFunctionCheck,
+              stabilityCheck: finalStabilityCheck
+            } = {
+              stabilityCheck,
+              identityFunctionCheck,
+              ...devModeChecks
+            };
+            if (finalStabilityCheck === "always" || finalStabilityCheck === "once" && firstRun.current) {
+              const toCompare = selector(state);
+              if (!equalityFn(selected, toCompare)) {
+                let stack = void 0;
+                try {
+                  throw new Error();
+                } catch (e) {
+                  ({ stack } = e);
+                }
+                console.warn(
+                  "Selector " + (selector.name || "unknown") + " returned a different result when called with the same parameters. This can lead to unnecessary rerenders.\nSelectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization",
+                  {
+                    state,
+                    selected,
+                    selected2: toCompare,
+                    stack
+                  }
+                );
+              }
+            }
+            if (finalIdentityFunctionCheck === "always" || finalIdentityFunctionCheck === "once" && firstRun.current) {
+              if (selected === state) {
+                let stack = void 0;
+                try {
+                  throw new Error();
+                } catch (e) {
+                  ({ stack } = e);
+                }
+                console.warn(
+                  "Selector " + (selector.name || "unknown") + " returned the root state when called. This can lead to unnecessary rerenders.\nSelectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.",
+                  { stack }
+                );
+              }
+            }
+            if (firstRun.current)
+              firstRun.current = false;
+          }
+          return selected;
+        }
+      }[selector.name],
+      [selector, stabilityCheck, devModeChecks.stabilityCheck]
+    );
+    const selectedState = useSyncExternalStoreWithSelector(
+      subscription.addNestedSub,
+      store.getState,
+      getServerState || store.getState,
+      wrappedSelector,
+      equalityFn
+    );
+    React.useDebugValue(selectedState);
+    return selectedState;
+  };
+  Object.assign(useSelector2, {
+    withTypes: () => useSelector2
+  });
+  return useSelector2;
+}
+var useSelector = /* @__PURE__ */ createSelectorHook();
+
+// src/utils/batch.ts
+function defaultNoopBatch(callback) {
+  callback();
+}
+
+// src/utils/Subscription.ts
+function createListenerCollection() {
+  let first = null;
+  let last = null;
+  return {
+    clear() {
+      first = null;
+      last = null;
+    },
+    notify() {
+      defaultNoopBatch(() => {
+        let listener = first;
+        while (listener) {
+          listener.callback();
+          listener = listener.next;
+        }
+      });
+    },
+    get() {
+      const listeners = [];
+      let listener = first;
+      while (listener) {
+        listeners.push(listener);
+        listener = listener.next;
+      }
+      return listeners;
+    },
+    subscribe(callback) {
+      let isSubscribed = true;
+      const listener = last = {
+        callback,
+        next: null,
+        prev: last
+      };
+      if (listener.prev) {
+        listener.prev.next = listener;
+      } else {
+        first = listener;
+      }
+      return function unsubscribe() {
+        if (!isSubscribed || first === null)
+          return;
+        isSubscribed = false;
+        if (listener.next) {
+          listener.next.prev = listener.prev;
+        } else {
+          last = listener.prev;
+        }
+        if (listener.prev) {
+          listener.prev.next = listener.next;
+        } else {
+          first = listener.next;
+        }
+      };
+    }
+  };
+}
+var nullListeners = {
+  notify() {
+  },
+  get: () => []
+};
+function createSubscription(store, parentSub) {
+  let unsubscribe;
+  let listeners = nullListeners;
+  let subscriptionsAmount = 0;
+  let selfSubscribed = false;
+  function addNestedSub(listener) {
+    trySubscribe();
+    const cleanupListener = listeners.subscribe(listener);
+    let removed = false;
+    return () => {
+      if (!removed) {
+        removed = true;
+        cleanupListener();
+        tryUnsubscribe();
+      }
+    };
+  }
+  function notifyNestedSubs() {
+    listeners.notify();
+  }
+  function handleChangeWrapper() {
+    if (subscription.onStateChange) {
+      subscription.onStateChange();
+    }
+  }
+  function isSubscribed() {
+    return selfSubscribed;
+  }
+  function trySubscribe() {
+    subscriptionsAmount++;
+    if (!unsubscribe) {
+      unsubscribe = store.subscribe(handleChangeWrapper);
+      listeners = createListenerCollection();
+    }
+  }
+  function tryUnsubscribe() {
+    subscriptionsAmount--;
+    if (unsubscribe && subscriptionsAmount === 0) {
+      unsubscribe();
+      unsubscribe = void 0;
+      listeners.clear();
+      listeners = nullListeners;
+    }
+  }
+  function trySubscribeSelf() {
+    if (!selfSubscribed) {
+      selfSubscribed = true;
+      trySubscribe();
+    }
+  }
+  function tryUnsubscribeSelf() {
+    if (selfSubscribed) {
+      selfSubscribed = false;
+      tryUnsubscribe();
+    }
+  }
+  const subscription = {
+    addNestedSub,
+    notifyNestedSubs,
+    handleChangeWrapper,
+    isSubscribed,
+    trySubscribe: trySubscribeSelf,
+    tryUnsubscribe: tryUnsubscribeSelf,
+    getListeners: () => listeners
+  };
+  return subscription;
+}
+
+// src/utils/useIsomorphicLayoutEffect.ts
+var canUseDOM$1 = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+var isReactNative$1 = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+var useIsomorphicLayoutEffect$1 = canUseDOM$1 || isReactNative$1 ? React.useLayoutEffect : React.useEffect;
+
+// src/utils/shallowEqual.ts
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || y !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+function shallowEqual(objA, objB) {
+  if (is(objA, objB))
+    return true;
+  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+    return false;
+  }
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (let i = 0; i < keysA.length; i++) {
+    if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/components/Provider.tsx
+function Provider({
+  store,
+  context,
+  children,
+  serverState,
+  stabilityCheck = "once",
+  identityFunctionCheck = "once"
+}) {
+  const contextValue = React.useMemo(() => {
+    const subscription = createSubscription(store);
+    return {
+      store,
+      subscription,
+      getServerState: serverState ? () => serverState : void 0,
+      stabilityCheck,
+      identityFunctionCheck
+    };
+  }, [store, serverState, stabilityCheck, identityFunctionCheck]);
+  const previousState = React.useMemo(() => store.getState(), [store]);
+  useIsomorphicLayoutEffect$1(() => {
+    const { subscription } = contextValue;
+    subscription.onStateChange = subscription.notifyNestedSubs;
+    subscription.trySubscribe();
+    if (previousState !== store.getState()) {
+      subscription.notifyNestedSubs();
+    }
+    return () => {
+      subscription.tryUnsubscribe();
+      subscription.onStateChange = void 0;
+    };
+  }, [contextValue, previousState]);
+  const Context = context || ReactReduxContext;
+  return /* @__PURE__ */ React.createElement(Context.Provider, { value: contextValue }, children);
+}
+var Provider_default = Provider;
+
+// src/hooks/useStore.ts
+function createStoreHook(context = ReactReduxContext) {
+  const useReduxContext2 = context === ReactReduxContext ? useReduxContext : (
+    // @ts-ignore
+    createReduxContextHook(context)
+  );
+  const useStore2 = () => {
+    const { store } = useReduxContext2();
+    return store;
+  };
+  Object.assign(useStore2, {
+    withTypes: () => useStore2
+  });
+  return useStore2;
+}
+var useStore = /* @__PURE__ */ createStoreHook();
+
+// src/hooks/useDispatch.ts
+function createDispatchHook(context = ReactReduxContext) {
+  const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context);
+  const useDispatch2 = () => {
+    const store = useStore2();
+    return store.dispatch;
+  };
+  Object.assign(useDispatch2, {
+    withTypes: () => useDispatch2
+  });
+  return useDispatch2;
+}
+var useDispatch = /* @__PURE__ */ createDispatchHook();
+
+// src/exports.ts
+var batch = defaultNoopBatch;
+
+// src/index.ts
+initializeUseSelector(withSelectorExports.useSyncExternalStoreWithSelector);
+
+// src/query/react/index.ts
+
+// src/query/endpointDefinitions.ts
+function isQueryDefinition(e) {
+  return e.type === "query" /* query */;
+}
+function isMutationDefinition(e) {
+  return e.type === "mutation" /* mutation */;
+}
+
+// src/query/tsHelpers.ts
+function safeAssign(target, ...args) {
+  return Object.assign(target, ...args);
+}
+
+// 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/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$1(value) ? Object.keys(value).sort().reduce((acc, key2) => {
+        acc[key2] = value[key2];
+        return acc;
+      }, {}) : value;
+      return value;
+    });
+    if (isPlainObject$1(queryArgs)) {
+      cache?.set(queryArgs, stringified);
+    }
+    serialized = stringified;
+  }
+  return `${endpointName}(${serialized})`;
+};
+
+// src/query/react/constants.ts
+var UNINITIALIZED_VALUE = Symbol();
+function useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {
+  const incoming = ReactOriginal.useMemo(() => ({
+    queryArgs,
+    serialized: typeof queryArgs == "object" ? serialize({
+      queryArgs,
+      endpointDefinition,
+      endpointName
+    }) : queryArgs
+  }), [queryArgs, serialize, endpointDefinition, endpointName]);
+  const cache2 = ReactOriginal.useRef(incoming);
+  ReactOriginal.useEffect(() => {
+    if (cache2.current.serialized !== incoming.serialized) {
+      cache2.current = incoming;
+    }
+  }, [incoming]);
+  return cache2.current.serialized === incoming.serialized ? cache2.current.queryArgs : queryArgs;
+}
+function useShallowStableValue(value) {
+  const cache2 = ReactOriginal.useRef(value);
+  ReactOriginal.useEffect(() => {
+    if (!shallowEqual(cache2.current, value)) {
+      cache2.current = value;
+    }
+  }, [value]);
+  return shallowEqual(cache2.current, value) ? cache2.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 ? ReactOriginal.useLayoutEffect : ReactOriginal.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: QueryStatus.pending
+    };
+  }
+  return selected;
+};
+function buildHooks({
+  api,
+  moduleOptions: {
+    batch,
+    hooks: {
+      useDispatch,
+      useSelector,
+      useStore
+    },
+    unstable__sideEffectsInRender,
+    createSelector: createSelector2
+  },
+  serializeQueryArgs,
+  context
+}) {
+  const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : ReactOriginal.useEffect;
+  return {
+    buildQueryHooks,
+    buildMutationHook,
+    usePrefetch
+  };
+  function queryStatePreSelector(currentState, lastResult, queryArgs) {
+    if (lastResult?.endpointName && currentState.isUninitialized) {
+      const {
+        endpointName
+      } = lastResult;
+      const endpointDefinition = context.endpointDefinitions[endpointName];
+      if (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 ReactOriginal.useCallback((arg, options) => dispatch(api.util.prefetch(endpointName, arg, {
+      ...stableDefaultOptions,
+      ...options
+    })), [endpointName, dispatch, stableDefaultOptions]);
+  }
+  function buildQueryHooks(name) {
+    const useQuerySubscription = (arg, {
+      refetchOnReconnect,
+      refetchOnFocus,
+      refetchOnMountOrArgChange,
+      skip = false,
+      pollingInterval = 0,
+      skipPollingIfUnfocused = false
+    } = {}) => {
+      const {
+        initiate
+      } = api.endpoints[name];
+      const dispatch = useDispatch();
+      const subscriptionSelectorsRef = ReactOriginal.useRef(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[name],
+        name
+      );
+      const stableSubscriptionOptions = useShallowStableValue({
+        refetchOnReconnect,
+        refetchOnFocus,
+        pollingInterval,
+        skipPollingIfUnfocused
+      });
+      const lastRenderHadSubscription = ReactOriginal.useRef(false);
+      const promiseRef = ReactOriginal.useRef(void 0);
+      let {
+        queryCacheKey,
+        requestId
+      } = promiseRef.current || {};
+      let currentRenderHasSubscription = false;
+      if (queryCacheKey && requestId) {
+        currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);
+      }
+      const subscriptionRemoved = !currentRenderHasSubscription && lastRenderHadSubscription.current;
+      usePossiblyImmediateEffect(() => {
+        lastRenderHadSubscription.current = currentRenderHasSubscription;
+      });
+      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
+          }));
+          promiseRef.current = promise;
+        } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {
+          lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);
+        }
+      }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved]);
+      ReactOriginal.useEffect(() => {
+        return () => {
+          promiseRef.current?.unsubscribe();
+          promiseRef.current = void 0;
+        };
+      }, []);
+      return ReactOriginal.useMemo(() => ({
+        /**
+         * A method to manually refetch data for the query
+         */
+        refetch: () => {
+          if (!promiseRef.current) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(38) : "Cannot refetch a query that has not been started yet.");
+          return promiseRef.current?.refetch();
+        }
+      }), []);
+    };
+    const useLazyQuerySubscription = ({
+      refetchOnReconnect,
+      refetchOnFocus,
+      pollingInterval = 0,
+      skipPollingIfUnfocused = false
+    } = {}) => {
+      const {
+        initiate
+      } = api.endpoints[name];
+      const dispatch = useDispatch();
+      const [arg, setArg] = ReactOriginal.useState(UNINITIALIZED_VALUE);
+      const promiseRef = ReactOriginal.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 = ReactOriginal.useRef(stableSubscriptionOptions);
+      usePossiblyImmediateEffect(() => {
+        subscriptionOptionsRef.current = stableSubscriptionOptions;
+      }, [stableSubscriptionOptions]);
+      const trigger = ReactOriginal.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]);
+      ReactOriginal.useEffect(() => {
+        return () => {
+          promiseRef?.current?.unsubscribe();
+        };
+      }, []);
+      ReactOriginal.useEffect(() => {
+        if (arg !== UNINITIALIZED_VALUE && !promiseRef.current) {
+          trigger(arg, true);
+        }
+      }, [arg, trigger]);
+      return ReactOriginal.useMemo(() => [trigger, arg], [trigger, arg]);
+    };
+    const useQueryState = (arg, {
+      skip = false,
+      selectFromResult
+    } = {}) => {
+      const {
+        select
+      } = api.endpoints[name];
+      const stableArg = useStableQueryArgs(skip ? skipToken : arg, serializeQueryArgs, context.endpointDefinitions[name], name);
+      const lastValue = ReactOriginal.useRef(void 0);
+      const selectDefaultResult = ReactOriginal.useMemo(() => createSelector2([select(stableArg), (_, lastResult) => lastResult, (_) => stableArg], queryStatePreSelector, {
+        memoizeOptions: {
+          resultEqualityCheck: shallowEqual
+        }
+      }), [select, stableArg]);
+      const querySelector = ReactOriginal.useMemo(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult, {
+        devModeChecks: {
+          identityFunctionCheck: "never"
+        }
+      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);
+      const currentState = useSelector((state) => querySelector(state, lastValue.current), shallowEqual);
+      const store = useStore();
+      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);
+      useIsomorphicLayoutEffect(() => {
+        lastValue.current = newLastValue;
+      }, [newLastValue]);
+      return currentState;
+    };
+    return {
+      useQueryState,
+      useQuerySubscription,
+      useLazyQuerySubscription,
+      useLazyQuery(options) {
+        const [trigger, arg] = useLazyQuerySubscription(options);
+        const queryStateResults = useQueryState(arg, {
+          ...options,
+          skip: arg === UNINITIALIZED_VALUE
+        });
+        const info = ReactOriginal.useMemo(() => ({
+          lastArg: arg
+        }), [arg]);
+        return ReactOriginal.useMemo(() => [trigger, queryStateResults, info], [trigger, queryStateResults, info]);
+      },
+      useQuery(arg, options) {
+        const querySubscriptionResults = useQuerySubscription(arg, options);
+        const queryStateResults = useQueryState(arg, {
+          selectFromResult: arg === skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,
+          ...options
+        });
+        const {
+          data,
+          status,
+          isLoading,
+          isSuccess,
+          isError,
+          error
+        } = queryStateResults;
+        ReactOriginal.useDebugValue({
+          data,
+          status,
+          isLoading,
+          isSuccess,
+          isError,
+          error
+        });
+        return ReactOriginal.useMemo(() => ({
+          ...queryStateResults,
+          ...querySubscriptionResults
+        }), [queryStateResults, querySubscriptionResults]);
+      }
+    };
+  }
+  function buildMutationHook(name) {
+    return ({
+      selectFromResult,
+      fixedCacheKey
+    } = {}) => {
+      const {
+        select,
+        initiate
+      } = api.endpoints[name];
+      const dispatch = useDispatch();
+      const [promise, setPromise] = ReactOriginal.useState();
+      ReactOriginal.useEffect(() => () => {
+        if (!promise?.arg.fixedCacheKey) {
+          promise?.reset();
+        }
+      }, [promise]);
+      const triggerMutation = ReactOriginal.useCallback(function(arg) {
+        const promise2 = dispatch(initiate(arg, {
+          fixedCacheKey
+        }));
+        setPromise(promise2);
+        return promise2;
+      }, [dispatch, initiate, fixedCacheKey]);
+      const {
+        requestId
+      } = promise || {};
+      const selectDefaultResult = ReactOriginal.useMemo(() => select({
+        fixedCacheKey,
+        requestId: promise?.requestId
+      }), [fixedCacheKey, promise, select]);
+      const mutationSelector = ReactOriginal.useMemo(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult) : selectDefaultResult, [selectFromResult, selectDefaultResult]);
+      const currentState = useSelector(mutationSelector, shallowEqual);
+      const originalArgs = fixedCacheKey == null ? promise?.arg.originalArgs : void 0;
+      const reset = ReactOriginal.useCallback(() => {
+        batch(() => {
+          if (promise) {
+            setPromise(void 0);
+          }
+          if (fixedCacheKey) {
+            dispatch(api.internalActions.removeMutationResult({
+              requestId,
+              fixedCacheKey
+            }));
+          }
+        });
+      }, [dispatch, fixedCacheKey, promise, requestId]);
+      const {
+        endpointName,
+        data,
+        status,
+        isLoading,
+        isSuccess,
+        isError,
+        error
+      } = currentState;
+      ReactOriginal.useDebugValue({
+        endpointName,
+        data,
+        status,
+        isLoading,
+        isSuccess,
+        isError,
+        error
+      });
+      const finalState = ReactOriginal.useMemo(() => ({
+        ...currentState,
+        originalArgs,
+        reset
+      }), [currentState, originalArgs, reset]);
+      return ReactOriginal.useMemo(() => [triggerMutation, finalState], [triggerMutation, finalState]);
+    };
+  }
+}
+
+// src/query/react/module.ts
+var reactHooksModuleName = /* @__PURE__ */ Symbol();
+var reactHooksModule = ({
+  batch: batch$1 = batch,
+  hooks = {
+    useDispatch: useDispatch,
+    useSelector: useSelector,
+    useStore: useStore
+  },
+  createSelector: createSelector2 = 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" ? formatProdErrorMessage(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,
+        buildMutationHook,
+        usePrefetch
+      } = buildHooks({
+        api,
+        moduleOptions: {
+          batch: batch$1,
+          hooks,
+          unstable__sideEffectsInRender,
+          createSelector: createSelector2
+        },
+        serializeQueryArgs,
+        context
+      });
+      safeAssign(anyApi, {
+        usePrefetch
+      });
+      safeAssign(context, {
+        batch: batch$1
+      });
+      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;
+          } else if (isMutationDefinition(definition)) {
+            const useMutation = buildMutationHook(endpointName);
+            safeAssign(anyApi.endpoints[endpointName], {
+              useMutation
+            });
+            api[`use${capitalize(endpointName)}Mutation`] = useMutation;
+          }
+        }
+      };
+    }
+  };
+};
+function ApiProvider(props) {
+  const context = props.context || ReactReduxContext;
+  const existingContext = ReactOriginal.useContext(context);
+  if (existingContext) {
+    throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(35) : "Existing Redux context detected. If you already have a store set up, please use the traditional Redux setup.");
+  }
+  const [store] = ReactOriginal__namespace.useState(() => configureStore({
+    reducer: {
+      [props.api.reducerPath]: props.api.reducer
+    },
+    middleware: (gDM) => gDM().concat(props.api.middleware)
+  }));
+  ReactOriginal.useEffect(() => props.setupListeners === false ? void 0 : setupListeners(store.dispatch, props.setupListeners), [props.setupListeners, store.dispatch]);
+  return /* @__PURE__ */ ReactOriginal__namespace.createElement(Provider_default, { store, context }, props.children);
+}
+
+// src/query/react/index.ts
+var createApi = /* @__PURE__ */ buildCreateApi(coreModule(), reactHooksModule());
 
-var rtkQuery_modern = /*#__PURE__*/Object.freeze({
+var rtkQueryReact_modern = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  ApiProvider: ApiProvider,
   QueryStatus: QueryStatus,
+  UNINITIALIZED_VALUE: UNINITIALIZED_VALUE,
   _NEVER: _NEVER,
   buildCreateApi: buildCreateApi,
   copyWithStructuralSharing: copyWithStructuralSharing,
   coreModule: coreModule,
   coreModuleName: coreModuleName,
   createApi: createApi,
-  defaultSerializeQueryArgs: defaultSerializeQueryArgs,
+  defaultSerializeQueryArgs: defaultSerializeQueryArgs$1,
   fakeBaseQuery: fakeBaseQuery,
   fetchBaseQuery: fetchBaseQuery,
+  reactHooksModule: reactHooksModule,
+  reactHooksModuleName: reactHooksModuleName,
   retry: retry,
   setupListeners: setupListeners,
   skipToken: skipToken
@@ -6464,7 +7661,7 @@ exports.miniSerializeError = miniSerializeError;
 exports.nanoid = nanoid;
 exports.original = original$1;
 exports.prepareAutoBatched = prepareAutoBatched;
-exports.reactQuery = rtkQuery_modern;
+exports.reactQuery = rtkQueryReact_modern;
 exports.removeListener = removeListener;
 exports.unwrapResult = unwrapResult;
 exports.weakMapMemoize = weakMapMemoize;