@ynput/ayon-frontend-shared 0.2.34 → 0.2.36

package/dist/node_modules/@reduxjs/toolkit/dist/query/rtk-query.modern.es.js

@@ -1,9 +1,9 @@
-import { isPlainObject as fe, nanoid as Ge, formatProdErrorMessage as ve, createAction as ue, createSelector as ut, createNextState as Ie, createAsyncThunk as je, createSlice as oe, prepareAutoBatched as le, isAnyOf as be, isFulfilled as ne, isRejectedWithValue as Te, combineReducers as lt, SHOULD_AUTOBATCH as Xe, isAllOf as we, isRejected as Oe, isPending as Ze, isAction as dt, isAsyncThunkAction as ke } from "@reduxjs/toolkit";
-import { enablePatches as ft, applyPatches as _e, isDraftable as pt, produceWithPatches as et, isDraft as yt, original as gt } from "../../../../immer/dist/immer.es.js";
-import { SchemaError as ht } from "../../../../@standard-schema/utils/dist/index.es.js";
-import { weakMapMemoize as xe } from "../../../../reselect/dist/reselect.es.js";
-var mt = /* @__PURE__ */ ((e) => (e.uninitialized = "uninitialized", e.pending = "pending", e.fulfilled = "fulfilled", e.rejected = "rejected", e))(mt || {});
-function Fe(e) {
+import { isPlainObject as fe, nanoid as tt, formatProdErrorMessage as ve, createAction as ue, createSelector as pt, createNextState as qe, createAsyncThunk as _e, createSlice as ae, prepareAutoBatched as le, isAnyOf as be, isFulfilled as re, isRejectedWithValue as Me, combineReducers as gt, SHOULD_AUTOBATCH as nt, isAllOf as Pe, isRejected as Oe, isPending as rt, isAction as ht, isAsyncThunkAction as xe } from "@reduxjs/toolkit";
+import { enablePatches as yt, applyPatches as Fe, isDraftable as mt, produceWithPatches as it, original as vt, isDraft as bt } from "../../../../immer/dist/immer.es.js";
+import { SchemaError as St } from "../../../../@standard-schema/utils/dist/index.es.js";
+import { weakMapMemoize as $e } from "../../../../reselect/dist/reselect.es.js";
+var Rt = /* @__PURE__ */ ((e) => (e.uninitialized = "uninitialized", e.pending = "pending", e.fulfilled = "fulfilled", e.rejected = "rejected", e))(Rt || {});
+function Ue(e) {
   return {
     status: e,
     isUninitialized: e === "uninitialized",
@@ -13,1337 +13,1342 @@ function Fe(e) {
     /* rejected */
   };
 }
-var $e = fe;
-function tt(e, r) {
-  if (e === r || !($e(e) && $e(r) || Array.isArray(e) && Array.isArray(r)))
-    return r;
-  const p = Object.keys(r), v = Object.keys(e);
-  let y = p.length === v.length;
-  const q = Array.isArray(r) ? [] : {};
-  for (const b of p)
-    q[b] = tt(e[b], r[b]), y && (y = e[b] === q[b]);
-  return y ? e : q;
-}
-function ce(e) {
-  let r = 0;
-  for (const p in e)
-    r++;
-  return r;
+var Ke = fe;
+function st(e, i) {
+  if (e === i || !(Ke(e) && Ke(i) || Array.isArray(e) && Array.isArray(i)))
+    return i;
+  const p = Object.keys(i), S = Object.keys(e);
+  let y = p.length === S.length;
+  const P = Array.isArray(i) ? [] : {};
+  for (const v of p)
+    P[v] = st(e[v], i[v]), y && (y = e[v] === P[v]);
+  return y ? e : P;
 }
-var Ke = (e) => [].concat(...e);
-function vt(e) {
+var Ve = (e) => [].concat(...e);
+function wt(e) {
   return new RegExp("(^|:)//").test(e);
 }
-function bt() {
+function Pt() {
   return typeof document > "u" ? !0 : document.visibilityState !== "hidden";
 }
-function Se(e) {
+function Ne(e) {
   return e != null;
 }
-function St() {
+function ze(e) {
+  return [...(e == null ? void 0 : e.values()) ?? []].filter(Ne);
+}
+function Et() {
   return typeof navigator > "u" || navigator.onLine === void 0 ? !0 : navigator.onLine;
 }
-var Rt = (e) => e.replace(/\/$/, ""), Pt = (e) => e.replace(/^\//, "");
-function wt(e, r) {
+var At = (e) => e.replace(/\/$/, ""), Qt = (e) => e.replace(/^\//, "");
+function It(e, i) {
   if (!e)
-    return r;
-  if (!r)
+    return i;
+  if (!i)
     return e;
-  if (vt(r))
-    return r;
-  const p = e.endsWith("/") || !r.startsWith("?") ? "/" : "";
-  return e = Rt(e), r = Pt(r), `${e}${p}${r}`;
+  if (wt(i))
+    return i;
+  const p = e.endsWith("/") || !i.startsWith("?") ? "/" : "";
+  return e = At(e), i = Qt(i), `${e}${p}${i}`;
 }
-function At(e, r, p) {
-  return e.has(r) ? e.get(r) : e.set(r, p).get(r);
+function Se(e, i, p) {
+  return e.has(i) ? e.get(i) : e.set(i, p(i)).get(i);
 }
-var Ue = (...e) => fetch(...e), Et = (e) => e.status >= 200 && e.status <= 299, Qt = (e) => (
+var Ae = () => /* @__PURE__ */ new Map(), Be = (...e) => fetch(...e), Tt = (e) => e.status >= 200 && e.status <= 299, qt = (e) => (
   /*applicat*/
   /ion\/(vnd\.api\+)?json/.test(e.get("content-type") || "")
 );
-function Ve(e) {
+function We(e) {
   if (!fe(e))
     return e;
-  const r = {
+  const i = {
     ...e
   };
-  for (const [p, v] of Object.entries(r))
-    v === void 0 && delete r[p];
-  return r;
+  for (const [p, S] of Object.entries(i))
+    S === void 0 && delete i[p];
+  return i;
 }
-function Xt({
+var Mt = (e) => typeof e == "object" && (fe(e) || Array.isArray(e) || typeof e.toJSON == "function");
+function en({
   baseUrl: e,
-  prepareHeaders: r = (S) => S,
-  fetchFn: p = Ue,
-  paramsSerializer: v,
-  isJsonContentType: y = Qt,
-  jsonContentType: q = "application/json",
-  jsonReplacer: b,
-  timeout: O,
-  responseHandler: j,
-  validateStatus: E,
-  ...D
+  prepareHeaders: i = (A) => A,
+  fetchFn: p = Be,
+  paramsSerializer: S,
+  isJsonContentType: y = qt,
+  jsonContentType: P = "application/json",
+  jsonReplacer: v,
+  timeout: M,
+  responseHandler: D,
+  validateStatus: I,
+  ...O
 } = {}) {
-  return typeof fetch > "u" && p === Ue && console.warn("Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments."), async (f, u, m) => {
+  return typeof fetch > "u" && p === Be && console.warn("Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments."), async (E, Q, q) => {
     const {
-      getState: A,
-      extra: h,
-      endpoint: l,
-      forced: I,
-      type: c
-    } = u;
-    let n, {
-      url: d,
-      headers: P = new Headers(D.headers),
-      params: w = void 0,
-      responseHandler: Q = j ?? "json",
-      validateStatus: g = E ?? Et,
-      timeout: a = O,
+      getState: R,
+      extra: d,
+      endpoint: u,
+      forced: b,
+      type: o
+    } = Q;
+    let r, {
+      url: a,
+      headers: h = new Headers(O.headers),
+      params: m = void 0,
+      responseHandler: g = D ?? "json",
+      validateStatus: f = I ?? Tt,
+      timeout: c = M,
       ...t
-    } = typeof f == "string" ? {
-      url: f
-    } : f, i, s = u.signal;
-    a && (i = new AbortController(), u.signal.addEventListener("abort", i.abort), s = i.signal);
-    let o = {
-      ...D,
-      signal: s,
+    } = typeof E == "string" ? {
+      url: E
+    } : E, n, l = Q.signal;
+    c && (n = new AbortController(), Q.signal.addEventListener("abort", n.abort), l = n.signal);
+    let s = {
+      ...O,
+      signal: l,
       ...t
     };
-    P = new Headers(Ve(P)), o.headers = await r(P, {
-      getState: A,
-      arg: f,
-      extra: h,
-      endpoint: l,
-      forced: I,
-      type: c,
-      extraOptions: m
-    }) || P;
-    const R = (K) => typeof K == "object" && (fe(K) || Array.isArray(K) || typeof K.toJSON == "function");
-    if (!o.headers.has("content-type") && R(o.body) && o.headers.set("content-type", q), R(o.body) && y(o.headers) && (o.body = JSON.stringify(o.body, b)), w) {
-      const K = ~d.indexOf("?") ? "&" : "?", N = v ? v(w) : new URLSearchParams(Ve(w));
-      d += K + N;
+    h = new Headers(We(h)), s.headers = await i(h, {
+      getState: R,
+      arg: E,
+      extra: d,
+      endpoint: u,
+      forced: b,
+      type: o,
+      extraOptions: q
+    }) || h;
+    const w = Mt(s.body);
+    if (s.body != null && !w && typeof s.body != "string" && s.headers.delete("content-type"), !s.headers.has("content-type") && w && s.headers.set("content-type", P), w && y(s.headers) && (s.body = JSON.stringify(s.body, v)), s.headers.has("accept") || (g === "json" ? s.headers.set("accept", "application/json") : g === "text" && s.headers.set("accept", "text/plain, text/html, */*")), m) {
+      const K = ~a.indexOf("?") ? "&" : "?", F = S ? S(m) : new URLSearchParams(We(m));
+      a += K + F;
     }
-    d = wt(e, d);
-    const C = new Request(d, o);
-    n = {
-      request: new Request(d, o)
+    a = It(e, a);
+    const N = new Request(a, s);
+    r = {
+      request: new Request(a, s)
     };
-    let M, T = !1, x = i && setTimeout(() => {
-      T = !0, i.abort();
-    }, a);
+    let k, T = !1, _ = n && setTimeout(() => {
+      T = !0, n.abort();
+    }, c);
     try {
-      M = await p(C);
+      k = await p(N);
     } catch (K) {
       return {
         error: {
           status: T ? "TIMEOUT_ERROR" : "FETCH_ERROR",
           error: String(K)
         },
-        meta: n
+        meta: r
       };
     } finally {
-      x && clearTimeout(x), i == null || i.signal.removeEventListener("abort", i.abort);
+      _ && clearTimeout(_), n == null || n.signal.removeEventListener("abort", n.abort);
     }
-    const F = M.clone();
-    n.response = F;
-    let z, H = "";
+    const U = k.clone();
+    r.response = U;
+    let B, L = "";
     try {
       let K;
       if (await Promise.all([
-        S(M, Q).then((N) => z = N, (N) => K = N),
+        A(k, g).then((F) => B = F, (F) => K = F),
         // 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
-        F.text().then((N) => H = N, () => {
+        U.text().then((F) => L = F, () => {
         })
       ]), K) throw K;
     } catch (K) {
       return {
         error: {
           status: "PARSING_ERROR",
-          originalStatus: M.status,
-          data: H,
+          originalStatus: k.status,
+          data: L,
           error: String(K)
         },
-        meta: n
+        meta: r
       };
     }
-    return g(M, z) ? {
-      data: z,
-      meta: n
+    return f(k, B) ? {
+      data: B,
+      meta: r
     } : {
       error: {
-        status: M.status,
-        data: z
+        status: k.status,
+        data: B
       },
-      meta: n
+      meta: r
     };
   };
-  async function S(f, u) {
-    if (typeof u == "function")
-      return u(f);
-    if (u === "content-type" && (u = y(f.headers) ? "json" : "text"), u === "json") {
-      const m = await f.text();
-      return m.length ? JSON.parse(m) : null;
+  async function A(E, Q) {
+    if (typeof Q == "function")
+      return Q(E);
+    if (Q === "content-type" && (Q = y(E.headers) ? "json" : "text"), Q === "json") {
+      const q = await E.text();
+      return q.length ? JSON.parse(q) : null;
     }
-    return f.text();
+    return E.text();
   }
 }
-var Be = class {
-  constructor(e, r = void 0) {
-    this.value = e, this.meta = r;
+var He = class {
+  constructor(e, i = void 0) {
+    this.value = e, this.meta = i;
   }
-}, Me = /* @__PURE__ */ ue("__rtkq/focused"), nt = /* @__PURE__ */ ue("__rtkq/unfocused"), Ne = /* @__PURE__ */ ue("__rtkq/online"), rt = /* @__PURE__ */ ue("__rtkq/offline");
-function Pe(e) {
+}, De = /* @__PURE__ */ ue("__rtkq/focused"), ot = /* @__PURE__ */ ue("__rtkq/unfocused"), ke = /* @__PURE__ */ ue("__rtkq/online"), at = /* @__PURE__ */ ue("__rtkq/offline");
+function we(e) {
   return e.type === "query";
 }
-function qt(e) {
+function Ot(e) {
   return e.type === "mutation";
 }
-function ge(e) {
+function he(e) {
   return e.type === "infinitequery";
 }
 function Re(e) {
-  return Pe(e) || ge(e);
+  return we(e) || he(e);
 }
-function De(e, r, p, v, y, q) {
-  return It(e) ? e(r, p, v, y).filter(Se).map(Ee).map(q) : Array.isArray(e) ? e.map(Ee).map(q) : [];
+function Ce(e, i, p, S, y, P) {
+  return Nt(e) ? e(i, p, S, y).filter(Ne).map(Qe).map(P) : Array.isArray(e) ? e.map(Qe).map(P) : [];
 }
-function It(e) {
+function Nt(e) {
   return typeof e == "function";
 }
-function Ee(e) {
+function Qe(e) {
   return typeof e == "string" ? {
     type: e
   } : e;
 }
-function Tt(e, r) {
-  return e.catch(r);
+function Dt(e, i) {
+  return e.catch(i);
 }
-var pe = Symbol("forceQueryFn"), Qe = (e) => typeof e[pe] == "function";
-function Ot({
+var pe = Symbol("forceQueryFn"), Ie = (e) => typeof e[pe] == "function";
+function kt({
   serializeQueryArgs: e,
-  queryThunk: r,
+  queryThunk: i,
   infiniteQueryThunk: p,
-  mutationThunk: v,
+  mutationThunk: S,
   api: y,
-  context: q
+  context: P,
+  getInternalState: v
 }) {
-  const b = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map(), {
-    unsubscribeQueryResult: j,
-    removeMutationResult: E,
-    updateSubscriptionOptions: D
+  const M = (a) => {
+    var h;
+    return (h = v(a)) == null ? void 0 : h.runningQueries;
+  }, D = (a) => {
+    var h;
+    return (h = v(a)) == null ? void 0 : h.runningMutations;
+  }, {
+    unsubscribeQueryResult: I,
+    removeMutationResult: O,
+    updateSubscriptionOptions: A
   } = y.internalActions;
   return {
-    buildInitiateQuery: l,
-    buildInitiateInfiniteQuery: I,
-    buildInitiateMutation: c,
-    getRunningQueryThunk: S,
-    getRunningMutationThunk: f,
-    getRunningQueriesThunk: u,
-    getRunningMutationsThunk: m
+    buildInitiateQuery: b,
+    buildInitiateInfiniteQuery: o,
+    buildInitiateMutation: r,
+    getRunningQueryThunk: E,
+    getRunningMutationThunk: Q,
+    getRunningQueriesThunk: q,
+    getRunningMutationsThunk: R
   };
-  function S(n, d) {
-    return (P) => {
-      var g;
-      const w = q.endpointDefinitions[n], Q = e({
-        queryArgs: d,
-        endpointDefinition: w,
-        endpointName: n
+  function E(a, h) {
+    return (m) => {
+      var c;
+      const g = P.endpointDefinitions[a], f = e({
+        queryArgs: h,
+        endpointDefinition: g,
+        endpointName: a
       });
-      return (g = b.get(P)) == null ? void 0 : g[Q];
+      return (c = M(m)) == null ? void 0 : c.get(f);
     };
   }
-  function f(n, d) {
-    return (P) => {
-      var w;
-      return (w = O.get(P)) == null ? void 0 : w[d];
+  function Q(a, h) {
+    return (m) => {
+      var g;
+      return (g = D(m)) == null ? void 0 : g.get(h);
     };
   }
-  function u() {
-    return (n) => Object.values(b.get(n) || {}).filter(Se);
+  function q() {
+    return (a) => ze(M(a));
   }
-  function m() {
-    return (n) => Object.values(O.get(n) || {}).filter(Se);
+  function R() {
+    return (a) => ze(D(a));
   }
-  function A(n) {
+  function d(a) {
     if (process.env.NODE_ENV !== "production") {
-      if (A.triggered) return;
-      const d = n(y.internalActions.internal_getRTKQSubscriptions());
-      if (A.triggered = !0, typeof d != "object" || typeof (d == null ? void 0 : d.type) == "string")
+      if (d.triggered) return;
+      const h = a(y.internalActions.internal_getRTKQSubscriptions());
+      if (d.triggered = !0, typeof h != "object" || typeof (h == null ? void 0 : h.type) == "string")
         throw new Error(process.env.NODE_ENV === "production" ? ve(34) : `Warning: Middleware for RTK-Query API at reducerPath "${y.reducerPath}" has not been added to the store.
 You must add the middleware for RTK-Query to function correctly!`);
     }
   }
-  function h(n, d) {
-    const P = (w, {
-      subscribe: Q = !0,
-      forceRefetch: g,
-      subscriptionOptions: a,
-      [pe]: t,
-      ...i
-    } = {}) => (s, o) => {
-      var B;
-      const R = e({
-        queryArgs: w,
-        endpointDefinition: d,
-        endpointName: n
+  function u(a, h) {
+    const m = (g, {
+      subscribe: f = !0,
+      forceRefetch: c,
+      subscriptionOptions: t,
+      [pe]: n,
+      ...l
+    } = {}) => (s, w) => {
+      var z;
+      const N = e({
+        queryArgs: g,
+        endpointDefinition: h,
+        endpointName: a
       });
-      let C;
+      let x;
       const k = {
-        ...i,
+        ...l,
         type: "query",
-        subscribe: Q,
-        forceRefetch: g,
-        subscriptionOptions: a,
-        endpointName: n,
-        originalArgs: w,
-        queryCacheKey: R,
-        [pe]: t
+        subscribe: f,
+        forceRefetch: c,
+        subscriptionOptions: t,
+        endpointName: a,
+        originalArgs: g,
+        queryCacheKey: N,
+        [pe]: n
       };
-      if (Pe(d))
-        C = r(k);
+      if (we(h))
+        x = i(k);
       else {
         const {
-          direction: U,
-          initialPageParam: L
-        } = i;
-        C = p({
+          direction: V,
+          initialPageParam: $
+        } = l;
+        x = p({
           ...k,
           // Supply these even if undefined. This helps with a field existence
           // check over in `buildSlice.ts`
-          direction: U,
-          initialPageParam: L
+          direction: V,
+          initialPageParam: $
         });
       }
-      const M = y.endpoints[n].select(w), T = s(C), x = M(o());
-      A(s);
+      const T = y.endpoints[a].select(g), _ = s(x), U = T(w());
+      d(s);
       const {
-        requestId: F,
-        abort: z
-      } = T, H = x.requestId !== F, K = (B = b.get(s)) == null ? void 0 : B[R], N = () => M(o()), $ = Object.assign(t ? (
+        requestId: B,
+        abort: L
+      } = _, K = U.requestId !== B, F = (z = M(s)) == null ? void 0 : z.get(N), W = () => T(w()), C = Object.assign(n ? (
         // a query has been forced (upsertQueryData)
         // -> we want to resolve it once data has been written with the data that will be written
-        T.then(N)
-      ) : H && !K ? (
+        _.then(W)
+      ) : K && !F ? (
         // 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(x)
+        Promise.resolve(U)
       ) : (
         // query just started or one is already in flight
         // -> wait for the running query, then resolve with data from after that
-        Promise.all([K, T]).then(N)
+        Promise.all([F, _]).then(W)
       ), {
-        arg: w,
-        requestId: F,
-        subscriptionOptions: a,
-        queryCacheKey: R,
-        abort: z,
+        arg: g,
+        requestId: B,
+        subscriptionOptions: t,
+        queryCacheKey: N,
+        abort: L,
         async unwrap() {
-          const U = await $;
-          if (U.isError)
-            throw U.error;
-          return U.data;
+          const V = await C;
+          if (V.isError)
+            throw V.error;
+          return V.data;
         },
-        refetch: () => s(P(w, {
+        refetch: () => s(m(g, {
           subscribe: !1,
           forceRefetch: !0
         })),
         unsubscribe() {
-          Q && s(j({
-            queryCacheKey: R,
-            requestId: F
+          f && s(I({
+            queryCacheKey: N,
+            requestId: B
           }));
         },
-        updateSubscriptionOptions(U) {
-          $.subscriptionOptions = U, s(D({
-            endpointName: n,
-            requestId: F,
-            queryCacheKey: R,
-            options: U
+        updateSubscriptionOptions(V) {
+          C.subscriptionOptions = V, s(A({
+            endpointName: a,
+            requestId: B,
+            queryCacheKey: N,
+            options: V
           }));
         }
       });
-      if (!K && !H && !t) {
-        const U = At(b, s, {});
-        U[R] = $, $.then(() => {
-          delete U[R], ce(U) || b.delete(s);
+      if (!F && !K && !n) {
+        const V = M(s);
+        V.set(N, C), C.then(() => {
+          V.delete(N);
         });
       }
-      return $;
+      return C;
     };
-    return P;
+    return m;
   }
-  function l(n, d) {
-    return h(n, d);
+  function b(a, h) {
+    return u(a, h);
   }
-  function I(n, d) {
-    return h(n, d);
+  function o(a, h) {
+    return u(a, h);
   }
-  function c(n) {
-    return (d, {
-      track: P = !0,
-      fixedCacheKey: w
-    } = {}) => (Q, g) => {
-      const a = v({
+  function r(a) {
+    return (h, {
+      track: m = !0,
+      fixedCacheKey: g
+    } = {}) => (f, c) => {
+      const t = S({
         type: "mutation",
-        endpointName: n,
-        originalArgs: d,
-        track: P,
-        fixedCacheKey: w
-      }), t = Q(a);
-      A(Q);
+        endpointName: a,
+        originalArgs: h,
+        track: m,
+        fixedCacheKey: g
+      }), n = f(t);
+      d(f);
       const {
-        requestId: i,
+        requestId: l,
         abort: s,
-        unwrap: o
-      } = t, R = Tt(t.unwrap().then((T) => ({
-        data: T
-      })), (T) => ({
-        error: T
-      })), C = () => {
-        Q(E({
-          requestId: i,
-          fixedCacheKey: w
+        unwrap: w
+      } = n, N = Dt(n.unwrap().then((_) => ({
+        data: _
+      })), (_) => ({
+        error: _
+      })), x = () => {
+        f(O({
+          requestId: l,
+          fixedCacheKey: g
         }));
-      }, k = Object.assign(R, {
-        arg: t.arg,
-        requestId: i,
+      }, k = Object.assign(N, {
+        arg: n.arg,
+        requestId: l,
         abort: s,
-        unwrap: o,
-        reset: C
-      }), M = O.get(Q) || {};
-      return O.set(Q, M), M[i] = k, k.then(() => {
-        delete M[i], ce(M) || O.delete(Q);
-      }), w && (M[w] = k, k.then(() => {
-        M[w] === k && (delete M[w], ce(M) || O.delete(Q));
+        unwrap: w,
+        reset: x
+      }), T = D(f);
+      return T.set(l, k), k.then(() => {
+        T.delete(l);
+      }), g && (T.set(g, k), k.then(() => {
+        T.get(g) === k && T.delete(g);
       })), k;
     };
   }
 }
-var it = class extends ht {
-  constructor(e, r, p, v) {
-    super(e), this.value = r, this.schemaName = p, this._bqMeta = v;
+var ct = class extends St {
+  constructor(e, i, p, S) {
+    super(e), this.value = i, this.schemaName = p, this._bqMeta = S;
   }
-};
-async function te(e, r, p, v) {
-  const y = await e["~standard"].validate(r);
+}, te = (e, i) => Array.isArray(e) ? e.includes(i) : !!e;
+async function ne(e, i, p, S) {
+  const y = await e["~standard"].validate(i);
   if (y.issues)
-    throw new it(y.issues, r, p, v);
+    throw new ct(y.issues, i, p, S);
   return y.value;
 }
-function Mt(e) {
+function Le(e) {
   return e;
 }
 var de = (e = {}) => ({
   ...e,
-  [Xe]: !0
+  [nt]: !0
 });
-function Nt({
+function Ct({
   reducerPath: e,
-  baseQuery: r,
+  baseQuery: i,
   context: {
     endpointDefinitions: p
   },
-  serializeQueryArgs: v,
+  serializeQueryArgs: S,
   api: y,
-  assertTagType: q,
-  selectors: b,
-  onSchemaFailure: O,
-  catchSchemaFailure: j,
-  skipSchemaValidation: E
+  assertTagType: P,
+  selectors: v,
+  onSchemaFailure: M,
+  catchSchemaFailure: D,
+  skipSchemaValidation: I
 }) {
-  const D = (t, i, s, o) => (R, C) => {
-    const k = p[t], M = v({
-      queryArgs: i,
-      endpointDefinition: k,
+  const O = (t, n, l, s) => (w, N) => {
+    const x = p[t], k = S({
+      queryArgs: n,
+      endpointDefinition: x,
       endpointName: t
     });
-    if (R(y.internalActions.queryResultPatched({
-      queryCacheKey: M,
-      patches: s
-    })), !o)
+    if (w(y.internalActions.queryResultPatched({
+      queryCacheKey: k,
+      patches: l
+    })), !s)
       return;
-    const T = y.endpoints[t].select(i)(
+    const T = y.endpoints[t].select(n)(
       // Work around TS 4.1 mismatch
-      C()
-    ), x = De(k.providesTags, T.data, void 0, i, {}, q);
-    R(y.internalActions.updateProvidedBy([{
-      queryCacheKey: M,
-      providedTags: x
+      N()
+    ), _ = Ce(x.providesTags, T.data, void 0, n, {}, P);
+    w(y.internalActions.updateProvidedBy([{
+      queryCacheKey: k,
+      providedTags: _
     }]));
   };
-  function S(t, i, s = 0) {
-    const o = [i, ...t];
-    return s && o.length > s ? o.slice(0, -1) : o;
+  function A(t, n, l = 0) {
+    const s = [n, ...t];
+    return l && s.length > l ? s.slice(0, -1) : s;
   }
-  function f(t, i, s = 0) {
-    const o = [...t, i];
-    return s && o.length > s ? o.slice(1) : o;
+  function E(t, n, l = 0) {
+    const s = [...t, n];
+    return l && s.length > l ? s.slice(1) : s;
   }
-  const u = (t, i, s, o = !0) => (R, C) => {
-    const M = y.endpoints[t].select(i)(
+  const Q = (t, n, l, s = !0) => (w, N) => {
+    const k = y.endpoints[t].select(n)(
       // Work around TS 4.1 mismatch
-      C()
+      N()
     ), T = {
       patches: [],
       inversePatches: [],
-      undo: () => R(y.util.patchQueryData(t, i, T.inversePatches, o))
+      undo: () => w(y.util.patchQueryData(t, n, T.inversePatches, s))
     };
-    if (M.status === "uninitialized")
+    if (k.status === "uninitialized")
       return T;
-    let x;
-    if ("data" in M)
-      if (pt(M.data)) {
-        const [F, z, H] = et(M.data, s);
-        T.patches.push(...z), T.inversePatches.push(...H), x = F;
+    let _;
+    if ("data" in k)
+      if (mt(k.data)) {
+        const [U, B, L] = it(k.data, l);
+        T.patches.push(...B), T.inversePatches.push(...L), _ = U;
       } else
-        x = s(M.data), T.patches.push({
+        _ = l(k.data), T.patches.push({
           op: "replace",
           path: [],
-          value: x
+          value: _
         }), T.inversePatches.push({
           op: "replace",
           path: [],
-          value: M.data
+          value: k.data
         });
-    return T.patches.length === 0 || R(y.util.patchQueryData(t, i, T.patches, o)), T;
-  }, m = (t, i, s) => (o) => o(y.endpoints[t].initiate(i, {
+    return T.patches.length === 0 || w(y.util.patchQueryData(t, n, T.patches, s)), T;
+  }, q = (t, n, l) => (s) => s(y.endpoints[t].initiate(n, {
     subscribe: !1,
     forceRefetch: !0,
     [pe]: () => ({
-      data: s
+      data: l
     })
-  })), A = (t, i) => t.query && t[i] ? t[i] : Mt, h = async (t, {
-    signal: i,
-    abort: s,
-    rejectWithValue: o,
-    fulfillWithValue: R,
-    dispatch: C,
-    getState: k,
-    extra: M
+  })), R = (t, n) => t.query && t[n] ? t[n] : Le, d = async (t, {
+    signal: n,
+    abort: l,
+    rejectWithValue: s,
+    fulfillWithValue: w,
+    dispatch: N,
+    getState: x,
+    extra: k
   }) => {
-    var z, H;
+    var B, L;
     const T = p[t.endpointName], {
-      metaSchema: x,
-      skipSchemaValidation: F = E
+      metaSchema: _,
+      skipSchemaValidation: U = I
     } = T;
     try {
-      let K = A(T, "transformResponse");
-      const N = {
-        signal: i,
-        abort: s,
-        dispatch: C,
-        getState: k,
-        extra: M,
+      let K = Le;
+      const F = {
+        signal: n,
+        abort: l,
+        dispatch: N,
+        getState: x,
+        extra: k,
         endpoint: t.endpointName,
         type: t.type,
-        forced: t.type === "query" ? l(t, k()) : void 0,
+        forced: t.type === "query" ? u(t, x()) : void 0,
         queryCacheKey: t.type === "query" ? t.queryCacheKey : void 0
-      }, $ = t.type === "query" ? t[pe] : void 0;
-      let B;
-      const U = async (V, _, W, re) => {
-        if (_ == null && V.pages.length)
+      }, W = t.type === "query" ? t[pe] : void 0;
+      let C;
+      const z = async ($, j, H, ie) => {
+        if (j == null && $.pages.length)
           return Promise.resolve({
-            data: V
+            data: $
           });
         const G = {
           queryArg: t.originalArgs,
-          pageParam: _
-        }, ie = await L(G), X = re ? S : f;
+          pageParam: j
+        }, se = await V(G), X = ie ? A : E;
         return {
           data: {
-            pages: X(V.pages, ie.data, W),
-            pageParams: X(V.pageParams, _, W)
+            pages: X($.pages, se.data, H),
+            pageParams: X($.pageParams, j, H)
           },
-          meta: ie.meta
+          meta: se.meta
         };
       };
-      async function L(V) {
-        let _;
+      async function V($) {
+        let j;
         const {
-          extraOptions: W,
-          argSchema: re,
+          extraOptions: H,
+          argSchema: ie,
           rawResponseSchema: G,
-          responseSchema: ie
+          responseSchema: se
         } = T;
-        if (re && !F && (V = await te(
-          re,
-          V,
+        if (ie && !te(U, "arg") && ($ = await ne(
+          ie,
+          $,
           "argSchema",
           {}
           // we don't have a meta yet, so we can't pass it
-        )), $ ? _ = $() : T.query ? _ = await r(T.query(V), N, W) : _ = await T.queryFn(V, N, W, (J) => r(J, N, W)), typeof process < "u" && process.env.NODE_ENV === "development") {
+        )), W ? j = W() : T.query ? (K = R(T, "transformResponse"), j = await i(T.query($), F, H)) : j = await T.queryFn($, F, H, (J) => i(J, F, H)), typeof process < "u" && process.env.NODE_ENV === "development") {
           const J = T.query ? "`baseQuery`" : "`queryFn`";
           let Y;
-          if (!_)
+          if (!j)
             Y = `${J} did not return anything.`;
-          else if (typeof _ != "object")
+          else if (typeof j != "object")
             Y = `${J} did not return an object.`;
-          else if (_.error && _.data)
+          else if (j.error && j.data)
             Y = `${J} returned an object containing both \`error\` and \`result\`.`;
-          else if (_.error === void 0 && _.data === void 0)
+          else if (j.error === void 0 && j.data === void 0)
             Y = `${J} returned an object containing neither a valid \`error\` and \`result\`. At least one of them should not be \`undefined\``;
           else
-            for (const se of Object.keys(_))
-              if (se !== "error" && se !== "data" && se !== "meta") {
-                Y = `The object returned by ${J} has the unknown property ${se}.`;
+            for (const oe of Object.keys(j))
+              if (oe !== "error" && oe !== "data" && oe !== "meta") {
+                Y = `The object returned by ${J} has the unknown property ${oe}.`;
                 break;
               }
           Y && console.error(`Error encountered handling the endpoint ${t.endpointName}.
                   ${Y}
                   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:`, _);
+                  Object returned was:`, j);
         }
-        if (_.error) throw new Be(_.error, _.meta);
+        if (j.error) throw new He(j.error, j.meta);
         let {
           data: X
-        } = _;
-        G && !F && (X = await te(G, _.data, "rawResponseSchema", _.meta));
-        let ee = await K(X, _.meta, V);
-        return ie && !F && (ee = await te(ie, ee, "responseSchema", _.meta)), {
-          ..._,
+        } = j;
+        G && !te(U, "rawResponse") && (X = await ne(G, j.data, "rawResponseSchema", j.meta));
+        let ee = await K(X, j.meta, $);
+        return se && !te(U, "response") && (ee = await ne(se, ee, "responseSchema", j.meta)), {
+          ...j,
           data: ee
         };
       }
       if (t.type === "query" && "infiniteQueryOptions" in T) {
         const {
-          infiniteQueryOptions: V
+          infiniteQueryOptions: $
         } = T, {
-          maxPages: _ = 1 / 0
-        } = V;
-        let W;
-        const re = {
+          maxPages: j = 1 / 0
+        } = $;
+        let H;
+        const ie = {
           pages: [],
           pageParams: []
-        }, G = (z = b.selectQueryEntry(k(), t.queryCacheKey)) == null ? void 0 : z.data, X = /* arg.forceRefetch */ l(t, k()) && !t.direction || !G ? re : G;
+        }, G = (B = v.selectQueryEntry(x(), t.queryCacheKey)) == null ? void 0 : B.data, X = /* arg.forceRefetch */ u(t, x()) && !t.direction || !G ? ie : G;
         if ("direction" in t && t.direction && X.pages.length) {
-          const ee = t.direction === "backward", Y = (ee ? st : qe)(V, X, t.originalArgs);
-          W = await U(X, Y, _, ee);
+          const ee = t.direction === "backward", Y = (ee ? ut : Te)($, X, t.originalArgs);
+          H = await z(X, Y, j, ee);
         } else {
           const {
-            initialPageParam: ee = V.initialPageParam
-          } = t, J = (G == null ? void 0 : G.pageParams) ?? [], Y = J[0] ?? ee, se = J.length;
-          W = await U(X, Y, _), $ && (W = {
-            data: W.data.pages[0]
+            initialPageParam: ee = $.initialPageParam
+          } = t, J = (G == null ? void 0 : G.pageParams) ?? [], Y = J[0] ?? ee, oe = J.length;
+          H = await z(X, Y, j), W && (H = {
+            data: H.data.pages[0]
           });
-          for (let Ce = 1; Ce < se; Ce++) {
-            const ct = qe(V, W.data, t.originalArgs);
-            W = await U(W.data, ct, _);
+          for (let je = 1; je < oe; je++) {
+            const ft = Te($, H.data, t.originalArgs);
+            H = await z(H.data, ft, j);
           }
         }
-        B = W;
+        C = H;
       } else
-        B = await L(t.originalArgs);
-      return x && !F && B.meta && (B.meta = await te(x, B.meta, "metaSchema", B.meta)), R(B.data, de({
+        C = await V(t.originalArgs);
+      return _ && !te(U, "meta") && C.meta && (C.meta = await ne(_, C.meta, "metaSchema", C.meta)), w(C.data, de({
         fulfilledTimeStamp: Date.now(),
-        baseQueryMeta: B.meta
+        baseQueryMeta: C.meta
       }));
     } catch (K) {
-      let N = K;
-      if (N instanceof Be) {
-        let $ = A(T, "transformErrorResponse");
+      let F = K;
+      if (F instanceof He) {
+        let W = R(T, "transformErrorResponse");
         const {
-          rawErrorResponseSchema: B,
-          errorResponseSchema: U
+          rawErrorResponseSchema: C,
+          errorResponseSchema: z
         } = T;
         let {
-          value: L,
-          meta: V
-        } = N;
+          value: V,
+          meta: $
+        } = F;
         try {
-          B && !F && (L = await te(B, L, "rawErrorResponseSchema", V)), x && !F && (V = await te(x, V, "metaSchema", V));
-          let _ = await $(L, V, t.originalArgs);
-          return U && !F && (_ = await te(U, _, "errorResponseSchema", V)), o(_, de({
-            baseQueryMeta: V
+          C && !te(U, "rawErrorResponse") && (V = await ne(C, V, "rawErrorResponseSchema", $)), _ && !te(U, "meta") && ($ = await ne(_, $, "metaSchema", $));
+          let j = await W(V, $, t.originalArgs);
+          return z && !te(U, "errorResponse") && (j = await ne(z, j, "errorResponseSchema", $)), s(j, de({
+            baseQueryMeta: $
           }));
-        } catch (_) {
-          N = _;
+        } catch (j) {
+          F = j;
         }
       }
       try {
-        if (N instanceof it) {
-          const $ = {
+        if (F instanceof ct) {
+          const W = {
             endpoint: t.endpointName,
             arg: t.originalArgs,
             type: t.type,
             queryCacheKey: t.type === "query" ? t.queryCacheKey : void 0
           };
-          (H = T.onSchemaFailure) == null || H.call(T, N, $), O == null || O(N, $);
+          (L = T.onSchemaFailure) == null || L.call(T, F, W), M == null || M(F, W);
           const {
-            catchSchemaFailure: B = j
+            catchSchemaFailure: C = D
           } = T;
-          if (B)
-            return o(B(N, $), de({
-              baseQueryMeta: N._bqMeta
+          if (C)
+            return s(C(F, W), de({
+              baseQueryMeta: F._bqMeta
             }));
         }
-      } catch ($) {
-        N = $;
+      } catch (W) {
+        F = W;
       }
       throw typeof process < "u" && process.env.NODE_ENV !== "production" ? console.error(`An unhandled error occurred processing a request for the endpoint "${t.endpointName}".
-In the case of an unhandled error, no tags will be "provided" or "invalidated".`, N) : console.error(N), N;
+In the case of an unhandled error, no tags will be "provided" or "invalidated".`, F) : console.error(F), F;
     }
   };
-  function l(t, i) {
-    const s = b.selectQueryEntry(i, t.queryCacheKey), o = b.selectConfig(i).refetchOnMountOrArgChange, R = s == null ? void 0 : s.fulfilledTimeStamp, C = t.forceRefetch ?? (t.subscribe && o);
-    return C ? C === !0 || (Number(/* @__PURE__ */ new Date()) - Number(R)) / 1e3 >= C : !1;
+  function u(t, n) {
+    const l = v.selectQueryEntry(n, t.queryCacheKey), s = v.selectConfig(n).refetchOnMountOrArgChange, w = l == null ? void 0 : l.fulfilledTimeStamp, N = t.forceRefetch ?? (t.subscribe && s);
+    return N ? N === !0 || (Number(/* @__PURE__ */ new Date()) - Number(w)) / 1e3 >= N : !1;
   }
-  const I = () => je(`${e}/executeQuery`, h, {
+  const b = () => _e(`${e}/executeQuery`, d, {
     getPendingMeta({
-      arg: i
+      arg: n
     }) {
-      const s = p[i.endpointName];
+      const l = p[n.endpointName];
       return de({
         startedTimeStamp: Date.now(),
-        ...ge(s) ? {
-          direction: i.direction
+        ...he(l) ? {
+          direction: n.direction
         } : {}
       });
     },
-    condition(i, {
-      getState: s
+    condition(n, {
+      getState: l
     }) {
-      var F;
-      const o = s(), R = b.selectQueryEntry(o, i.queryCacheKey), C = R == null ? void 0 : R.fulfilledTimeStamp, k = i.originalArgs, M = R == null ? void 0 : R.originalArgs, T = p[i.endpointName], x = i.direction;
-      return Qe(i) ? !0 : (R == null ? void 0 : R.status) === "pending" ? !1 : l(i, o) || Pe(T) && ((F = T == null ? void 0 : T.forceRefetch) != null && F.call(T, {
-        currentArg: k,
-        previousArg: M,
-        endpointState: R,
-        state: o
-      })) ? !0 : !(C && !x);
+      var U;
+      const s = l(), w = v.selectQueryEntry(s, n.queryCacheKey), N = w == null ? void 0 : w.fulfilledTimeStamp, x = n.originalArgs, k = w == null ? void 0 : w.originalArgs, T = p[n.endpointName], _ = n.direction;
+      return Ie(n) ? !0 : (w == null ? void 0 : w.status) === "pending" ? !1 : u(n, s) || we(T) && ((U = T == null ? void 0 : T.forceRefetch) != null && U.call(T, {
+        currentArg: x,
+        previousArg: k,
+        endpointState: w,
+        state: s
+      })) ? !0 : !(N && !_);
     },
     dispatchConditionRejection: !0
-  }), c = I(), n = I(), d = je(`${e}/executeMutation`, h, {
+  }), o = b(), r = b(), a = _e(`${e}/executeMutation`, d, {
     getPendingMeta() {
       return de({
         startedTimeStamp: Date.now()
       });
     }
-  }), P = (t) => "force" in t, w = (t) => "ifOlderThan" in t, Q = (t, i, s) => (o, R) => {
-    const C = P(s) && s.force, k = w(s) && s.ifOlderThan, M = (x = !0) => {
-      const F = {
-        forceRefetch: x,
-        isPrefetch: !0
+  }), h = (t) => "force" in t, m = (t) => "ifOlderThan" in t, g = (t, n, l = {}) => (s, w) => {
+    const N = h(l) && l.force, x = m(l) && l.ifOlderThan, k = (_ = !0) => {
+      const U = {
+        forceRefetch: _,
+        subscribe: !1
       };
-      return y.endpoints[t].initiate(i, F);
-    }, T = y.endpoints[t].select(i)(R());
-    if (C)
-      o(M());
-    else if (k) {
-      const x = T == null ? void 0 : T.fulfilledTimeStamp;
-      if (!x) {
-        o(M());
+      return y.endpoints[t].initiate(n, U);
+    }, T = y.endpoints[t].select(n)(w());
+    if (N)
+      s(k());
+    else if (x) {
+      const _ = T == null ? void 0 : T.fulfilledTimeStamp;
+      if (!_) {
+        s(k());
         return;
       }
-      (Number(/* @__PURE__ */ new Date()) - Number(new Date(x))) / 1e3 >= k && o(M());
+      (Number(/* @__PURE__ */ new Date()) - Number(new Date(_))) / 1e3 >= x && s(k());
     } else
-      o(M(!1));
+      s(k(!1));
   };
-  function g(t) {
-    return (i) => {
-      var s, o;
-      return ((o = (s = i == null ? void 0 : i.meta) == null ? void 0 : s.arg) == null ? void 0 : o.endpointName) === t;
+  function f(t) {
+    return (n) => {
+      var l, s;
+      return ((s = (l = n == null ? void 0 : n.meta) == null ? void 0 : l.arg) == null ? void 0 : s.endpointName) === t;
     };
   }
-  function a(t, i) {
+  function c(t, n) {
     return {
-      matchPending: we(Ze(t), g(i)),
-      matchFulfilled: we(ne(t), g(i)),
-      matchRejected: we(Oe(t), g(i))
+      matchPending: Pe(rt(t), f(n)),
+      matchFulfilled: Pe(re(t), f(n)),
+      matchRejected: Pe(Oe(t), f(n))
     };
   }
   return {
-    queryThunk: c,
-    mutationThunk: d,
-    infiniteQueryThunk: n,
-    prefetch: Q,
-    updateQueryData: u,
-    upsertQueryData: m,
-    patchQueryData: D,
-    buildMatchThunkActions: a
+    queryThunk: o,
+    mutationThunk: a,
+    infiniteQueryThunk: r,
+    prefetch: g,
+    updateQueryData: Q,
+    upsertQueryData: q,
+    patchQueryData: O,
+    buildMatchThunkActions: c
   };
 }
-function qe(e, {
-  pages: r,
+function Te(e, {
+  pages: i,
   pageParams: p
-}, v) {
-  const y = r.length - 1;
-  return e.getNextPageParam(r[y], r, p[y], p, v);
+}, S) {
+  const y = i.length - 1;
+  return e.getNextPageParam(i[y], i, p[y], p, S);
 }
-function st(e, {
-  pages: r,
+function ut(e, {
+  pages: i,
   pageParams: p
-}, v) {
+}, S) {
   var y;
-  return (y = e.getPreviousPageParam) == null ? void 0 : y.call(e, r[0], r, p[0], p, v);
+  return (y = e.getPreviousPageParam) == null ? void 0 : y.call(e, i[0], i, p[0], p, S);
 }
-function ot(e, r, p, v) {
-  return De(p[e.meta.arg.endpointName][r], ne(e) ? e.payload : void 0, Te(e) ? e.payload : void 0, e.meta.arg.originalArgs, "baseQueryMeta" in e.meta ? e.meta.baseQueryMeta : void 0, v);
+function lt(e, i, p, S) {
+  return Ce(p[e.meta.arg.endpointName][i], re(e) ? e.payload : void 0, Me(e) ? e.payload : void 0, e.meta.arg.originalArgs, "baseQueryMeta" in e.meta ? e.meta.baseQueryMeta : void 0, S);
 }
-function he(e, r, p) {
-  const v = e[r];
-  v && p(v);
+function ye(e, i, p) {
+  const S = e[i];
+  S && p(S);
 }
-function ye(e) {
+function ge(e) {
   return ("arg" in e ? e.arg.fixedCacheKey : e.fixedCacheKey) ?? e.requestId;
 }
-function We(e, r, p) {
-  const v = e[ye(r)];
-  v && p(v);
+function Je(e, i, p) {
+  const S = e[ge(i)];
+  S && p(S);
 }
 var me = {};
-function Dt({
+function jt({
   reducerPath: e,
-  queryThunk: r,
+  queryThunk: i,
   mutationThunk: p,
-  serializeQueryArgs: v,
+  serializeQueryArgs: S,
   context: {
     endpointDefinitions: y,
-    apiUid: q,
-    extractRehydrationInfo: b,
-    hasRehydrationInfo: O
+    apiUid: P,
+    extractRehydrationInfo: v,
+    hasRehydrationInfo: M
   },
-  assertTagType: j,
-  config: E
+  assertTagType: D,
+  config: I
 }) {
-  const D = ue(`${e}/resetApiState`);
-  function S(g, a, t, i) {
-    var s;
-    g[s = a.queryCacheKey] ?? (g[s] = {
+  const O = ue(`${e}/resetApiState`);
+  function A(f, c, t, n) {
+    var l;
+    f[l = c.queryCacheKey] ?? (f[l] = {
       status: "uninitialized",
-      endpointName: a.endpointName
-    }), he(g, a.queryCacheKey, (o) => {
-      o.status = "pending", o.requestId = t && o.requestId ? (
+      endpointName: c.endpointName
+    }), ye(f, c.queryCacheKey, (s) => {
+      s.status = "pending", s.requestId = t && s.requestId ? (
         // for `upsertQuery` **updates**, keep the current `requestId`
-        o.requestId
+        s.requestId
       ) : (
         // for normal queries or `upsertQuery` **inserts** always update the `requestId`
-        i.requestId
-      ), a.originalArgs !== void 0 && (o.originalArgs = a.originalArgs), o.startedTimeStamp = i.startedTimeStamp;
-      const R = y[i.arg.endpointName];
-      ge(R) && "direction" in a && (o.direction = a.direction);
+        n.requestId
+      ), c.originalArgs !== void 0 && (s.originalArgs = c.originalArgs), s.startedTimeStamp = n.startedTimeStamp;
+      const w = y[n.arg.endpointName];
+      he(w) && "direction" in c && (s.direction = c.direction);
     });
   }
-  function f(g, a, t, i) {
-    he(g, a.arg.queryCacheKey, (s) => {
-      if (s.requestId !== a.requestId && !i) return;
+  function E(f, c, t, n) {
+    ye(f, c.arg.queryCacheKey, (l) => {
+      if (l.requestId !== c.requestId && !n) return;
       const {
-        merge: o
-      } = y[a.arg.endpointName];
-      if (s.status = "fulfilled", o)
-        if (s.data !== void 0) {
+        merge: s
+      } = y[c.arg.endpointName];
+      if (l.status = "fulfilled", s)
+        if (l.data !== void 0) {
           const {
-            fulfilledTimeStamp: R,
-            arg: C,
-            baseQueryMeta: k,
-            requestId: M
-          } = a;
-          let T = Ie(s.data, (x) => o(x, t, {
-            arg: C.originalArgs,
-            baseQueryMeta: k,
-            fulfilledTimeStamp: R,
-            requestId: M
+            fulfilledTimeStamp: w,
+            arg: N,
+            baseQueryMeta: x,
+            requestId: k
+          } = c;
+          let T = qe(l.data, (_) => s(_, t, {
+            arg: N.originalArgs,
+            baseQueryMeta: x,
+            fulfilledTimeStamp: w,
+            requestId: k
           }));
-          s.data = T;
+          l.data = T;
         } else
-          s.data = t;
+          l.data = t;
       else
-        s.data = y[a.arg.endpointName].structuralSharing ?? !0 ? tt(yt(s.data) ? gt(s.data) : s.data, t) : t;
-      delete s.error, s.fulfilledTimeStamp = a.fulfilledTimeStamp;
+        l.data = y[c.arg.endpointName].structuralSharing ?? !0 ? st(bt(l.data) ? vt(l.data) : l.data, t) : t;
+      delete l.error, l.fulfilledTimeStamp = c.fulfilledTimeStamp;
     });
   }
-  const u = oe({
+  const Q = ae({
     name: `${e}/queries`,
     initialState: me,
     reducers: {
       removeQueryResult: {
-        reducer(g, {
+        reducer(f, {
           payload: {
-            queryCacheKey: a
+            queryCacheKey: c
           }
         }) {
-          delete g[a];
+          delete f[c];
         },
         prepare: le()
       },
       cacheEntriesUpserted: {
-        reducer(g, a) {
-          for (const t of a.payload) {
+        reducer(f, c) {
+          for (const t of c.payload) {
             const {
-              queryDescription: i,
-              value: s
+              queryDescription: n,
+              value: l
             } = t;
-            S(g, i, !0, {
-              arg: i,
-              requestId: a.meta.requestId,
-              startedTimeStamp: a.meta.timestamp
-            }), f(
-              g,
+            A(f, n, !0, {
+              arg: n,
+              requestId: c.meta.requestId,
+              startedTimeStamp: c.meta.timestamp
+            }), E(
+              f,
               {
-                arg: i,
-                requestId: a.meta.requestId,
-                fulfilledTimeStamp: a.meta.timestamp,
+                arg: n,
+                requestId: c.meta.requestId,
+                fulfilledTimeStamp: c.meta.timestamp,
                 baseQueryMeta: {}
               },
-              s,
+              l,
               // We know we're upserting here
               !0
             );
           }
         },
-        prepare: (g) => ({
-          payload: g.map((i) => {
+        prepare: (f) => ({
+          payload: f.map((n) => {
             const {
-              endpointName: s,
-              arg: o,
-              value: R
-            } = i, C = y[s];
+              endpointName: l,
+              arg: s,
+              value: w
+            } = n, N = y[l];
             return {
               queryDescription: {
                 type: "query",
-                endpointName: s,
-                originalArgs: i.arg,
-                queryCacheKey: v({
-                  queryArgs: o,
-                  endpointDefinition: C,
-                  endpointName: s
+                endpointName: l,
+                originalArgs: n.arg,
+                queryCacheKey: S({
+                  queryArgs: s,
+                  endpointDefinition: N,
+                  endpointName: l
                 })
               },
-              value: R
+              value: w
             };
           }),
           meta: {
-            [Xe]: !0,
-            requestId: Ge(),
+            [nt]: !0,
+            requestId: tt(),
             timestamp: Date.now()
           }
         })
       },
       queryResultPatched: {
-        reducer(g, {
+        reducer(f, {
           payload: {
-            queryCacheKey: a,
+            queryCacheKey: c,
             patches: t
           }
         }) {
-          he(g, a, (i) => {
-            i.data = _e(i.data, t.concat());
+          ye(f, c, (n) => {
+            n.data = Fe(n.data, t.concat());
           });
         },
         prepare: le()
       }
     },
-    extraReducers(g) {
-      g.addCase(r.pending, (a, {
+    extraReducers(f) {
+      f.addCase(i.pending, (c, {
         meta: t,
         meta: {
-          arg: i
+          arg: n
         }
       }) => {
-        const s = Qe(i);
-        S(a, i, s, t);
-      }).addCase(r.fulfilled, (a, {
+        const l = Ie(n);
+        A(c, n, l, t);
+      }).addCase(i.fulfilled, (c, {
         meta: t,
-        payload: i
+        payload: n
       }) => {
-        const s = Qe(t.arg);
-        f(a, t, i, s);
-      }).addCase(r.rejected, (a, {
+        const l = Ie(t.arg);
+        E(c, t, n, l);
+      }).addCase(i.rejected, (c, {
         meta: {
           condition: t,
-          arg: i,
-          requestId: s
+          arg: n,
+          requestId: l
         },
-        error: o,
-        payload: R
+        error: s,
+        payload: w
       }) => {
-        he(a, i.queryCacheKey, (C) => {
+        ye(c, n.queryCacheKey, (N) => {
           if (!t) {
-            if (C.requestId !== s) return;
-            C.status = "rejected", C.error = R ?? o;
+            if (N.requestId !== l) return;
+            N.status = "rejected", N.error = w ?? s;
           }
         });
-      }).addMatcher(O, (a, t) => {
+      }).addMatcher(M, (c, t) => {
         const {
-          queries: i
-        } = b(t);
-        for (const [s, o] of Object.entries(i))
+          queries: n
+        } = v(t);
+        for (const [l, s] of Object.entries(n))
           // do not rehydrate entries that were currently in flight.
-          ((o == null ? void 0 : o.status) === "fulfilled" || (o == null ? void 0 : o.status) === "rejected") && (a[s] = o);
+          ((s == null ? void 0 : s.status) === "fulfilled" || (s == null ? void 0 : s.status) === "rejected") && (c[l] = s);
       });
     }
-  }), m = oe({
+  }), q = ae({
     name: `${e}/mutations`,
     initialState: me,
     reducers: {
       removeMutationResult: {
-        reducer(g, {
-          payload: a
+        reducer(f, {
+          payload: c
         }) {
-          const t = ye(a);
-          t in g && delete g[t];
+          const t = ge(c);
+          t in f && delete f[t];
         },
         prepare: le()
       }
     },
-    extraReducers(g) {
-      g.addCase(p.pending, (a, {
+    extraReducers(f) {
+      f.addCase(p.pending, (c, {
         meta: t,
         meta: {
-          requestId: i,
-          arg: s,
-          startedTimeStamp: o
+          requestId: n,
+          arg: l,
+          startedTimeStamp: s
         }
       }) => {
-        s.track && (a[ye(t)] = {
-          requestId: i,
+        l.track && (c[ge(t)] = {
+          requestId: n,
           status: "pending",
-          endpointName: s.endpointName,
-          startedTimeStamp: o
+          endpointName: l.endpointName,
+          startedTimeStamp: s
         });
-      }).addCase(p.fulfilled, (a, {
+      }).addCase(p.fulfilled, (c, {
         payload: t,
-        meta: i
+        meta: n
       }) => {
-        i.arg.track && We(a, i, (s) => {
-          s.requestId === i.requestId && (s.status = "fulfilled", s.data = t, s.fulfilledTimeStamp = i.fulfilledTimeStamp);
+        n.arg.track && Je(c, n, (l) => {
+          l.requestId === n.requestId && (l.status = "fulfilled", l.data = t, l.fulfilledTimeStamp = n.fulfilledTimeStamp);
         });
-      }).addCase(p.rejected, (a, {
+      }).addCase(p.rejected, (c, {
         payload: t,
-        error: i,
-        meta: s
+        error: n,
+        meta: l
       }) => {
-        s.arg.track && We(a, s, (o) => {
-          o.requestId === s.requestId && (o.status = "rejected", o.error = t ?? i);
+        l.arg.track && Je(c, l, (s) => {
+          s.requestId === l.requestId && (s.status = "rejected", s.error = t ?? n);
         });
-      }).addMatcher(O, (a, t) => {
+      }).addMatcher(M, (c, t) => {
         const {
-          mutations: i
-        } = b(t);
-        for (const [s, o] of Object.entries(i))
+          mutations: n
+        } = v(t);
+        for (const [l, s] of Object.entries(n))
           // do not rehydrate entries that were currently in flight.
-          ((o == null ? void 0 : o.status) === "fulfilled" || (o == null ? void 0 : o.status) === "rejected") && // only rehydrate endpoints that were persisted using a `fixedCacheKey`
-          s !== (o == null ? void 0 : o.requestId) && (a[s] = o);
+          ((s == null ? void 0 : s.status) === "fulfilled" || (s == null ? void 0 : s.status) === "rejected") && // only rehydrate endpoints that were persisted using a `fixedCacheKey`
+          l !== (s == null ? void 0 : s.requestId) && (c[l] = s);
       });
     }
-  }), A = {
+  }), R = {
     tags: {},
     keys: {}
-  }, h = oe({
+  }, d = ae({
     name: `${e}/invalidation`,
-    initialState: A,
+    initialState: R,
     reducers: {
       updateProvidedBy: {
-        reducer(g, a) {
-          var t, i, s;
+        reducer(f, c) {
+          var t, n, l;
           for (const {
-            queryCacheKey: o,
-            providedTags: R
-          } of a.payload) {
-            l(g, o);
+            queryCacheKey: s,
+            providedTags: w
+          } of c.payload) {
+            u(f, s);
             for (const {
-              type: C,
-              id: k
-            } of R) {
-              const M = (i = (t = g.tags)[C] ?? (t[C] = {}))[s = k || "__internal_without_id"] ?? (i[s] = []);
-              M.includes(o) || M.push(o);
+              type: N,
+              id: x
+            } of w) {
+              const k = (n = (t = f.tags)[N] ?? (t[N] = {}))[l = x || "__internal_without_id"] ?? (n[l] = []);
+              k.includes(s) || k.push(s);
             }
-            g.keys[o] = R;
+            f.keys[s] = w;
           }
         },
         prepare: le()
       }
     },
-    extraReducers(g) {
-      g.addCase(u.actions.removeQueryResult, (a, {
+    extraReducers(f) {
+      f.addCase(Q.actions.removeQueryResult, (c, {
         payload: {
           queryCacheKey: t
         }
       }) => {
-        l(a, t);
-      }).addMatcher(O, (a, t) => {
-        var s, o, R;
+        u(c, t);
+      }).addMatcher(M, (c, t) => {
+        var l, s, w;
         const {
-          provided: i
-        } = b(t);
-        for (const [C, k] of Object.entries(i))
-          for (const [M, T] of Object.entries(k)) {
-            const x = (o = (s = a.tags)[C] ?? (s[C] = {}))[R = M || "__internal_without_id"] ?? (o[R] = []);
-            for (const F of T)
-              x.includes(F) || x.push(F);
+          provided: n
+        } = v(t);
+        for (const [N, x] of Object.entries(n.tags ?? {}))
+          for (const [k, T] of Object.entries(x)) {
+            const _ = (s = (l = c.tags)[N] ?? (l[N] = {}))[w = k || "__internal_without_id"] ?? (s[w] = []);
+            for (const U of T)
+              _.includes(U) || _.push(U), c.keys[U] = n.keys[U];
           }
-      }).addMatcher(be(ne(r), Te(r)), (a, t) => {
-        I(a, [t]);
-      }).addMatcher(u.actions.cacheEntriesUpserted.match, (a, t) => {
-        const i = t.payload.map(({
-          queryDescription: s,
-          value: o
+      }).addMatcher(be(re(i), Me(i)), (c, t) => {
+        b(c, [t]);
+      }).addMatcher(Q.actions.cacheEntriesUpserted.match, (c, t) => {
+        const n = t.payload.map(({
+          queryDescription: l,
+          value: s
         }) => ({
           type: "UNKNOWN",
-          payload: o,
+          payload: s,
           meta: {
             requestStatus: "fulfilled",
             requestId: "UNKNOWN",
-            arg: s
+            arg: l
           }
         }));
-        I(a, i);
+        b(c, n);
       });
     }
   });
-  function l(g, a) {
-    var i;
-    const t = g.keys[a] ?? [];
-    for (const s of t) {
-      const o = s.type, R = s.id ?? "__internal_without_id", C = (i = g.tags[o]) == null ? void 0 : i[R];
-      C && (g.tags[o][R] = C.filter((k) => k !== a));
+  function u(f, c) {
+    var n;
+    const t = f.keys[c] ?? [];
+    for (const l of t) {
+      const s = l.type, w = l.id ?? "__internal_without_id", N = (n = f.tags[s]) == null ? void 0 : n[w];
+      N && (f.tags[s][w] = N.filter((x) => x !== c));
     }
-    delete g.keys[a];
+    delete f.keys[c];
   }
-  function I(g, a) {
-    const t = a.map((i) => {
-      const s = ot(i, "providesTags", y, j), {
-        queryCacheKey: o
-      } = i.meta.arg;
+  function b(f, c) {
+    const t = c.map((n) => {
+      const l = lt(n, "providesTags", y, D), {
+        queryCacheKey: s
+      } = n.meta.arg;
       return {
-        queryCacheKey: o,
-        providedTags: s
+        queryCacheKey: s,
+        providedTags: l
       };
     });
-    h.caseReducers.updateProvidedBy(g, h.actions.updateProvidedBy(t));
+    d.caseReducers.updateProvidedBy(f, d.actions.updateProvidedBy(t));
   }
-  const c = oe({
+  const o = ae({
     name: `${e}/subscriptions`,
     initialState: me,
     reducers: {
-      updateSubscriptionOptions(g, a) {
+      updateSubscriptionOptions(f, c) {
       },
-      unsubscribeQueryResult(g, a) {
+      unsubscribeQueryResult(f, c) {
       },
       internal_getRTKQSubscriptions() {
       }
     }
-  }), n = oe({
+  }), r = ae({
     name: `${e}/internalSubscriptions`,
     initialState: me,
     reducers: {
       subscriptionsUpdated: {
-        reducer(g, a) {
-          return _e(g, a.payload);
+        reducer(f, c) {
+          return Fe(f, c.payload);
         },
         prepare: le()
       }
     }
-  }), d = oe({
+  }), a = ae({
     name: `${e}/config`,
     initialState: {
-      online: St(),
-      focused: bt(),
+      online: Et(),
+      focused: Pt(),
       middlewareRegistered: !1,
-      ...E
+      ...I
     },
     reducers: {
-      middlewareRegistered(g, {
-        payload: a
+      middlewareRegistered(f, {
+        payload: c
       }) {
-        g.middlewareRegistered = g.middlewareRegistered === "conflict" || q !== a ? "conflict" : !0;
+        f.middlewareRegistered = f.middlewareRegistered === "conflict" || P !== c ? "conflict" : !0;
       }
     },
-    extraReducers: (g) => {
-      g.addCase(Ne, (a) => {
-        a.online = !0;
-      }).addCase(rt, (a) => {
-        a.online = !1;
-      }).addCase(Me, (a) => {
-        a.focused = !0;
-      }).addCase(nt, (a) => {
-        a.focused = !1;
-      }).addMatcher(O, (a) => ({
-        ...a
+    extraReducers: (f) => {
+      f.addCase(ke, (c) => {
+        c.online = !0;
+      }).addCase(at, (c) => {
+        c.online = !1;
+      }).addCase(De, (c) => {
+        c.focused = !0;
+      }).addCase(ot, (c) => {
+        c.focused = !1;
+      }).addMatcher(M, (c) => ({
+        ...c
       }));
     }
-  }), P = lt({
-    queries: u.reducer,
-    mutations: m.reducer,
-    provided: h.reducer,
-    subscriptions: n.reducer,
-    config: d.reducer
-  }), w = (g, a) => P(D.match(a) ? void 0 : g, a), Q = {
+  }), h = gt({
+    queries: Q.reducer,
+    mutations: q.reducer,
+    provided: d.reducer,
+    subscriptions: r.reducer,
+    config: a.reducer
+  }), m = (f, c) => h(O.match(c) ? void 0 : f, c), g = {
+    ...a.actions,
+    ...Q.actions,
+    ...o.actions,
+    ...r.actions,
+    ...q.actions,
     ...d.actions,
-    ...u.actions,
-    ...c.actions,
-    ...n.actions,
-    ...m.actions,
-    ...h.actions,
-    resetApiState: D
+    resetApiState: O
   };
   return {
-    reducer: w,
-    actions: Q
+    reducer: m,
+    actions: g
   };
 }
-var Ae = /* @__PURE__ */ Symbol.for("RTKQ/skipToken"), at = {
+var Ee = /* @__PURE__ */ Symbol.for("RTKQ/skipToken"), dt = {
   status: "uninitialized"
   /* uninitialized */
-}, ze = /* @__PURE__ */ Ie(at, () => {
-}), He = /* @__PURE__ */ Ie(at, () => {
+}, Ye = /* @__PURE__ */ qe(dt, () => {
+}), Ge = /* @__PURE__ */ qe(dt, () => {
 });
-function Ct({
+function _t({
   serializeQueryArgs: e,
-  reducerPath: r,
+  reducerPath: i,
   createSelector: p
 }) {
-  const v = (c) => ze, y = (c) => He;
+  const S = (o) => Ye, y = (o) => Ge;
   return {
-    buildQuerySelector: f,
-    buildInfiniteQuerySelector: u,
-    buildMutationSelector: m,
-    selectInvalidatedBy: A,
-    selectCachedArgsForQuery: h,
-    selectApiState: b,
-    selectQueries: O,
-    selectMutations: E,
-    selectQueryEntry: j,
-    selectConfig: D
+    buildQuerySelector: E,
+    buildInfiniteQuerySelector: Q,
+    buildMutationSelector: q,
+    selectInvalidatedBy: R,
+    selectCachedArgsForQuery: d,
+    selectApiState: v,
+    selectQueries: M,
+    selectMutations: I,
+    selectQueryEntry: D,
+    selectConfig: O
   };
-  function q(c) {
+  function P(o) {
     return {
-      ...c,
-      ...Fe(c.status)
+      ...o,
+      ...Ue(o.status)
     };
   }
-  function b(c) {
-    const n = c[r];
-    if (process.env.NODE_ENV !== "production" && !n) {
-      if (b.triggered) return n;
-      b.triggered = !0, console.error(`Error: No data found at \`state.${r}\`. Did you forget to add the reducer to the store?`);
+  function v(o) {
+    const r = o[i];
+    if (process.env.NODE_ENV !== "production" && !r) {
+      if (v.triggered) return r;
+      v.triggered = !0, console.error(`Error: No data found at \`state.${i}\`. Did you forget to add the reducer to the store?`);
     }
-    return n;
+    return r;
   }
-  function O(c) {
-    var n;
-    return (n = b(c)) == null ? void 0 : n.queries;
+  function M(o) {
+    var r;
+    return (r = v(o)) == null ? void 0 : r.queries;
   }
-  function j(c, n) {
-    var d;
-    return (d = O(c)) == null ? void 0 : d[n];
+  function D(o, r) {
+    var a;
+    return (a = M(o)) == null ? void 0 : a[r];
   }
-  function E(c) {
-    var n;
-    return (n = b(c)) == null ? void 0 : n.mutations;
+  function I(o) {
+    var r;
+    return (r = v(o)) == null ? void 0 : r.mutations;
   }
-  function D(c) {
-    var n;
-    return (n = b(c)) == null ? void 0 : n.config;
+  function O(o) {
+    var r;
+    return (r = v(o)) == null ? void 0 : r.config;
   }
-  function S(c, n, d) {
-    return (P) => {
-      if (P === Ae)
-        return p(v, d);
-      const w = e({
-        queryArgs: P,
-        endpointDefinition: n,
-        endpointName: c
+  function A(o, r, a) {
+    return (h) => {
+      if (h === Ee)
+        return p(S, a);
+      const m = e({
+        queryArgs: h,
+        endpointDefinition: r,
+        endpointName: o
       });
-      return p((g) => j(g, w) ?? ze, d);
+      return p((f) => D(f, m) ?? Ye, a);
     };
   }
-  function f(c, n) {
-    return S(c, n, q);
+  function E(o, r) {
+    return A(o, r, P);
   }
-  function u(c, n) {
+  function Q(o, r) {
     const {
-      infiniteQueryOptions: d
-    } = n;
-    function P(w) {
-      const Q = {
-        ...w,
-        ...Fe(w.status)
+      infiniteQueryOptions: a
+    } = r;
+    function h(m) {
+      const g = {
+        ...m,
+        ...Ue(m.status)
       }, {
-        isLoading: g,
-        isError: a,
+        isLoading: f,
+        isError: c,
         direction: t
-      } = Q, i = t === "forward", s = t === "backward";
+      } = g, n = t === "forward", l = t === "backward";
       return {
-        ...Q,
-        hasNextPage: l(d, Q.data, Q.originalArgs),
-        hasPreviousPage: I(d, Q.data, Q.originalArgs),
-        isFetchingNextPage: g && i,
-        isFetchingPreviousPage: g && s,
-        isFetchNextPageError: a && i,
-        isFetchPreviousPageError: a && s
+        ...g,
+        hasNextPage: u(a, g.data, g.originalArgs),
+        hasPreviousPage: b(a, g.data, g.originalArgs),
+        isFetchingNextPage: f && n,
+        isFetchingPreviousPage: f && l,
+        isFetchNextPageError: c && n,
+        isFetchPreviousPageError: c && l
       };
     }
-    return S(c, n, P);
+    return A(o, r, h);
   }
-  function m() {
-    return (c) => {
-      let n;
-      return typeof c == "object" ? n = ye(c) ?? Ae : n = c, p(n === Ae ? y : (w) => {
-        var Q, g;
-        return ((g = (Q = b(w)) == null ? void 0 : Q.mutations) == null ? void 0 : g[n]) ?? He;
-      }, q);
+  function q() {
+    return (o) => {
+      let r;
+      return typeof o == "object" ? r = ge(o) ?? Ee : r = o, p(r === Ee ? y : (m) => {
+        var g, f;
+        return ((f = (g = v(m)) == null ? void 0 : g.mutations) == null ? void 0 : f[r]) ?? Ge;
+      }, P);
     };
   }
-  function A(c, n) {
-    const d = c[r], P = /* @__PURE__ */ new Set();
-    for (const w of n.filter(Se).map(Ee)) {
-      const Q = d.provided.tags[w.type];
-      if (!Q)
+  function R(o, r) {
+    const a = o[i], h = /* @__PURE__ */ new Set();
+    for (const m of r.filter(Ne).map(Qe)) {
+      const g = a.provided.tags[m.type];
+      if (!g)
         continue;
-      let g = (w.id !== void 0 ? (
+      let f = (m.id !== void 0 ? (
         // id given: invalidate all queries that provide this type & id
-        Q[w.id]
+        g[m.id]
       ) : (
         // no id: invalidate all queries that provide this type
-        Ke(Object.values(Q))
+        Ve(Object.values(g))
       )) ?? [];
-      for (const a of g)
-        P.add(a);
+      for (const c of f)
+        h.add(c);
     }
-    return Ke(Array.from(P.values()).map((w) => {
-      const Q = d.queries[w];
-      return Q ? [{
-        queryCacheKey: w,
-        endpointName: Q.endpointName,
-        originalArgs: Q.originalArgs
+    return Ve(Array.from(h.values()).map((m) => {
+      const g = a.queries[m];
+      return g ? [{
+        queryCacheKey: m,
+        endpointName: g.endpointName,
+        originalArgs: g.originalArgs
       }] : [];
     }));
   }
-  function h(c, n) {
-    return Object.values(O(c)).filter(
-      (d) => (d == null ? void 0 : d.endpointName) === n && d.status !== "uninitialized"
+  function d(o, r) {
+    return Object.values(M(o)).filter(
+      (a) => (a == null ? void 0 : a.endpointName) === r && a.status !== "uninitialized"
       /* uninitialized */
-    ).map((d) => d.originalArgs);
+    ).map((a) => a.originalArgs);
   }
-  function l(c, n, d) {
-    return n ? qe(c, n, d) != null : !1;
+  function u(o, r, a) {
+    return r ? Te(o, r, a) != null : !1;
   }
-  function I(c, n, d) {
-    return !n || !c.getPreviousPageParam ? !1 : st(c, n, d) != null;
+  function b(o, r, a) {
+    return !r || !o.getPreviousPageParam ? !1 : ut(o, r, a) != null;
   }
 }
-var ae = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0, Le = ({
+var ce = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0, Xe = ({
   endpointName: e,
-  queryArgs: r
+  queryArgs: i
 }) => {
   let p = "";
-  const v = ae == null ? void 0 : ae.get(r);
-  if (typeof v == "string")
-    p = v;
+  const S = ce == null ? void 0 : ce.get(i);
+  if (typeof S == "string")
+    p = S;
   else {
-    const y = JSON.stringify(r, (q, b) => (b = typeof b == "bigint" ? {
-      $bigint: b.toString()
-    } : b, b = fe(b) ? Object.keys(b).sort().reduce((O, j) => (O[j] = b[j], O), {}) : b, b));
-    fe(r) && (ae == null || ae.set(r, y)), p = y;
+    const y = JSON.stringify(i, (P, v) => (v = typeof v == "bigint" ? {
+      $bigint: v.toString()
+    } : v, v = fe(v) ? Object.keys(v).sort().reduce((M, D) => (M[D] = v[D], M), {}) : v, v));
+    fe(i) && (ce == null || ce.set(i, y)), p = y;
   }
   return `${e}(${p})`;
 };
-function jt(...e) {
+function xt(...e) {
   return function(p) {
-    const v = xe((E) => {
-      var D;
-      return (D = p.extractRehydrationInfo) == null ? void 0 : D.call(p, E, {
+    const S = $e((I) => {
+      var O;
+      return (O = p.extractRehydrationInfo) == null ? void 0 : O.call(p, I, {
         reducerPath: p.reducerPath ?? "api"
       });
     }), y = {
@@ -1354,761 +1359,801 @@ function jt(...e) {
       refetchOnReconnect: !1,
       invalidationBehavior: "delayed",
       ...p,
-      extractRehydrationInfo: v,
-      serializeQueryArgs(E) {
-        let D = Le;
-        if ("serializeQueryArgs" in E.endpointDefinition) {
-          const S = E.endpointDefinition.serializeQueryArgs;
-          D = (f) => {
-            const u = S(f);
-            return typeof u == "string" ? u : Le({
-              ...f,
-              queryArgs: u
+      extractRehydrationInfo: S,
+      serializeQueryArgs(I) {
+        let O = Xe;
+        if ("serializeQueryArgs" in I.endpointDefinition) {
+          const A = I.endpointDefinition.serializeQueryArgs;
+          O = (E) => {
+            const Q = A(E);
+            return typeof Q == "string" ? Q : Xe({
+              ...E,
+              queryArgs: Q
             });
           };
-        } else p.serializeQueryArgs && (D = p.serializeQueryArgs);
-        return D(E);
+        } else p.serializeQueryArgs && (O = p.serializeQueryArgs);
+        return O(I);
       },
       tagTypes: [...p.tagTypes || []]
-    }, q = {
+    }, P = {
       endpointDefinitions: {},
-      batch(E) {
-        E();
+      batch(I) {
+        I();
       },
-      apiUid: Ge(),
-      extractRehydrationInfo: v,
-      hasRehydrationInfo: xe((E) => v(E) != null)
-    }, b = {
-      injectEndpoints: j,
+      apiUid: tt(),
+      extractRehydrationInfo: S,
+      hasRehydrationInfo: $e((I) => S(I) != null)
+    }, v = {
+      injectEndpoints: D,
       enhanceEndpoints({
-        addTagTypes: E,
-        endpoints: D
+        addTagTypes: I,
+        endpoints: O
       }) {
-        if (E)
-          for (const S of E)
-            y.tagTypes.includes(S) || y.tagTypes.push(S);
-        if (D)
-          for (const [S, f] of Object.entries(D))
-            typeof f == "function" ? f(q.endpointDefinitions[S]) : Object.assign(q.endpointDefinitions[S] || {}, f);
-        return b;
+        if (I)
+          for (const A of I)
+            y.tagTypes.includes(A) || y.tagTypes.push(A);
+        if (O)
+          for (const [A, E] of Object.entries(O))
+            typeof E == "function" ? E(P.endpointDefinitions[A]) : Object.assign(P.endpointDefinitions[A] || {}, E);
+        return v;
       }
-    }, O = e.map((E) => E.init(b, y, q));
-    function j(E) {
-      const D = E.endpoints({
-        query: (S) => ({
-          ...S,
+    }, M = e.map((I) => I.init(v, y, P));
+    function D(I) {
+      const O = I.endpoints({
+        query: (A) => ({
+          ...A,
           type: "query"
           /* query */
         }),
-        mutation: (S) => ({
-          ...S,
+        mutation: (A) => ({
+          ...A,
           type: "mutation"
           /* mutation */
         }),
-        infiniteQuery: (S) => ({
-          ...S,
+        infiniteQuery: (A) => ({
+          ...A,
           type: "infinitequery"
           /* infinitequery */
         })
       });
-      for (const [S, f] of Object.entries(D)) {
-        if (E.overrideExisting !== !0 && S in q.endpointDefinitions) {
-          if (E.overrideExisting === "throw")
-            throw new Error(process.env.NODE_ENV === "production" ? ve(39) : `called \`injectEndpoints\` to override already-existing endpointName ${S} without specifying \`overrideExisting: true\``);
-          typeof process < "u" && process.env.NODE_ENV === "development" && console.error(`called \`injectEndpoints\` to override already-existing endpointName ${S} without specifying \`overrideExisting: true\``);
+      for (const [A, E] of Object.entries(O)) {
+        if (I.overrideExisting !== !0 && A in P.endpointDefinitions) {
+          if (I.overrideExisting === "throw")
+            throw new Error(process.env.NODE_ENV === "production" ? ve(39) : `called \`injectEndpoints\` to override already-existing endpointName ${A} without specifying \`overrideExisting: true\``);
+          typeof process < "u" && process.env.NODE_ENV === "development" && console.error(`called \`injectEndpoints\` to override already-existing endpointName ${A} without specifying \`overrideExisting: true\``);
           continue;
         }
-        if (typeof process < "u" && process.env.NODE_ENV === "development" && ge(f)) {
+        if (typeof process < "u" && process.env.NODE_ENV === "development" && he(E)) {
           const {
-            infiniteQueryOptions: u
-          } = f, {
-            maxPages: m,
-            getPreviousPageParam: A
-          } = u;
-          if (typeof m == "number") {
-            if (m < 1)
-              throw new Error(process.env.NODE_ENV === "production" ? ve(40) : `maxPages for endpoint '${S}' must be a number greater than 0`);
-            if (typeof A != "function")
-              throw new Error(process.env.NODE_ENV === "production" ? ve(41) : `getPreviousPageParam for endpoint '${S}' must be a function if maxPages is used`);
+            infiniteQueryOptions: Q
+          } = E, {
+            maxPages: q,
+            getPreviousPageParam: R
+          } = Q;
+          if (typeof q == "number") {
+            if (q < 1)
+              throw new Error(process.env.NODE_ENV === "production" ? ve(40) : `maxPages for endpoint '${A}' must be a number greater than 0`);
+            if (typeof R != "function")
+              throw new Error(process.env.NODE_ENV === "production" ? ve(41) : `getPreviousPageParam for endpoint '${A}' must be a function if maxPages is used`);
           }
         }
-        q.endpointDefinitions[S] = f;
-        for (const u of O)
-          u.injectEndpoint(S, f);
+        P.endpointDefinitions[A] = E;
+        for (const Q of M)
+          Q.injectEndpoint(A, E);
       }
-      return b;
+      return v;
     }
-    return b.injectEndpoints({
+    return v.injectEndpoints({
       endpoints: p.endpoints
     });
   };
 }
-function Z(e, ...r) {
-  return Object.assign(e, ...r);
+function Z(e, ...i) {
+  return Object.assign(e, ...i);
 }
-var kt = ({
+var Ft = ({
   api: e,
-  queryThunk: r,
-  internalState: p
+  queryThunk: i,
+  internalState: p,
+  mwApi: S
 }) => {
-  const v = `${e.reducerPath}/subscriptions`;
-  let y = null, q = null;
+  const y = `${e.reducerPath}/subscriptions`;
+  let P = null, v = null;
   const {
-    updateSubscriptionOptions: b,
-    unsubscribeQueryResult: O
-  } = e.internalActions, j = (u, m) => {
-    var h, l, I;
-    if (b.match(m)) {
+    updateSubscriptionOptions: M,
+    unsubscribeQueryResult: D
+  } = e.internalActions, I = (R, d) => {
+    if (M.match(d)) {
       const {
-        queryCacheKey: c,
-        requestId: n,
-        options: d
-      } = m.payload;
-      return (h = u == null ? void 0 : u[c]) != null && h[n] && (u[c][n] = d), !0;
+        queryCacheKey: b,
+        requestId: o,
+        options: r
+      } = d.payload, a = R.get(b);
+      return a != null && a.has(o) && a.set(o, r), !0;
     }
-    if (O.match(m)) {
+    if (D.match(d)) {
       const {
-        queryCacheKey: c,
-        requestId: n
-      } = m.payload;
-      return u[c] && delete u[c][n], !0;
+        queryCacheKey: b,
+        requestId: o
+      } = d.payload, r = R.get(b);
+      return r && r.delete(o), !0;
     }
-    if (e.internalActions.removeQueryResult.match(m))
-      return delete u[m.payload.queryCacheKey], !0;
-    if (r.pending.match(m)) {
+    if (e.internalActions.removeQueryResult.match(d))
+      return R.delete(d.payload.queryCacheKey), !0;
+    if (i.pending.match(d)) {
       const {
         meta: {
-          arg: c,
-          requestId: n
+          arg: b,
+          requestId: o
         }
-      } = m, d = u[l = c.queryCacheKey] ?? (u[l] = {});
-      return d[`${n}_running`] = {}, c.subscribe && (d[n] = c.subscriptionOptions ?? d[n] ?? {}), !0;
+      } = d, r = Se(R, b.queryCacheKey, Ae);
+      return b.subscribe && r.set(o, b.subscriptionOptions ?? r.get(o) ?? {}), !0;
     }
-    let A = !1;
-    if (r.fulfilled.match(m) || r.rejected.match(m)) {
-      const c = u[m.meta.arg.queryCacheKey] || {}, n = `${m.meta.requestId}_running`;
-      A || (A = !!c[n]), delete c[n];
-    }
-    if (r.rejected.match(m)) {
+    let u = !1;
+    if (i.rejected.match(d)) {
       const {
         meta: {
-          condition: c,
-          arg: n,
-          requestId: d
+          condition: b,
+          arg: o,
+          requestId: r
         }
-      } = m;
-      if (c && n.subscribe) {
-        const P = u[I = n.queryCacheKey] ?? (u[I] = {});
-        P[d] = n.subscriptionOptions ?? P[d] ?? {}, A = !0;
+      } = d;
+      if (b && o.subscribe) {
+        const a = Se(R, o.queryCacheKey, Ae);
+        a.set(r, o.subscriptionOptions ?? a.get(r) ?? {}), u = !0;
       }
     }
-    return A;
-  }, E = () => p.currentSubscriptions, f = {
-    getSubscriptions: E,
-    getSubscriptionCount: (u) => {
-      const A = E()[u] ?? {};
-      return ce(A);
+    return u;
+  }, O = () => p.currentSubscriptions, Q = {
+    getSubscriptions: O,
+    getSubscriptionCount: (R) => {
+      const u = O().get(R);
+      return (u == null ? void 0 : u.size) ?? 0;
     },
-    isRequestSubscribed: (u, m) => {
-      var h;
-      const A = E();
-      return !!((h = A == null ? void 0 : A[u]) != null && h[m]);
+    isRequestSubscribed: (R, d) => {
+      var b;
+      const u = O();
+      return !!((b = u == null ? void 0 : u.get(R)) != null && b.get(d));
     }
   };
-  return (u, m) => {
-    if (y || (y = JSON.parse(JSON.stringify(p.currentSubscriptions))), e.util.resetApiState.match(u))
-      return y = p.currentSubscriptions = {}, q = null, [!0, !1];
-    if (e.internalActions.internal_getRTKQSubscriptions.match(u))
-      return [!1, f];
-    const A = j(p.currentSubscriptions, u);
-    let h = !0;
-    if (A) {
-      q || (q = setTimeout(() => {
-        const c = JSON.parse(JSON.stringify(p.currentSubscriptions)), [, n] = et(y, () => c);
-        m.next(e.internalActions.subscriptionsUpdated(n)), y = c, q = null;
+  function q(R) {
+    return JSON.parse(JSON.stringify(Object.fromEntries([...R].map(([d, u]) => [d, Object.fromEntries(u)]))));
+  }
+  return (R, d) => {
+    if (P || (P = q(p.currentSubscriptions)), e.util.resetApiState.match(R))
+      return P = {}, p.currentSubscriptions.clear(), v = null, [!0, !1];
+    if (e.internalActions.internal_getRTKQSubscriptions.match(R))
+      return [!1, Q];
+    const u = I(p.currentSubscriptions, R);
+    let b = !0;
+    if (process.env.NODE_ENV === "test" && typeof R.type == "string" && R.type === `${e.reducerPath}/getPolling`)
+      return [!1, p.currentPolls];
+    if (u) {
+      v || (v = setTimeout(() => {
+        const a = q(p.currentSubscriptions), [, h] = it(P, () => a);
+        d.next(e.internalActions.subscriptionsUpdated(h)), P = a, v = null;
       }, 500));
-      const l = typeof u.type == "string" && !!u.type.startsWith(v), I = r.rejected.match(u) && u.meta.condition && !!u.meta.arg.subscribe;
-      h = !l && !I;
+      const o = typeof R.type == "string" && !!R.type.startsWith(y), r = i.rejected.match(R) && R.meta.condition && !!R.meta.arg.subscribe;
+      b = !o && !r;
     }
-    return [h, !1];
+    return [b, !1];
   };
-};
-function _t(e) {
-  for (const r in e)
-    return !1;
-  return !0;
-}
-var xt = 2147483647 / 1e3 - 1, Ft = ({
+}, $t = 2147483647 / 1e3 - 1, Ut = ({
   reducerPath: e,
-  api: r,
+  api: i,
   queryThunk: p,
-  context: v,
+  context: S,
   internalState: y,
   selectors: {
-    selectQueryEntry: q,
-    selectConfig: b
-  }
+    selectQueryEntry: P,
+    selectConfig: v
+  },
+  getRunningQueryThunk: M,
+  mwApi: D
 }) => {
   const {
-    removeQueryResult: O,
-    unsubscribeQueryResult: j,
-    cacheEntriesUpserted: E
-  } = r.internalActions, D = be(j.match, p.fulfilled, p.rejected, E.match);
-  function S(h) {
-    const l = y.currentSubscriptions[h];
-    return !!l && !_t(l);
+    removeQueryResult: I,
+    unsubscribeQueryResult: O,
+    cacheEntriesUpserted: A
+  } = i.internalActions, E = be(O.match, p.fulfilled, p.rejected, A.match);
+  function Q(o) {
+    const r = y.currentSubscriptions.get(o);
+    return r ? r.size > 0 : !1;
+  }
+  const q = {};
+  function R(o) {
+    var r;
+    for (const a of o.values())
+      (r = a == null ? void 0 : a.abort) == null || r.call(a);
   }
-  const f = {}, u = (h, l, I) => {
-    const c = l.getState(), n = b(c);
-    if (D(h)) {
-      let d;
-      if (E.match(h))
-        d = h.payload.map((P) => P.queryDescription.queryCacheKey);
+  const d = (o, r) => {
+    const a = r.getState(), h = v(a);
+    if (E(o)) {
+      let m;
+      if (A.match(o))
+        m = o.payload.map((g) => g.queryDescription.queryCacheKey);
       else {
         const {
-          queryCacheKey: P
-        } = j.match(h) ? h.payload : h.meta.arg;
-        d = [P];
+          queryCacheKey: g
+        } = O.match(o) ? o.payload : o.meta.arg;
+        m = [g];
       }
-      m(d, l, n);
+      u(m, r, h);
     }
-    if (r.util.resetApiState.match(h))
-      for (const [d, P] of Object.entries(f))
-        P && clearTimeout(P), delete f[d];
-    if (v.hasRehydrationInfo(h)) {
+    if (i.util.resetApiState.match(o)) {
+      for (const [m, g] of Object.entries(q))
+        g && clearTimeout(g), delete q[m];
+      R(y.runningQueries), R(y.runningMutations);
+    }
+    if (S.hasRehydrationInfo(o)) {
       const {
-        queries: d
-      } = v.extractRehydrationInfo(h);
-      m(Object.keys(d), l, n);
+        queries: m
+      } = S.extractRehydrationInfo(o);
+      u(Object.keys(m), r, h);
     }
   };
-  function m(h, l, I) {
-    const c = l.getState();
-    for (const n of h) {
-      const d = q(c, n);
-      A(n, d == null ? void 0 : d.endpointName, l, I);
+  function u(o, r, a) {
+    const h = r.getState();
+    for (const m of o) {
+      const g = P(h, m);
+      g != null && g.endpointName && b(m, g.endpointName, r, a);
     }
   }
-  function A(h, l, I, c) {
-    const n = v.endpointDefinitions[l], d = (n == null ? void 0 : n.keepUnusedDataFor) ?? c.keepUnusedDataFor;
-    if (d === 1 / 0)
+  function b(o, r, a, h) {
+    const m = S.endpointDefinitions[r], g = (m == null ? void 0 : m.keepUnusedDataFor) ?? h.keepUnusedDataFor;
+    if (g === 1 / 0)
       return;
-    const P = Math.max(0, Math.min(d, xt));
-    if (!S(h)) {
-      const w = f[h];
-      w && clearTimeout(w), f[h] = setTimeout(() => {
-        S(h) || I.dispatch(O({
-          queryCacheKey: h
-        })), delete f[h];
-      }, P * 1e3);
+    const f = Math.max(0, Math.min(g, $t));
+    if (!Q(o)) {
+      const c = q[o];
+      c && clearTimeout(c), q[o] = setTimeout(() => {
+        if (!Q(o)) {
+          const t = P(a.getState(), o);
+          if (t != null && t.endpointName) {
+            const n = a.dispatch(M(t.endpointName, t.originalArgs));
+            n == null || n.abort();
+          }
+          a.dispatch(I({
+            queryCacheKey: o
+          }));
+        }
+        delete q[o];
+      }, f * 1e3);
     }
   }
-  return u;
-}, Je = new Error("Promise never resolved before cacheEntryRemoved."), $t = ({
+  return d;
+}, Ze = new Error("Promise never resolved before cacheEntryRemoved."), Kt = ({
   api: e,
-  reducerPath: r,
+  reducerPath: i,
   context: p,
-  queryThunk: v,
+  queryThunk: S,
   mutationThunk: y,
-  internalState: q,
+  internalState: P,
   selectors: {
-    selectQueryEntry: b,
-    selectApiState: O
+    selectQueryEntry: v,
+    selectApiState: M
   }
 }) => {
-  const j = ke(v), E = ke(y), D = ne(v, y), S = {};
-  function f(l, I, c) {
-    const n = S[l];
-    n != null && n.valueResolved && (n.valueResolved({
-      data: I,
-      meta: c
-    }), delete n.valueResolved);
+  const D = xe(S), I = xe(y), O = re(S, y), A = {};
+  function E(u, b, o) {
+    const r = A[u];
+    r != null && r.valueResolved && (r.valueResolved({
+      data: b,
+      meta: o
+    }), delete r.valueResolved);
   }
-  function u(l) {
-    const I = S[l];
-    I && (delete S[l], I.cacheEntryRemoved());
+  function Q(u) {
+    const b = A[u];
+    b && (delete A[u], b.cacheEntryRemoved());
   }
-  const m = (l, I, c) => {
-    const n = A(l);
-    function d(P, w, Q, g) {
-      const a = b(c, w), t = b(I.getState(), w);
-      !a && t && h(P, g, w, I, Q);
+  const q = (u, b, o) => {
+    const r = R(u);
+    function a(h, m, g, f) {
+      const c = v(o, m), t = v(b.getState(), m);
+      !c && t && d(h, f, m, b, g);
     }
-    if (v.pending.match(l))
-      d(l.meta.arg.endpointName, n, l.meta.requestId, l.meta.arg.originalArgs);
-    else if (e.internalActions.cacheEntriesUpserted.match(l))
+    if (S.pending.match(u))
+      a(u.meta.arg.endpointName, r, u.meta.requestId, u.meta.arg.originalArgs);
+    else if (e.internalActions.cacheEntriesUpserted.match(u))
       for (const {
-        queryDescription: P,
-        value: w
-      } of l.payload) {
+        queryDescription: h,
+        value: m
+      } of u.payload) {
         const {
-          endpointName: Q,
-          originalArgs: g,
-          queryCacheKey: a
-        } = P;
-        d(Q, a, l.meta.requestId, g), f(a, w, {});
+          endpointName: g,
+          originalArgs: f,
+          queryCacheKey: c
+        } = h;
+        a(g, c, u.meta.requestId, f), E(c, m, {});
       }
-    else if (y.pending.match(l))
-      I.getState()[r].mutations[n] && h(l.meta.arg.endpointName, l.meta.arg.originalArgs, n, I, l.meta.requestId);
-    else if (D(l))
-      f(n, l.payload, l.meta.baseQueryMeta);
-    else if (e.internalActions.removeQueryResult.match(l) || e.internalActions.removeMutationResult.match(l))
-      u(n);
-    else if (e.util.resetApiState.match(l))
-      for (const P of Object.keys(S))
-        u(P);
+    else if (y.pending.match(u))
+      b.getState()[i].mutations[r] && d(u.meta.arg.endpointName, u.meta.arg.originalArgs, r, b, u.meta.requestId);
+    else if (O(u))
+      E(r, u.payload, u.meta.baseQueryMeta);
+    else if (e.internalActions.removeQueryResult.match(u) || e.internalActions.removeMutationResult.match(u))
+      Q(r);
+    else if (e.util.resetApiState.match(u))
+      for (const h of Object.keys(A))
+        Q(h);
   };
-  function A(l) {
-    return j(l) ? l.meta.arg.queryCacheKey : E(l) ? l.meta.arg.fixedCacheKey ?? l.meta.requestId : e.internalActions.removeQueryResult.match(l) ? l.payload.queryCacheKey : e.internalActions.removeMutationResult.match(l) ? ye(l.payload) : "";
+  function R(u) {
+    return D(u) ? u.meta.arg.queryCacheKey : I(u) ? u.meta.arg.fixedCacheKey ?? u.meta.requestId : e.internalActions.removeQueryResult.match(u) ? u.payload.queryCacheKey : e.internalActions.removeMutationResult.match(u) ? ge(u.payload) : "";
   }
-  function h(l, I, c, n, d) {
-    const P = p.endpointDefinitions[l], w = P == null ? void 0 : P.onCacheEntryAdded;
-    if (!w) return;
-    const Q = {}, g = new Promise((R) => {
-      Q.cacheEntryRemoved = R;
-    }), a = Promise.race([new Promise((R) => {
-      Q.valueResolved = R;
-    }), g.then(() => {
-      throw Je;
+  function d(u, b, o, r, a) {
+    const h = p.endpointDefinitions[u], m = h == null ? void 0 : h.onCacheEntryAdded;
+    if (!m) return;
+    const g = {}, f = new Promise((w) => {
+      g.cacheEntryRemoved = w;
+    }), c = Promise.race([new Promise((w) => {
+      g.valueResolved = w;
+    }), f.then(() => {
+      throw Ze;
     })]);
-    a.catch(() => {
-    }), S[c] = Q;
-    const t = e.endpoints[l].select(Re(P) ? I : c), i = n.dispatch((R, C, k) => k), s = {
-      ...n,
-      getCacheEntry: () => t(n.getState()),
-      requestId: d,
-      extra: i,
-      updateCachedData: Re(P) ? (R) => n.dispatch(e.util.updateQueryData(l, I, R)) : void 0,
-      cacheDataLoaded: a,
-      cacheEntryRemoved: g
-    }, o = w(I, s);
-    Promise.resolve(o).catch((R) => {
-      if (R !== Je)
-        throw R;
+    c.catch(() => {
+    }), A[o] = g;
+    const t = e.endpoints[u].select(Re(h) ? b : o), n = r.dispatch((w, N, x) => x), l = {
+      ...r,
+      getCacheEntry: () => t(r.getState()),
+      requestId: a,
+      extra: n,
+      updateCachedData: Re(h) ? (w) => r.dispatch(e.util.updateQueryData(u, b, w)) : void 0,
+      cacheDataLoaded: c,
+      cacheEntryRemoved: f
+    }, s = m(b, l);
+    Promise.resolve(s).catch((w) => {
+      if (w !== Ze)
+        throw w;
     });
   }
-  return m;
-}, Kt = ({
+  return q;
+}, Vt = ({
   api: e,
   context: {
-    apiUid: r
+    apiUid: i
   },
   reducerPath: p
-}) => (v, y) => {
-  var q, b;
-  e.util.resetApiState.match(v) && y.dispatch(e.internalActions.middlewareRegistered(r)), typeof process < "u" && process.env.NODE_ENV === "development" && e.internalActions.middlewareRegistered.match(v) && v.payload === r && ((b = (q = y.getState()[p]) == null ? void 0 : q.config) == null ? void 0 : b.middlewareRegistered) === "conflict" && console.warn(`There is a mismatch between slice and middleware for the reducerPath "${p}".
+}) => (S, y) => {
+  var P, v;
+  e.util.resetApiState.match(S) && y.dispatch(e.internalActions.middlewareRegistered(i)), typeof process < "u" && process.env.NODE_ENV === "development" && e.internalActions.middlewareRegistered.match(S) && S.payload === i && ((v = (P = y.getState()[p]) == null ? void 0 : P.config) == null ? void 0 : v.middlewareRegistered) === "conflict" && console.warn(`There is a mismatch between slice and middleware for the reducerPath "${p}".
 You can only have one api per reducer path, this will lead to crashes in various situations!${p === "api" ? `
 If you have multiple apis, you *have* to specify the reducerPath option when using createApi!` : ""}`);
-}, Ut = ({
+}, zt = ({
   reducerPath: e,
-  context: r,
+  context: i,
   context: {
     endpointDefinitions: p
   },
-  mutationThunk: v,
+  mutationThunk: S,
   queryThunk: y,
-  api: q,
-  assertTagType: b,
-  refetchQuery: O,
-  internalState: j
+  api: P,
+  assertTagType: v,
+  refetchQuery: M,
+  internalState: D
 }) => {
   const {
-    removeQueryResult: E
-  } = q.internalActions, D = be(ne(v), Te(v)), S = be(ne(v, y), Oe(v, y));
-  let f = [];
-  const u = (h, l) => {
-    D(h) ? A(ot(h, "invalidatesTags", p, b), l) : S(h) ? A([], l) : q.util.invalidateTags.match(h) && A(De(h.payload, void 0, void 0, void 0, void 0, b), l);
+    removeQueryResult: I
+  } = P.internalActions, O = be(re(S), Me(S)), A = be(re(S, y), Oe(S, y));
+  let E = [];
+  const Q = (d, u) => {
+    O(d) ? R(lt(d, "invalidatesTags", p, v), u) : A(d) ? R([], u) : P.util.invalidateTags.match(d) && R(Ce(d.payload, void 0, void 0, void 0, void 0, v), u);
   };
-  function m(h) {
-    var c;
+  function q(d) {
+    var o;
     const {
-      queries: l,
-      mutations: I
-    } = h;
-    for (const n of [l, I])
-      for (const d in n)
-        if (((c = n[d]) == null ? void 0 : c.status) === "pending") return !0;
+      queries: u,
+      mutations: b
+    } = d;
+    for (const r of [u, b])
+      for (const a in r)
+        if (((o = r[a]) == null ? void 0 : o.status) === "pending") return !0;
     return !1;
   }
-  function A(h, l) {
-    const I = l.getState(), c = I[e];
-    if (f.push(...h), c.config.invalidationBehavior === "delayed" && m(c))
+  function R(d, u) {
+    const b = u.getState(), o = b[e];
+    if (E.push(...d), o.config.invalidationBehavior === "delayed" && q(o))
       return;
-    const n = f;
-    if (f = [], n.length === 0) return;
-    const d = q.util.selectInvalidatedBy(I, n);
-    r.batch(() => {
-      const P = Array.from(d.values());
+    const r = E;
+    if (E = [], r.length === 0) return;
+    const a = P.util.selectInvalidatedBy(b, r);
+    i.batch(() => {
+      const h = Array.from(a.values());
       for (const {
-        queryCacheKey: w
-      } of P) {
-        const Q = c.queries[w], g = j.currentSubscriptions[w] ?? {};
-        Q && (ce(g) === 0 ? l.dispatch(E({
-          queryCacheKey: w
-        })) : Q.status !== "uninitialized" && l.dispatch(O(Q)));
+        queryCacheKey: m
+      } of h) {
+        const g = o.queries[m], f = Se(D.currentSubscriptions, m, Ae);
+        g && (f.size === 0 ? u.dispatch(I({
+          queryCacheKey: m
+        })) : g.status !== "uninitialized" && u.dispatch(M(g)));
       }
     });
   }
-  return u;
-}, Vt = ({
+  return Q;
+}, Bt = ({
   reducerPath: e,
-  queryThunk: r,
+  queryThunk: i,
   api: p,
-  refetchQuery: v,
+  refetchQuery: S,
   internalState: y
 }) => {
-  const q = {}, b = (f, u) => {
-    (p.internalActions.updateSubscriptionOptions.match(f) || p.internalActions.unsubscribeQueryResult.match(f)) && j(f.payload, u), (r.pending.match(f) || r.rejected.match(f) && f.meta.condition) && j(f.meta.arg, u), (r.fulfilled.match(f) || r.rejected.match(f) && !f.meta.condition) && O(f.meta.arg, u), p.util.resetApiState.match(f) && D();
+  const {
+    currentPolls: P,
+    currentSubscriptions: v
+  } = y, M = /* @__PURE__ */ new Set();
+  let D = null;
+  const I = (d, u) => {
+    (p.internalActions.updateSubscriptionOptions.match(d) || p.internalActions.unsubscribeQueryResult.match(d)) && O(d.payload.queryCacheKey, u), (i.pending.match(d) || i.rejected.match(d) && d.meta.condition) && O(d.meta.arg.queryCacheKey, u), (i.fulfilled.match(d) || i.rejected.match(d) && !d.meta.condition) && A(d.meta.arg, u), p.util.resetApiState.match(d) && (q(), D && (clearTimeout(D), D = null), M.clear());
   };
-  function O({
-    queryCacheKey: f
+  function O(d, u) {
+    M.add(d), D || (D = setTimeout(() => {
+      for (const b of M)
+        E({
+          queryCacheKey: b
+        }, u);
+      M.clear(), D = null;
+    }, 0));
+  }
+  function A({
+    queryCacheKey: d
   }, u) {
-    const m = u.getState()[e], A = m.queries[f], h = y.currentSubscriptions[f];
-    if (!A || A.status === "uninitialized") return;
+    const b = u.getState()[e], o = b.queries[d], r = v.get(d);
+    if (!o || o.status === "uninitialized") return;
     const {
-      lowestPollingInterval: l,
-      skipPollingIfUnfocused: I
-    } = S(h);
-    if (!Number.isFinite(l)) return;
-    const c = q[f];
-    c != null && c.timeout && (clearTimeout(c.timeout), c.timeout = void 0);
-    const n = Date.now() + l;
-    q[f] = {
-      nextPollTimestamp: n,
-      pollingInterval: l,
+      lowestPollingInterval: a,
+      skipPollingIfUnfocused: h
+    } = R(r);
+    if (!Number.isFinite(a)) return;
+    const m = P.get(d);
+    m != null && m.timeout && (clearTimeout(m.timeout), m.timeout = void 0);
+    const g = Date.now() + a;
+    P.set(d, {
+      nextPollTimestamp: g,
+      pollingInterval: a,
       timeout: setTimeout(() => {
-        (m.config.focused || !I) && u.dispatch(v(A)), O({
-          queryCacheKey: f
+        (b.config.focused || !h) && u.dispatch(S(o)), A({
+          queryCacheKey: d
         }, u);
-      }, l)
-    };
+      }, a)
+    });
   }
-  function j({
-    queryCacheKey: f
+  function E({
+    queryCacheKey: d
   }, u) {
-    const A = u.getState()[e].queries[f], h = y.currentSubscriptions[f];
-    if (!A || A.status === "uninitialized")
+    const o = u.getState()[e].queries[d], r = v.get(d);
+    if (!o || o.status === "uninitialized")
       return;
     const {
-      lowestPollingInterval: l
-    } = S(h);
-    if (!Number.isFinite(l)) {
-      E(f);
+      lowestPollingInterval: a
+    } = R(r);
+    if (process.env.NODE_ENV === "test") {
+      const g = P.pollUpdateCounters ?? (P.pollUpdateCounters = {});
+      g[d] ?? (g[d] = 0), g[d]++;
+    }
+    if (!Number.isFinite(a)) {
+      Q(d);
       return;
     }
-    const I = q[f], c = Date.now() + l;
-    (!I || c < I.nextPollTimestamp) && O({
-      queryCacheKey: f
+    const h = P.get(d), m = Date.now() + a;
+    (!h || m < h.nextPollTimestamp) && A({
+      queryCacheKey: d
     }, u);
   }
-  function E(f) {
-    const u = q[f];
-    u != null && u.timeout && clearTimeout(u.timeout), delete q[f];
+  function Q(d) {
+    const u = P.get(d);
+    u != null && u.timeout && clearTimeout(u.timeout), P.delete(d);
   }
-  function D() {
-    for (const f of Object.keys(q))
-      E(f);
+  function q() {
+    for (const d of P.keys())
+      Q(d);
   }
-  function S(f = {}) {
-    let u = !1, m = Number.POSITIVE_INFINITY;
-    for (let A in f)
-      f[A].pollingInterval && (m = Math.min(f[A].pollingInterval, m), u = f[A].skipPollingIfUnfocused || u);
+  function R(d = /* @__PURE__ */ new Map()) {
+    let u = !1, b = Number.POSITIVE_INFINITY;
+    for (const o of d.values())
+      o.pollingInterval && (b = Math.min(o.pollingInterval, b), u = o.skipPollingIfUnfocused || u);
     return {
-      lowestPollingInterval: m,
+      lowestPollingInterval: b,
       skipPollingIfUnfocused: u
     };
   }
-  return b;
-}, Bt = ({
+  return I;
+}, Wt = ({
   api: e,
-  context: r,
+  context: i,
   queryThunk: p,
-  mutationThunk: v
+  mutationThunk: S
 }) => {
-  const y = Ze(p, v), q = Oe(p, v), b = ne(p, v), O = {};
-  return (E, D) => {
-    var S, f;
-    if (y(E)) {
+  const y = rt(p, S), P = Oe(p, S), v = re(p, S), M = {};
+  return (I, O) => {
+    var A, E;
+    if (y(I)) {
       const {
-        requestId: u,
+        requestId: Q,
         arg: {
-          endpointName: m,
-          originalArgs: A
+          endpointName: q,
+          originalArgs: R
         }
-      } = E.meta, h = r.endpointDefinitions[m], l = h == null ? void 0 : h.onQueryStarted;
-      if (l) {
-        const I = {}, c = new Promise((w, Q) => {
-          I.resolve = w, I.reject = Q;
+      } = I.meta, d = i.endpointDefinitions[q], u = d == null ? void 0 : d.onQueryStarted;
+      if (u) {
+        const b = {}, o = new Promise((m, g) => {
+          b.resolve = m, b.reject = g;
         });
-        c.catch(() => {
-        }), O[u] = I;
-        const n = e.endpoints[m].select(Re(h) ? A : u), d = D.dispatch((w, Q, g) => g), P = {
-          ...D,
-          getCacheEntry: () => n(D.getState()),
-          requestId: u,
-          extra: d,
-          updateCachedData: Re(h) ? (w) => D.dispatch(e.util.updateQueryData(m, A, w)) : void 0,
-          queryFulfilled: c
+        o.catch(() => {
+        }), M[Q] = b;
+        const r = e.endpoints[q].select(Re(d) ? R : Q), a = O.dispatch((m, g, f) => f), h = {
+          ...O,
+          getCacheEntry: () => r(O.getState()),
+          requestId: Q,
+          extra: a,
+          updateCachedData: Re(d) ? (m) => O.dispatch(e.util.updateQueryData(q, R, m)) : void 0,
+          queryFulfilled: o
         };
-        l(A, P);
+        u(R, h);
       }
-    } else if (b(E)) {
+    } else if (v(I)) {
       const {
-        requestId: u,
-        baseQueryMeta: m
-      } = E.meta;
-      (S = O[u]) == null || S.resolve({
-        data: E.payload,
-        meta: m
-      }), delete O[u];
-    } else if (q(E)) {
+        requestId: Q,
+        baseQueryMeta: q
+      } = I.meta;
+      (A = M[Q]) == null || A.resolve({
+        data: I.payload,
+        meta: q
+      }), delete M[Q];
+    } else if (P(I)) {
       const {
-        requestId: u,
-        rejectedWithValue: m,
-        baseQueryMeta: A
-      } = E.meta;
-      (f = O[u]) == null || f.reject({
-        error: E.payload ?? E.error,
-        isUnhandledError: !m,
-        meta: A
-      }), delete O[u];
+        requestId: Q,
+        rejectedWithValue: q,
+        baseQueryMeta: R
+      } = I.meta;
+      (E = M[Q]) == null || E.reject({
+        error: I.payload ?? I.error,
+        isUnhandledError: !q,
+        meta: R
+      }), delete M[Q];
     }
   };
-}, Wt = ({
+}, Ht = ({
   reducerPath: e,
-  context: r,
+  context: i,
   api: p,
-  refetchQuery: v,
+  refetchQuery: S,
   internalState: y
 }) => {
   const {
-    removeQueryResult: q
-  } = p.internalActions, b = (j, E) => {
-    Me.match(j) && O(E, "refetchOnFocus"), Ne.match(j) && O(E, "refetchOnReconnect");
+    removeQueryResult: P
+  } = p.internalActions, v = (D, I) => {
+    De.match(D) && M(I, "refetchOnFocus"), ke.match(D) && M(I, "refetchOnReconnect");
   };
-  function O(j, E) {
-    const D = j.getState()[e], S = D.queries, f = y.currentSubscriptions;
-    r.batch(() => {
-      for (const u of Object.keys(f)) {
-        const m = S[u], A = f[u];
-        if (!A || !m) continue;
-        (Object.values(A).some((l) => l[E] === !0) || Object.values(A).every((l) => l[E] === void 0) && D.config[E]) && (ce(A) === 0 ? j.dispatch(q({
-          queryCacheKey: u
-        })) : m.status !== "uninitialized" && j.dispatch(v(m)));
+  function M(D, I) {
+    const O = D.getState()[e], A = O.queries, E = y.currentSubscriptions;
+    i.batch(() => {
+      for (const Q of E.keys()) {
+        const q = A[Q], R = E.get(Q);
+        if (!R || !q) continue;
+        const d = [...R.values()];
+        (d.some((b) => b[I] === !0) || d.every((b) => b[I] === void 0) && O.config[I]) && (R.size === 0 ? D.dispatch(P({
+          queryCacheKey: Q
+        })) : q.status !== "uninitialized" && D.dispatch(S(q)));
       }
     });
   }
-  return b;
+  return v;
 };
-function zt(e) {
+function Lt(e) {
   const {
-    reducerPath: r,
+    reducerPath: i,
     queryThunk: p,
-    api: v,
-    context: y
+    api: S,
+    context: y,
+    getInternalState: P
   } = e, {
-    apiUid: q
-  } = y, b = {
-    invalidateTags: ue(`${r}/invalidateTags`)
-  }, O = (S) => S.type.startsWith(`${r}/`), j = [Kt, Ft, Ut, Vt, $t, Bt];
+    apiUid: v
+  } = y, M = {
+    invalidateTags: ue(`${i}/invalidateTags`)
+  }, D = (E) => E.type.startsWith(`${i}/`), I = [Vt, Ut, zt, Bt, Kt, Wt];
   return {
-    middleware: (S) => {
-      let f = !1;
-      const m = {
+    middleware: (E) => {
+      let Q = !1;
+      const q = P(E.dispatch), R = {
         ...e,
-        internalState: {
-          currentSubscriptions: {}
-        },
-        refetchQuery: D,
-        isThisApiSliceAction: O
-      }, A = j.map((I) => I(m)), h = kt(m), l = Wt(m);
-      return (I) => (c) => {
-        if (!dt(c))
-          return I(c);
-        f || (f = !0, S.dispatch(v.internalActions.middlewareRegistered(q)));
-        const n = {
-          ...S,
-          next: I
-        }, d = S.getState(), [P, w] = h(c, n, d);
-        let Q;
-        if (P ? Q = I(c) : Q = w, S.getState()[r] && (l(c, n, d), O(c) || y.hasRehydrationInfo(c)))
-          for (const g of A)
-            g(c, n, d);
-        return Q;
+        internalState: q,
+        refetchQuery: A,
+        isThisApiSliceAction: D,
+        mwApi: E
+      }, d = I.map((o) => o(R)), u = Ft(R), b = Ht(R);
+      return (o) => (r) => {
+        if (!ht(r))
+          return o(r);
+        Q || (Q = !0, E.dispatch(S.internalActions.middlewareRegistered(v)));
+        const a = {
+          ...E,
+          next: o
+        }, h = E.getState(), [m, g] = u(r, a, h);
+        let f;
+        if (m ? f = o(r) : f = g, E.getState()[i] && (b(r, a, h), D(r) || y.hasRehydrationInfo(r)))
+          for (const c of d)
+            c(r, a, h);
+        return f;
       };
     },
-    actions: b
+    actions: M
   };
-  function D(S) {
-    return e.api.endpoints[S.endpointName].initiate(S.originalArgs, {
+  function A(E) {
+    return e.api.endpoints[E.endpointName].initiate(E.originalArgs, {
       subscribe: !1,
       forceRefetch: !0
     });
   }
 }
-var Ye = /* @__PURE__ */ Symbol(), Ht = ({
-  createSelector: e = ut
+var et = /* @__PURE__ */ Symbol(), Jt = ({
+  createSelector: e = pt
 } = {}) => ({
-  name: Ye,
-  init(r, {
+  name: et,
+  init(i, {
     baseQuery: p,
-    tagTypes: v,
+    tagTypes: S,
     reducerPath: y,
-    serializeQueryArgs: q,
-    keepUnusedDataFor: b,
-    refetchOnMountOrArgChange: O,
-    refetchOnFocus: j,
-    refetchOnReconnect: E,
-    invalidationBehavior: D,
-    onSchemaFailure: S,
-    catchSchemaFailure: f,
-    skipSchemaValidation: u
-  }, m) {
-    ft();
-    const A = (N) => (typeof process < "u" && process.env.NODE_ENV === "development" && (v.includes(N.type) || console.error(`Tag type '${N.type}' was used, but not specified in \`tagTypes\`!`)), N);
-    Object.assign(r, {
+    serializeQueryArgs: P,
+    keepUnusedDataFor: v,
+    refetchOnMountOrArgChange: M,
+    refetchOnFocus: D,
+    refetchOnReconnect: I,
+    invalidationBehavior: O,
+    onSchemaFailure: A,
+    catchSchemaFailure: E,
+    skipSchemaValidation: Q
+  }, q) {
+    yt();
+    const R = (C) => (typeof process < "u" && process.env.NODE_ENV === "development" && (S.includes(C.type) || console.error(`Tag type '${C.type}' was used, but not specified in \`tagTypes\`!`)), C);
+    Object.assign(i, {
       reducerPath: y,
       endpoints: {},
       internalActions: {
-        onOnline: Ne,
-        onOffline: rt,
-        onFocus: Me,
-        onFocusLost: nt
+        onOnline: ke,
+        onOffline: at,
+        onFocus: De,
+        onFocusLost: ot
       },
       util: {}
     });
-    const h = Ct({
-      serializeQueryArgs: q,
+    const d = _t({
+      serializeQueryArgs: P,
       reducerPath: y,
       createSelector: e
     }), {
-      selectInvalidatedBy: l,
-      selectCachedArgsForQuery: I,
-      buildQuerySelector: c,
-      buildInfiniteQuerySelector: n,
-      buildMutationSelector: d
-    } = h;
-    Z(r.util, {
-      selectInvalidatedBy: l,
-      selectCachedArgsForQuery: I
+      selectInvalidatedBy: u,
+      selectCachedArgsForQuery: b,
+      buildQuerySelector: o,
+      buildInfiniteQuerySelector: r,
+      buildMutationSelector: a
+    } = d;
+    Z(i.util, {
+      selectInvalidatedBy: u,
+      selectCachedArgsForQuery: b
     });
     const {
-      queryThunk: P,
-      infiniteQueryThunk: w,
-      mutationThunk: Q,
-      patchQueryData: g,
-      updateQueryData: a,
+      queryThunk: h,
+      infiniteQueryThunk: m,
+      mutationThunk: g,
+      patchQueryData: f,
+      updateQueryData: c,
       upsertQueryData: t,
-      prefetch: i,
-      buildMatchThunkActions: s
-    } = Nt({
+      prefetch: n,
+      buildMatchThunkActions: l
+    } = Ct({
       baseQuery: p,
       reducerPath: y,
-      context: m,
-      api: r,
-      serializeQueryArgs: q,
-      assertTagType: A,
-      selectors: h,
-      onSchemaFailure: S,
-      catchSchemaFailure: f,
-      skipSchemaValidation: u
+      context: q,
+      api: i,
+      serializeQueryArgs: P,
+      assertTagType: R,
+      selectors: d,
+      onSchemaFailure: A,
+      catchSchemaFailure: E,
+      skipSchemaValidation: Q
     }), {
-      reducer: o,
-      actions: R
-    } = Dt({
-      context: m,
-      queryThunk: P,
-      mutationThunk: Q,
-      serializeQueryArgs: q,
+      reducer: s,
+      actions: w
+    } = jt({
+      context: q,
+      queryThunk: h,
+      mutationThunk: g,
+      serializeQueryArgs: P,
       reducerPath: y,
-      assertTagType: A,
+      assertTagType: R,
       config: {
-        refetchOnFocus: j,
-        refetchOnReconnect: E,
-        refetchOnMountOrArgChange: O,
-        keepUnusedDataFor: b,
+        refetchOnFocus: D,
+        refetchOnReconnect: I,
+        refetchOnMountOrArgChange: M,
+        keepUnusedDataFor: v,
         reducerPath: y,
-        invalidationBehavior: D
+        invalidationBehavior: O
       }
     });
-    Z(r.util, {
-      patchQueryData: g,
-      updateQueryData: a,
+    Z(i.util, {
+      patchQueryData: f,
+      updateQueryData: c,
       upsertQueryData: t,
-      prefetch: i,
-      resetApiState: R.resetApiState,
-      upsertQueryEntries: R.cacheEntriesUpserted
-    }), Z(r.internalActions, R);
-    const {
-      middleware: C,
-      actions: k
-    } = zt({
-      reducerPath: y,
-      context: m,
-      queryThunk: P,
-      mutationThunk: Q,
-      infiniteQueryThunk: w,
-      api: r,
-      assertTagType: A,
-      selectors: h
-    });
-    Z(r.util, k), Z(r, {
-      reducer: o,
-      middleware: C
-    });
-    const {
-      buildInitiateQuery: M,
+      prefetch: n,
+      resetApiState: w.resetApiState,
+      upsertQueryEntries: w.cacheEntriesUpserted
+    }), Z(i.internalActions, w);
+    const N = /* @__PURE__ */ new WeakMap(), x = (C) => Se(N, C, () => ({
+      currentSubscriptions: /* @__PURE__ */ new Map(),
+      currentPolls: /* @__PURE__ */ new Map(),
+      runningQueries: /* @__PURE__ */ new Map(),
+      runningMutations: /* @__PURE__ */ new Map()
+    })), {
+      buildInitiateQuery: k,
       buildInitiateInfiniteQuery: T,
-      buildInitiateMutation: x,
-      getRunningMutationThunk: F,
-      getRunningMutationsThunk: z,
-      getRunningQueriesThunk: H,
+      buildInitiateMutation: _,
+      getRunningMutationThunk: U,
+      getRunningMutationsThunk: B,
+      getRunningQueriesThunk: L,
       getRunningQueryThunk: K
-    } = Ot({
-      queryThunk: P,
-      mutationThunk: Q,
-      infiniteQueryThunk: w,
-      api: r,
-      serializeQueryArgs: q,
-      context: m
+    } = kt({
+      queryThunk: h,
+      mutationThunk: g,
+      infiniteQueryThunk: m,
+      api: i,
+      serializeQueryArgs: P,
+      context: q,
+      getInternalState: x
     });
-    return Z(r.util, {
-      getRunningMutationThunk: F,
-      getRunningMutationsThunk: z,
+    Z(i.util, {
+      getRunningMutationThunk: U,
+      getRunningMutationsThunk: B,
       getRunningQueryThunk: K,
-      getRunningQueriesThunk: H
+      getRunningQueriesThunk: L
+    });
+    const {
+      middleware: F,
+      actions: W
+    } = Lt({
+      reducerPath: y,
+      context: q,
+      queryThunk: h,
+      mutationThunk: g,
+      infiniteQueryThunk: m,
+      api: i,
+      assertTagType: R,
+      selectors: d,
+      getRunningQueryThunk: K,
+      getInternalState: x
+    });
+    return Z(i.util, W), Z(i, {
+      reducer: s,
+      middleware: F
     }), {
-      name: Ye,
-      injectEndpoint(N, $) {
-        var L;
-        const U = (L = r.endpoints)[N] ?? (L[N] = {});
-        Pe($) && Z(U, {
-          name: N,
-          select: c(N, $),
-          initiate: M(N, $)
-        }, s(P, N)), qt($) && Z(U, {
-          name: N,
-          select: d(),
-          initiate: x(N)
-        }, s(Q, N)), ge($) && Z(U, {
-          name: N,
-          select: n(N, $),
-          initiate: T(N, $)
-        }, s(P, N));
+      name: et,
+      injectEndpoint(C, z) {
+        var j;
+        const $ = (j = i.endpoints)[C] ?? (j[C] = {});
+        we(z) && Z($, {
+          name: C,
+          select: o(C, z),
+          initiate: k(C, z)
+        }, l(h, C)), Ot(z) && Z($, {
+          name: C,
+          select: a(),
+          initiate: _(C)
+        }, l(g, C)), he(z) && Z($, {
+          name: C,
+          select: r(C, z),
+          initiate: T(C, z)
+        }, l(h, C));
       }
     };
   }
 });
-Ht();
+Jt();
 export {
-  it as NamedSchemaError,
-  mt as QueryStatus,
-  jt as buildCreateApi,
-  tt as copyWithStructuralSharing,
-  Ht as coreModule,
-  Ye as coreModuleName,
-  Le as defaultSerializeQueryArgs,
-  Xt as fetchBaseQuery,
-  Ae as skipToken
+  ct as NamedSchemaError,
+  Rt as QueryStatus,
+  xt as buildCreateApi,
+  st as copyWithStructuralSharing,
+  Jt as coreModule,
+  et as coreModuleName,
+  Xe as defaultSerializeQueryArgs,
+  en as fetchBaseQuery,
+  Ee as skipToken
 };
 //# sourceMappingURL=rtk-query.modern.es.js.map