@ynput/ayon-frontend-shared 0.3.5 → 0.3.6

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

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