https://axis-fe.up.railway.app/node_modules/.vite/deps/chunk-WO3AQFYS.js?v=bf763330

1import __buffer_polyfill from "/node_modules/.vite/deps/vite-plugin-node-polyfills_shims_buffer.js?v=bf763330";
2globalThis.Buffer = globalThis.Buffer || __buffer_polyfill;
3import __global_polyfill from "/node_modules/.vite/deps/vite-plugin-node-polyfills_shims_global.js?v=bf763330";
4globalThis.global = globalThis.global || __global_polyfill;
5import __process_polyfill from "/node_modules/.vite/deps/vite-plugin-node-polyfills_shims_process.js?v=bf763330";
6globalThis.process = globalThis.process || __process_polyfill;
7import {
8  SHOULD_AUTOBATCH,
9  applyPatches,
10  combineReducers,
11  createAction,
12  createAsyncThunk,
13  createSelector,
14  createSlice,
15  current,
16  enablePatches,
17  formatProdErrorMessage,
18  isAction,
19  isAllOf,
20  isAnyOf,
21  isAsyncThunkAction,
22  isDraft,
23  isDraftable,
24  isFulfilled,
25  isPending,
26  isPlainObject,
27  isRejected,
28  isRejectedWithValue,
29  nanoid,
30  original,
31  prepareAutoBatched,
32  produce,
33  produceWithPatches,
34  weakMapMemoize
35} from "/node_modules/.vite/deps/chunk-2ICND253.js?v=bf763330";
36import {
37  __publicField,
38  __toESM,
39  require_dist,
40  require_dist2,
41  require_dist3
42} from "/node_modules/.vite/deps/chunk-CURNFZRR.js?v=bf763330";
43var import_dist4 = __toESM(require_dist(), 1);
44var import_dist5 = __toESM(require_dist2(), 1);
45var import_dist6 = __toESM(require_dist3(), 1);
46var import_dist = __toESM(require_dist());
47var import_dist2 = __toESM(require_dist2());
48var import_dist3 = __toESM(require_dist3());
49var SchemaError = class extends Error {
50  /**
51   * Creates a schema error with useful information.
52   *
53   * @param issues The schema issues.
54   */
55  constructor(issues) {
56    super(issues[0].message);
57    __publicField(this, "issues");
58    this.name = "SchemaError";
59    this.issues = issues;
60  }
61};
62var QueryStatus = ((QueryStatus7) => {
63  QueryStatus7["uninitialized"] = "uninitialized";
64  QueryStatus7["pending"] = "pending";
65  QueryStatus7["fulfilled"] = "fulfilled";
66  QueryStatus7["rejected"] = "rejected";
67  return QueryStatus7;
68})(QueryStatus || {});
69var STATUS_UNINITIALIZED = "uninitialized";
70var STATUS_PENDING = "pending";
71var STATUS_FULFILLED = "fulfilled";
72var STATUS_REJECTED = "rejected";
73function getRequestStatusFlags(status) {
74  return {
75    status,
76    isUninitialized: status === STATUS_UNINITIALIZED,
77    isLoading: status === STATUS_PENDING,
78    isSuccess: status === STATUS_FULFILLED,
79    isError: status === STATUS_REJECTED
80  };
81}
82var isPlainObject2 = isPlainObject;
83function copyWithStructuralSharing(oldObj, newObj) {
84  if (oldObj === newObj || !(isPlainObject2(oldObj) && isPlainObject2(newObj) || Array.isArray(oldObj) && Array.isArray(newObj))) {
85    return newObj;
86  }
87  const newKeys = Object.keys(newObj);
88  const oldKeys = Object.keys(oldObj);
89  let isSameObject = newKeys.length === oldKeys.length;
90  const mergeObj = Array.isArray(newObj) ? [] : {};
91  for (const key of newKeys) {
92    mergeObj[key] = copyWithStructuralSharing(oldObj[key], newObj[key]);
93    if (isSameObject) isSameObject = oldObj[key] === mergeObj[key];
94  }
95  return isSameObject ? oldObj : mergeObj;
96}
97function filterMap(array, predicate, mapper) {
98  return array.reduce((acc, item, i) => {
99    if (predicate(item, i)) {
100      acc.push(mapper(item, i));
101    }
102    return acc;
103  }, []).flat();
104}
105function isAbsoluteUrl(url) {
106  return new RegExp(`(^|:)//`).test(url);
107}
108function isDocumentVisible() {
109  if (typeof document === "undefined") {
110    return true;
111  }
112  return document.visibilityState !== "hidden";
113}
114function isNotNullish(v) {
115  return v != null;
116}
117function filterNullishValues(map) {
118  return [...(map == null ? void 0 : map.values()) ?? []].filter(isNotNullish);
119}
120function isOnline() {
121  return typeof navigator === "undefined" ? true : navigator.onLine === void 0 ? true : navigator.onLine;
122}
123var withoutTrailingSlash = (url) => url.replace(/\/$/, "");
124var withoutLeadingSlash = (url) => url.replace(/^\//, "");
125function joinUrls(base, url) {
126  if (!base) {
127    return url;
128  }
129  if (!url) {
130    return base;
131  }
132  if (isAbsoluteUrl(url)) {
133    return url;
134  }
135  const delimiter = base.endsWith("/") || !url.startsWith("?") ? "/" : "";
136  base = withoutTrailingSlash(base);
137  url = withoutLeadingSlash(url);
138  return `${base}${delimiter}${url}`;
139}
140function getOrInsertComputed(map, key, compute) {
141  if (map.has(key)) return map.get(key);
142  return map.set(key, compute(key)).get(key);
143}
144var createNewMap = () => /* @__PURE__ */ new Map();
145var timeoutSignal = (milliseconds) => {
146  const abortController = new AbortController();
147  setTimeout(() => {
148    const message = "signal timed out";
149    const name = "TimeoutError";
150    abortController.abort(
151      // some environments (React Native, Node) don't have DOMException
152      typeof DOMException !== "undefined" ? new DOMException(message, name) : Object.assign(new Error(message), {
153        name
154      })
155    );
156  }, milliseconds);
157  return abortController.signal;
158};
159var anySignal = (...signals) => {
160  for (const signal of signals) if (signal.aborted) return AbortSignal.abort(signal.reason);
161  const abortController = new AbortController();
162  for (const signal of signals) {
163    signal.addEventListener("abort", () => abortController.abort(signal.reason), {
164      signal: abortController.signal,
165      once: true
166    });
167  }
168  return abortController.signal;
169};
170var defaultFetchFn = (...args) => fetch(...args);
171var defaultValidateStatus = (response) => response.status >= 200 && response.status <= 299;
172var defaultIsJsonContentType = (headers) => (
173  /*applicat*/

174  /ion\/(vnd\.api\+)?json/.test(headers.get("content-type") || "")
175);
176function stripUndefined(obj) {
177  if (!isPlainObject(obj)) {
178    return obj;
179  }
180  const copy = {
181    ...obj
182  };
183  for (const [k, v] of Object.entries(copy)) {
184    if (v === void 0) delete copy[k];
185  }
186  return copy;
187}
188var isJsonifiable = (body) => typeof body === "object" && (isPlainObject(body) || Array.isArray(body) || typeof body.toJSON === "function");
189function fetchBaseQuery({
190  baseUrl,
191  prepareHeaders = (x) => x,
192  fetchFn = defaultFetchFn,
193  paramsSerializer,
194  isJsonContentType = defaultIsJsonContentType,
195  jsonContentType = "application/json",
196  jsonReplacer,
197  timeout: defaultTimeout,
198  responseHandler: globalResponseHandler,
199  validateStatus: globalValidateStatus,
200  ...baseFetchOptions
201} = {}) {
202  if (typeof fetch === "undefined" && fetchFn === defaultFetchFn) {
203    console.warn("Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments.");
204  }
205  return async (arg, api, extraOptions) => {
206    const {
207      getState,
208      extra,
209      endpoint,
210      forced,
211      type
212    } = api;
213    let meta;
214    let {
215      url,
216      headers = new Headers(baseFetchOptions.headers),
217      params = void 0,
218      responseHandler = globalResponseHandler ?? "json",
219      validateStatus = globalValidateStatus ?? defaultValidateStatus,
220      timeout = defaultTimeout,
221      ...rest
222    } = typeof arg == "string" ? {
223      url: arg
224    } : arg;
225    let config = {
226      ...baseFetchOptions,
227      signal: timeout ? anySignal(api.signal, timeoutSignal(timeout)) : api.signal,
228      ...rest
229    };
230    headers = new Headers(stripUndefined(headers));
231    config.headers = await prepareHeaders(headers, {
232      getState,
233      arg,
234      extra,
235      endpoint,
236      forced,
237      type,
238      extraOptions
239    }) || headers;
240    const bodyIsJsonifiable = isJsonifiable(config.body);
241    if (config.body != null && !bodyIsJsonifiable && typeof config.body !== "string") {
242      config.headers.delete("content-type");
243    }
244    if (!config.headers.has("content-type") && bodyIsJsonifiable) {
245      config.headers.set("content-type", jsonContentType);
246    }
247    if (bodyIsJsonifiable && isJsonContentType(config.headers)) {
248      config.body = JSON.stringify(config.body, jsonReplacer);
249    }
250    if (!config.headers.has("accept")) {
251      if (responseHandler === "json") {
252        config.headers.set("accept", "application/json");
253      } else if (responseHandler === "text") {
254        config.headers.set("accept", "text/plain, text/html, */*");
255      }
256    }
257    if (params) {
258      const divider = ~url.indexOf("?") ? "&" : "?";
259      const query = paramsSerializer ? paramsSerializer(params) : new URLSearchParams(stripUndefined(params));
260      url += divider + query;
261    }
262    url = joinUrls(baseUrl, url);
263    const request = new Request(url, config);
264    const requestClone = new Request(url, config);
265    meta = {
266      request: requestClone
267    };
268    let response;
269    try {
270      response = await fetchFn(request);
271    } catch (e) {
272      return {
273        error: {
274          status: (e instanceof Error || typeof DOMException !== "undefined" && e instanceof DOMException) && e.name === "TimeoutError" ? "TIMEOUT_ERROR" : "FETCH_ERROR",
275          error: String(e)
276        },
277        meta
278      };
279    }
280    const responseClone = response.clone();
281    meta.response = responseClone;
282    let resultData;
283    let responseText = "";
284    try {
285      let handleResponseError;
286      await Promise.all([
287        handleResponse(response, responseHandler).then((r) => resultData = r, (e) => handleResponseError = e),
288        // see https://github.com/node-fetch/node-fetch/issues/665#issuecomment-538995182
289        // we *have* to "use up" both streams at the same time or they will stop running in node-fetch scenarios
290        responseClone.text().then((r) => responseText = r, () => {
291        })
292      ]);
293      if (handleResponseError) throw handleResponseError;
294    } catch (e) {
295      return {
296        error: {
297          status: "PARSING_ERROR",
298          originalStatus: response.status,
299          data: responseText,
300          error: String(e)
301        },
302        meta
303      };
304    }
305    return validateStatus(response, resultData) ? {
306      data: resultData,
307      meta
308    } : {
309      error: {
310        status: response.status,
311        data: resultData
312      },
313      meta
314    };
315  };
316  async function handleResponse(response, responseHandler) {
317    if (typeof responseHandler === "function") {
318      return responseHandler(response);
319    }
320    if (responseHandler === "content-type") {
321      responseHandler = isJsonContentType(response.headers) ? "json" : "text";
322    }
323    if (responseHandler === "json") {
324      const text = await response.text();
325      return text.length ? JSON.parse(text) : null;
326    }
327    return response.text();
328  }
329}
330var HandledError = class {
331  constructor(value, meta = void 0) {
332    this.value = value;
333    this.meta = meta;
334  }
335};
336async function defaultBackoff(attempt = 0, maxRetries = 5, signal) {
337  const attempts = Math.min(attempt, maxRetries);
338  const timeout = ~~((Math.random() + 0.4) * (300 << attempts));
339  await new Promise((resolve, reject) => {
340    const timeoutId = setTimeout(() => resolve(), timeout);
341    if (signal) {
342      const abortHandler = () => {
343        clearTimeout(timeoutId);
344        reject(new Error("Aborted"));
345      };
346      if (signal.aborted) {
347        clearTimeout(timeoutId);
348        reject(new Error("Aborted"));
349      } else {
350        signal.addEventListener("abort", abortHandler, {
351          once: true
352        });
353      }
354    }
355  });
356}
357function fail(error, meta) {
358  throw Object.assign(new HandledError({
359    error,
360    meta
361  }), {
362    throwImmediately: true
363  });
364}
365function failIfAborted(signal) {
366  if (signal.aborted) {
367    fail({
368      status: "CUSTOM_ERROR",
369      error: "Aborted"
370    });
371  }
372}
373var EMPTY_OPTIONS = {};
374var retryWithBackoff = (baseQuery, defaultOptions) => async (args, api, extraOptions) => {
375  const possibleMaxRetries = [5, (defaultOptions || EMPTY_OPTIONS).maxRetries, (extraOptions || EMPTY_OPTIONS).maxRetries].filter((x) => x !== void 0);
376  const [maxRetries] = possibleMaxRetries.slice(-1);
377  const defaultRetryCondition = (_, __, {
378    attempt
379  }) => attempt <= maxRetries;
380  const options = {
381    maxRetries,
382    backoff: defaultBackoff,
383    retryCondition: defaultRetryCondition,
384    ...defaultOptions,
385    ...extraOptions
386  };
387  let retry2 = 0;
388  while (true) {
389    failIfAborted(api.signal);
390    try {
391      const result = await baseQuery(args, api, extraOptions);
392      if (result.error) {
393        throw new HandledError(result);
394      }
395      return result;
396    } catch (e) {
397      retry2++;
398      if (e.throwImmediately) {
399        if (e instanceof HandledError) {
400          return e.value;
401        }
402        throw e;
403      }
404      if (e instanceof HandledError) {
405        if (!options.retryCondition(e.value.error, args, {
406          attempt: retry2,
407          baseQueryApi: api,
408          extraOptions
409        })) {
410          return e.value;
411        }
412      } else {
413        if (retry2 > options.maxRetries) {
414          return {
415            error: e
416          };
417        }
418      }
419      failIfAborted(api.signal);

420      try {
421        await options.backoff(retry2, options.maxRetries, api.signal);
422      } catch (backoffError) {
423        failIfAborted(api.signal);
424        throw backoffError;
425      }
426    }
427  }
428};
429var retry = Object.assign(retryWithBackoff, {
430  fail
431});
432var INTERNAL_PREFIX = "__rtkq/";
433var ONLINE = "online";
434var OFFLINE = "offline";
435var FOCUS = "focus";
436var FOCUSED = "focused";
437var VISIBILITYCHANGE = "visibilitychange";
438var onFocus = createAction(`${INTERNAL_PREFIX}${FOCUSED}`);
439var onFocusLost = createAction(`${INTERNAL_PREFIX}un${FOCUSED}`);
440var onOnline = createAction(`${INTERNAL_PREFIX}${ONLINE}`);
441var onOffline = createAction(`${INTERNAL_PREFIX}${OFFLINE}`);
442var actions = {
443  onFocus,
444  onFocusLost,
445  onOnline,
446  onOffline
447};
448var initialized = false;
449function setupListeners(dispatch, customHandler) {
450  function defaultHandler() {
451    const [handleFocus, handleFocusLost, handleOnline, handleOffline] = [onFocus, onFocusLost, onOnline, onOffline].map((action) => () => dispatch(action()));
452    const handleVisibilityChange = () => {
453      if (window.document.visibilityState === "visible") {
454        handleFocus();
455      } else {
456        handleFocusLost();
457      }
458    };
459    let unsubscribe = () => {
460      initialized = false;
461    };
462    if (!initialized) {
463      if (typeof window !== "undefined" && window.addEventListener) {
464        let updateListeners2 = function(add) {
465          Object.entries(handlers).forEach(([event, handler]) => {
466            if (add) {
467              window.addEventListener(event, handler, false);
468            } else {
469              window.removeEventListener(event, handler);
470            }
471          });
472        };
473        var updateListeners = updateListeners2;
474        const handlers = {
475          [FOCUS]: handleFocus,
476          [VISIBILITYCHANGE]: handleVisibilityChange,
477          [ONLINE]: handleOnline,
478          [OFFLINE]: handleOffline
479        };
480        updateListeners2(true);
481        initialized = true;
482        unsubscribe = () => {
483          updateListeners2(false);
484          initialized = false;
485        };
486      }
487    }
488    return unsubscribe;
489  }
490  return customHandler ? customHandler(dispatch, actions) : defaultHandler();
491}
492var ENDPOINT_QUERY = "query";
493var ENDPOINT_MUTATION = "mutation";
494var ENDPOINT_INFINITEQUERY = "infinitequery";
495function isQueryDefinition(e) {
496  return e.type === ENDPOINT_QUERY;
497}
498function isMutationDefinition(e) {
499  return e.type === ENDPOINT_MUTATION;
500}
501function isInfiniteQueryDefinition(e) {
502  return e.type === ENDPOINT_INFINITEQUERY;
503}
504function isAnyQueryDefinition(e) {
505  return isQueryDefinition(e) || isInfiniteQueryDefinition(e);
506}
507function calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {
508  const finalDescription = isFunction(description) ? description(result, error, queryArg, meta) : description;
509  if (finalDescription) {
510    return filterMap(finalDescription, isNotNullish, (tag) => assertTagTypes(expandTagDescription(tag)));
511  }
512  return [];
513}
514function isFunction(t) {
515  return typeof t === "function";
516}
517function expandTagDescription(description) {
518  return typeof description === "string" ? {
519    type: description
520  } : description;
521}
522function asSafePromise(promise, fallback) {
523  return promise.catch(fallback);
524}
525var getEndpointDefinition = (context, endpointName) => context.endpointDefinitions[endpointName];
526var forceQueryFnSymbol = Symbol("forceQueryFn");
527var isUpsertQuery = (arg) => typeof arg[forceQueryFnSymbol] === "function";
528function buildInitiate({
529  serializeQueryArgs,
530  queryThunk,
531  infiniteQueryThunk,
532  mutationThunk,
533  api,
534  context,
535  getInternalState
536}) {
537  const getRunningQueries = (dispatch) => {
538    var _a;
539    return (_a = getInternalState(dispatch)) == null ? void 0 : _a.runningQueries;
540  };
541  const getRunningMutations = (dispatch) => {
542    var _a;
543    return (_a = getInternalState(dispatch)) == null ? void 0 : _a.runningMutations;
544  };
545  const {
546    unsubscribeQueryResult,
547    removeMutationResult,
548    updateSubscriptionOptions
549  } = api.internalActions;
550  return {
551    buildInitiateQuery,
552    buildInitiateInfiniteQuery,
553    buildInitiateMutation,
554    getRunningQueryThunk,
555    getRunningMutationThunk,
556    getRunningQueriesThunk,
557    getRunningMutationsThunk
558  };
559  function getRunningQueryThunk(endpointName, queryArgs) {
560    return (dispatch) => {
561      var _a;
562      const endpointDefinition = getEndpointDefinition(context, endpointName);
563      const queryCacheKey = serializeQueryArgs({
564        queryArgs,
565        endpointDefinition,
566        endpointName
567      });
568      return (_a = getRunningQueries(dispatch)) == null ? void 0 : _a.get(queryCacheKey);
569    };
570  }
571  function getRunningMutationThunk(_endpointName, fixedCacheKeyOrRequestId) {
572    return (dispatch) => {
573      var _a;
574      return (_a = getRunningMutations(dispatch)) == null ? void 0 : _a.get(fixedCacheKeyOrRequestId);
575    };
576  }
577  function getRunningQueriesThunk() {
578    return (dispatch) => filterNullishValues(getRunningQueries(dispatch));
579  }
580  function getRunningMutationsThunk() {
581    return (dispatch) => filterNullishValues(getRunningMutations(dispatch));
582  }

583  function middlewareWarning(dispatch) {
584    if (true) {
585      if (middlewareWarning.triggered) return;
586      const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());
587      middlewareWarning.triggered = true;
588      if (typeof returnedValue !== "object" || typeof (returnedValue == null ? void 0 : returnedValue.type) === "string") {
589        throw new Error(false ? formatProdErrorMessage(34) : `Warning: Middleware for RTK-Query API at reducerPath "${api.reducerPath}" has not been added to the store.
590You must add the middleware for RTK-Query to function correctly!`);
591      }
592    }
593  }
594  function buildInitiateAnyQuery(endpointName, endpointDefinition) {
595    const queryAction = (arg, {
596      subscribe = true,
597      forceRefetch,
598      subscriptionOptions,
599      [forceQueryFnSymbol]: forceQueryFn,
600      ...rest
601    } = {}) => (dispatch, getState) => {
602      var _a;
603      const queryCacheKey = serializeQueryArgs({
604        queryArgs: arg,
605        endpointDefinition,
606        endpointName
607      });
608      let thunk;
609      const commonThunkArgs = {
610        ...rest,
611        type: ENDPOINT_QUERY,
612        subscribe,
613        forceRefetch,
614        subscriptionOptions,
615        endpointName,
616        originalArgs: arg,
617        queryCacheKey,
618        [forceQueryFnSymbol]: forceQueryFn
619      };
620      if (isQueryDefinition(endpointDefinition)) {
621        thunk = queryThunk(commonThunkArgs);
622      } else {
623        const {
624          direction,
625          initialPageParam,
626          refetchCachedPages
627        } = rest;
628        thunk = infiniteQueryThunk({
629          ...commonThunkArgs,
630          // Supply these even if undefined. This helps with a field existence
631          // check over in `buildSlice.ts`
632          direction,
633          initialPageParam,
634          refetchCachedPages
635        });
636      }
637      const selector = api.endpoints[endpointName].select(arg);
638      const thunkResult = dispatch(thunk);
639      const stateAfter = selector(getState());
640      middlewareWarning(dispatch);
641      const {
642        requestId,
643        abort
644      } = thunkResult;
645      const skippedSynchronously = stateAfter.requestId !== requestId;
646      const runningQuery = (_a = getRunningQueries(dispatch)) == null ? void 0 : _a.get(queryCacheKey);
647      const selectFromState = () => selector(getState());
648      const statePromise = Object.assign(forceQueryFn ? (
649        // a query has been forced (upsertQueryData)
650        // -> we want to resolve it once data has been written with the data that will be written
651        thunkResult.then(selectFromState)
652      ) : skippedSynchronously && !runningQuery ? (
653        // a query has been skipped due to a condition and we do not have any currently running query
654        // -> we want to resolve it immediately with the current data
655        Promise.resolve(stateAfter)
656      ) : (
657        // query just started or one is already in flight
658        // -> wait for the running query, then resolve with data from after that
659        Promise.all([runningQuery, thunkResult]).then(selectFromState)
660      ), {
661        arg,
662        requestId,
663        subscriptionOptions,
664        queryCacheKey,
665        abort,
666        async unwrap() {
667          const result = await statePromise;
668          if (result.isError) {
669            throw result.error;
670          }
671          return result.data;
672        },
673        refetch: (options) => dispatch(queryAction(arg, {
674          subscribe: false,
675          forceRefetch: true,
676          ...options
677        })),
678        unsubscribe() {
679          if (subscribe) dispatch(unsubscribeQueryResult({
680            queryCacheKey,
681            requestId
682          }));
683        },
684        updateSubscriptionOptions(options) {
685          statePromise.subscriptionOptions = options;
686          dispatch(updateSubscriptionOptions({
687            endpointName,
688            requestId,
689            queryCacheKey,
690            options
691          }));
692        }
693      });
694      if (!runningQuery && !skippedSynchronously && !forceQueryFn) {
695        const runningQueries = getRunningQueries(dispatch);
696        runningQueries.set(queryCacheKey, statePromise);
697        statePromise.then(() => {
698          runningQueries.delete(queryCacheKey);
699        });
700      }
701      return statePromise;
702    };
703    return queryAction;
704  }
705  function buildInitiateQuery(endpointName, endpointDefinition) {
706    const queryAction = buildInitiateAnyQuery(endpointName, endpointDefinition);
707    return queryAction;
708  }
709  function buildInitiateInfiniteQuery(endpointName, endpointDefinition) {
710    const infiniteQueryAction = buildInitiateAnyQuery(endpointName, endpointDefinition);
711    return infiniteQueryAction;
712  }

713  function buildInitiateMutation(endpointName) {
714    return (arg, {
715      track = true,
716      fixedCacheKey
717    } = {}) => (dispatch, getState) => {
718      const thunk = mutationThunk({
719        type: "mutation",
720        endpointName,
721        originalArgs: arg,
722        track,
723        fixedCacheKey
724      });
725      const thunkResult = dispatch(thunk);
726      middlewareWarning(dispatch);
727      const {
728        requestId,
729        abort,
730        unwrap
731      } = thunkResult;
732      const returnValuePromise = asSafePromise(thunkResult.unwrap().then((data) => ({
733        data
734      })), (error) => ({
735        error
736      }));
737      const reset = () => {
738        dispatch(removeMutationResult({
739          requestId,
740          fixedCacheKey
741        }));
742      };
743      const ret = Object.assign(returnValuePromise, {
744        arg: thunkResult.arg,
745        requestId,
746        abort,
747        unwrap,
748        reset
749      });
750      const runningMutations = getRunningMutations(dispatch);
751      runningMutations.set(requestId, ret);
752      ret.then(() => {
753        runningMutations.delete(requestId);
754      });
755      if (fixedCacheKey) {
756        runningMutations.set(fixedCacheKey, ret);
757        ret.then(() => {
758          if (runningMutations.get(fixedCacheKey) === ret) {
759            runningMutations.delete(fixedCacheKey);
760          }
761        });
762      }
763      return ret;
764    };
765  }
766}
767var NamedSchemaError = class extends SchemaError {
768  constructor(issues, value, schemaName, _bqMeta) {
769    super(issues);
770    this.value = value;
771    this.schemaName = schemaName;
772    this._bqMeta = _bqMeta;
773  }
774};
775var shouldSkip = (skipSchemaValidation, schemaName) => Array.isArray(skipSchemaValidation) ? skipSchemaValidation.includes(schemaName) : !!skipSchemaValidation;
776async function parseWithSchema(schema, data, schemaName, bqMeta) {
777  const result = await schema["~standard"].validate(data);
778  if (result.issues) {
779    throw new NamedSchemaError(result.issues, data, schemaName, bqMeta);
780  }
781  return result.value;
782}
783function defaultTransformResponse(baseQueryReturnValue) {
784  return baseQueryReturnValue;
785}
786var addShouldAutoBatch = (arg = {}) => {
787  return {
788    ...arg,
789    [SHOULD_AUTOBATCH]: true
790  };
791};
792function buildThunks({
793  reducerPath,
794  baseQuery,
795  context: {
796    endpointDefinitions
797  },
798  serializeQueryArgs,
799  api,
800  assertTagType,
801  selectors,
802  onSchemaFailure,
803  catchSchemaFailure: globalCatchSchemaFailure,
804  skipSchemaValidation: globalSkipSchemaValidation
805}) {
806  const patchQueryData = (endpointName, arg, patches, updateProvided) => (dispatch, getState) => {
807    const endpointDefinition = endpointDefinitions[endpointName];
808    const queryCacheKey = serializeQueryArgs({
809      queryArgs: arg,
810      endpointDefinition,
811      endpointName
812    });
813    dispatch(api.internalActions.queryResultPatched({
814      queryCacheKey,
815      patches
816    }));
817    if (!updateProvided) {
818      return;
819    }
820    const newValue = api.endpoints[endpointName].select(arg)(
821      // Work around TS 4.1 mismatch
822      getState()
823    );
824    const providedTags = calculateProvidedBy(endpointDefinition.providesTags, newValue.data, void 0, arg, {}, assertTagType);
825    dispatch(api.internalActions.updateProvidedBy([{
826      queryCacheKey,
827      providedTags
828    }]));
829  };
830  function addToStart(items, item, max = 0) {
831    const newItems = [item, ...items];
832    return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
833  }
834  function addToEnd(items, item, max = 0) {
835    const newItems = [...items, item];
836    return max && newItems.length > max ? newItems.slice(1) : newItems;
837  }
838  const updateQueryData = (endpointName, arg, updateRecipe, updateProvided = true) => (dispatch, getState) => {
839    const endpointDefinition = api.endpoints[endpointName];
840    const currentState = endpointDefinition.select(arg)(
841      // Work around TS 4.1 mismatch
842      getState()
843    );
844    const ret = {
845      patches: [],
846      inversePatches: [],
847      undo: () => dispatch(api.util.patchQueryData(endpointName, arg, ret.inversePatches, updateProvided))
848    };
849    if (currentState.status === STATUS_UNINITIALIZED) {
850      return ret;
851    }
852    let newValue;
853    if ("data" in currentState) {
854      if (isDraftable(currentState.data)) {
855        const [value, patches, inversePatches] = produceWithPatches(currentState.data, updateRecipe);
856        ret.patches.push(...patches);
857        ret.inversePatches.push(...inversePatches);
858        newValue = value;
859      } else {
860        newValue = updateRecipe(currentState.data);
861        ret.patches.push({
862          op: "replace",
863          path: [],
864          value: newValue
865        });
866        ret.inversePatches.push({
867          op: "replace",
868          path: [],
869          value: currentState.data
870        });
871      }
872    }
873    if (ret.patches.length === 0) {
874      return ret;
875    }
876    dispatch(api.util.patchQueryData(endpointName, arg, ret.patches, updateProvided));
877    return ret;
878  };
879  const upsertQueryData = (endpointName, arg, value) => (dispatch) => {
880    const res = dispatch(api.endpoints[endpointName].initiate(arg, {
881      subscribe: false,
882      forceRefetch: true,
883      [forceQueryFnSymbol]: () => ({
884        data: value
885      })
886    }));
887    return res;
888  };
889  const getTransformCallbackForEndpoint = (endpointDefinition, transformFieldName) => {
890    return endpointDefinition.query && endpointDefinition[transformFieldName] ? endpointDefinition[transformFieldName] : defaultTransformResponse;
891  };
892  const executeEndpoint = async (arg, {
893    signal,
894    abort,
895    rejectWithValue,
896    fulfillWithValue,
897    dispatch,
898    getState,
899    extra
900  }) => {
901    var _a, _b;

901
902    const endpointDefinition = endpointDefinitions[arg.endpointName];
903    const {
904      metaSchema,
905      skipSchemaValidation = globalSkipSchemaValidation
906    } = endpointDefinition;
907    const isQuery = arg.type === ENDPOINT_QUERY;
908    try {
909      let transformResponse = defaultTransformResponse;
910      const baseQueryApi = {
911        signal,
912        abort,
913        dispatch,
914        getState,
915        extra,
916        endpoint: arg.endpointName,
917        type: arg.type,
918        forced: isQuery ? isForcedQuery(arg, getState()) : void 0,
919        queryCacheKey: isQuery ? arg.queryCacheKey : void 0
920      };
921      const forceQueryFn = isQuery ? arg[forceQueryFnSymbol] : void 0;
922      let finalQueryReturnValue;
923      const fetchPage = async (data, param, maxPages, previous) => {
924        if (param == null && data.pages.length) {
925          return Promise.resolve({
926            data
927          });
928        }
929        const finalQueryArg = {
930          queryArg: arg.originalArgs,
931          pageParam: param
932        };
933        const pageResponse = await executeRequest(finalQueryArg);
934        const addTo = previous ? addToStart : addToEnd;
935        return {
936          data: {
937            pages: addTo(data.pages, pageResponse.data, maxPages),
938            pageParams: addTo(data.pageParams, param, maxPages)
939          },
940          meta: pageResponse.meta
941        };
942      };
943      async function executeRequest(finalQueryArg) {
944        let result;
945        const {
946          extraOptions,
947          argSchema,
948          rawResponseSchema,
949          responseSchema
950        } = endpointDefinition;
951        if (argSchema && !shouldSkip(skipSchemaValidation, "arg")) {
952          finalQueryArg = await parseWithSchema(
953            argSchema,
954            finalQueryArg,
955            "argSchema",
956            {}
957            // we don't have a meta yet, so we can't pass it
958          );
959        }
960        if (forceQueryFn) {
961          result = forceQueryFn();
962        } else if (endpointDefinition.query) {
963          transformResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformResponse");
964          result = await baseQuery(endpointDefinition.query(finalQueryArg), baseQueryApi, extraOptions);
965        } else {
966          result = await endpointDefinition.queryFn(finalQueryArg, baseQueryApi, extraOptions, (arg2) => baseQuery(arg2, baseQueryApi, extraOptions));
967        }
968        if (typeof process !== "undefined" && true) {
969          const what = endpointDefinition.query ? "`baseQuery`" : "`queryFn`";
970          let err;
971          if (!result) {
972            err = `${what} did not return anything.`;
973          } else if (typeof result !== "object") {
974            err = `${what} did not return an object.`;
975          } else if (result.error && result.data) {
976            err = `${what} returned an object containing both \`error\` and \`result\`.`;
977          } else if (result.error === void 0 && result.data === void 0) {
978            err = `${what} returned an object containing neither a valid \`error\` and \`result\`. At least one of them should not be \`undefined\``;
979          } else {
980            for (const key of Object.keys(result)) {
981              if (key !== "error" && key !== "data" && key !== "meta") {
982                err = `The object returned by ${what} has the unknown property ${key}.`;
983                break;
984              }
985            }
986          }
987          if (err) {
988            console.error(`Error encountered handling the endpoint ${arg.endpointName}.
989                  ${err}
990                  It needs to return an object with either the shape \`{ data: <value> }\` or \`{ error: <value> }\` that may contain an optional \`meta\` property.
991                  Object returned was:`, result);
992          }
993        }
994        if (result.error) throw new HandledError(result.error, result.meta);
995        let {
996          data
997        } = result;
998        if (rawResponseSchema && !shouldSkip(skipSchemaValidation, "rawResponse")) {
999          data = await parseWithSchema(rawResponseSchema, result.data, "rawResponseSchema", result.meta);
1000        }
1001        let transformedResponse = await transformResponse(data, result.meta, finalQueryArg);
1002        if (responseSchema && !shouldSkip(skipSchemaValidation, "response")) {
1003          transformedResponse = await parseWithSchema(responseSchema, transformedResponse, "responseSchema", result.meta);
1004        }
1005        return {
1006          ...result,
1007          data: transformedResponse
1008        };
1009      }
1010      if (isQuery && "infiniteQueryOptions" in endpointDefinition) {
1011        const {
1012          infiniteQueryOptions
1013        } = endpointDefinition;
1014        const {
1015          maxPages = Infinity
1016        } = infiniteQueryOptions;
1017        const refetchCachedPages = arg.refetchCachedPages ?? infiniteQueryOptions.refetchCachedPages ?? true;
1018        let result;
1019        const blankData = {
1020          pages: [],
1021          pageParams: []
1022        };
1023        const cachedData = 

1023(_a = selectors.selectQueryEntry(getState(), arg.queryCacheKey)) == null ? void 0 : _a.data;
1024        const isForcedQueryNeedingRefetch = (
1025          // arg.forceRefetch
1026          isForcedQuery(arg, getState()) && !arg.direction
1027        );
1028        const existingData = isForcedQueryNeedingRefetch || !cachedData ? blankData : cachedData;
1029        if ("direction" in arg && arg.direction && existingData.pages.length) {
1030          const previous = arg.direction === "backward";
1031          const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
1032          const param = pageParamFn(infiniteQueryOptions, existingData, arg.originalArgs);
1033          result = await fetchPage(existingData, param, maxPages, previous);
1034        } else {
1035          const {
1036            initialPageParam = infiniteQueryOptions.initialPageParam
1037          } = arg;
1038          const cachedPageParams = (cachedData == null ? void 0 : cachedData.pageParams) ?? [];
1039          const firstPageParam = cachedPageParams[0] ?? initialPageParam;
1040          const totalPages = cachedPageParams.length;
1041          result = await fetchPage(existingData, firstPageParam, maxPages);
1042          if (forceQueryFn) {
1043            result = {
1044              data: result.data.pages[0]
1045            };
1046          }
1047          if (refetchCachedPages) {
1048            for (let i = 1; i < totalPages; i++) {
1049              const param = getNextPageParam(infiniteQueryOptions, result.data, arg.originalArgs);
1050              result = await fetchPage(result.data, param, maxPages);
1051            }
1052          }
1053        }
1054        finalQueryReturnValue = result;
1055      } else {
1056        finalQueryReturnValue = await executeRequest(arg.originalArgs);
1057      }
1058      if (metaSchema && !shouldSkip(skipSchemaValidation, "meta") && finalQueryReturnValue.meta) {
1059        finalQueryReturnValue.meta = await parseWithSchema(metaSchema, finalQueryReturnValue.meta, "metaSchema", finalQueryReturnValue.meta);
1060      }
1061      return fulfillWithValue(finalQueryReturnValue.data, addShouldAutoBatch({
1062        fulfilledTimeStamp: Date.now(),
1063        baseQueryMeta: finalQueryReturnValue.meta
1064      }));
1065    } catch (error) {
1066      let caughtError = error;
1067      if (caughtError instanceof HandledError) {
1068        let transformErrorResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformErrorResponse");
1069        const {
1070          rawErrorResponseSchema,
1071          errorResponseSchema
1072        } = endpointDefinition;
1073        let {
1074          value,
1075          meta
1076        } = caughtError;
1077        try {
1078          if (rawErrorResponseSchema && !shouldSkip(skipSchemaValidation, "rawErrorResponse")) {
1079            value = await parseWithSchema(rawErrorResponseSchema, value, "rawErrorResponseSchema", meta);
1080          }
1081          if (metaSchema && !shouldSkip(skipSchemaValidation, "meta")) {
1082            meta = await parseWithSchema(metaSchema, meta, "metaSchema", meta);
1083          }
1084          let transformedErrorResponse = await transformErrorResponse(value, meta, arg.originalArgs);
1085          if (errorResponseSchema && !shouldSkip(skipSchemaValidation, "errorResponse")) {
1086            transformedErrorResponse = await parseWithSchema(errorResponseSchema, transformedErrorResponse, "errorResponseSchema", meta);
1087          }
1088          return rejectWithValue(transformedErrorResponse, addShouldAutoBatch({
1089            baseQueryMeta: meta
1090          }));
1091        } catch (e) {
1092          caughtError = e;
1093        }
1094      }
1095      try {
1096        if (caughtError instanceof NamedSchemaError) {
1097          const info = {
1098            endpoint: arg.endpointName,
1099            arg: arg.originalArgs,
1100            type: arg.type,
1101            queryCacheKey: isQuery ? arg.queryCacheKey : void 0
1102          };
1103          (_b = endpointDefinition.onSchemaFailure) == null ? void 0 : _b.call(endpointDefinition, caughtError, info);
1104          onSchemaFailure == null ? void 0 : onSchemaFailure(caughtError, info);
1105          const {
1106            catchSchemaFailure = globalCatchSchemaFailure
1107          } = endpointDefinition;
1108          if (catchSchemaFailure) {
1109            return rejectWithValue(catchSchemaFailure(caughtError, info), addShouldAutoBatch({
1110              baseQueryMeta: caughtError._bqMeta
1111            }));
1112          }
1113        }
1114      } catch (e) {
1115        caughtError = e;
1116      }
1117      if (typeof process !== "undefined" && true) {
1118        console.error(`An unhandled error occurred processing a request for the endpoint "${arg.endpointName}".
1119In the case of an unhandled error, no tags will be "provided" or "invalidated".`, caughtError);
1120      } else {
1121        console.error(caughtError);
1122      }
1123      throw caughtError;
1124    }
1125  };
1126  function isForcedQuery(arg, state) {
1127    const requestState = selectors.selectQueryEntry(state, arg.queryCacheKey);
1128    const baseFetchOnMountOrArgChange = selectors.selectConfig(state).refetchOnMountOrArgChange;
1129    const fulfilledVal = requestState == null ? void 0 : requestState.fulfilledTimeStamp;
1130    const refetchVal = arg.forceRefetch ?? (arg.subscribe && baseFetchOnMountOrArgChange);
1131    if (refetchVal) {
1132      return refetchVal === true || (Number(/* @__PURE__ */ new Date()) - Number(fulfilledVal)) / 1e3 >= refetchVal;
1133    }
1134    return false;
1135  }
1136  const createQueryThunk = () => {
1137    const generatedQueryThunk = createAsyncThunk(`${reducerPath}/executeQuery`, executeEndpoint, {
1138      getPendingMeta({
1139        arg
1140      }) {
1141        const endpointDefinition = endpointDefinitions[arg.endpointName];
1142        return addShouldAutoBatch({
1143          startedTimeStamp: Date.now(),
1144          ...isInfiniteQueryDefinition(endpointDefinition) ? {
1145            direction: arg.direction
1146          } : {}
1147        });
1148      },
1149      condition(queryThunkArg, {
1150        getState
1151      }) {
1152        var _a;
1153        const state = getState();
1154        const requestState = selectors.selectQueryEntry(state, queryThunkArg.queryCacheKey);
1155        const fulfilledVal = requestState == null ? void 0 : requestState.fulfilledTimeStamp;
1156        const currentArg = queryThunkArg.originalArgs;
1157        const previousArg = requestState == null ? void 0 : requestState.originalArgs;
1158        const endpointDefinition = endpointDefinitions[queryThunkArg.endpointName];
1159        const direction = queryThunkArg.direction;
1160        if (isUpsertQuery(queryThunkArg)) {
1161          return true;
1162        }
1163        if ((requestState == null ? void 0 : requestState.status) === "pending") {
1164          return false;
1165        }
1166        if (isForcedQuery(queryThunkArg, state)) {
1167          return true;
1168        }
1169        if (isQueryDefinition(endpointDefinition) && ((_a = endpointDefinition == null ? void 0 : endpointDefinition.forceRefetch) == null ? void 0 : _a.call(endpointDefinition, {
1170          currentArg,
1171          previousArg,
1172          endpointState: requestState,
1173          state
1174        }))) {
1175          return true;
1176        }
1177        if (fulfilledVal && !direction) {
1178          return false;
1179        }
1180        return true;
1181      },
1182      dispatchConditionRejection: true
1183    });
1184    return generatedQueryThunk;
1185  };
1186  const queryThunk = createQueryThunk();
1187  const infiniteQueryThunk = createQueryThunk();
1188  const mutationThunk = createAsyncThunk(`${reducerPath}/executeMutation`, executeEndpoint, {
1189    getPendingMeta() {
1190      return addShouldAutoBatch({
1191        startedTimeStamp: Date.now()
1192      });
1193    }
1194  });
1195  const hasTheForce = (options) => "force" in options;
1196  const hasMaxAge = (options) => "ifOlderThan" in options;
1197  const prefetch = (endpointName, arg, options = {}) => (dispatch, getState) => {
1198    const force = hasTheForce(options) && options.force;
1199    const maxAge = hasMaxAge(options) && options.ifOlderThan;
1200    const queryAction = (force2 = true) => {
1201      const options2 = {
1202        forceRefetch: force2,
1203        subscribe: false
1204      };
1205      return api.endpoints[endpointName].initiate(arg, options2);
1206    };
1207    const latestStateValue = api.endpoints[endpointName].select(arg)(getState());
1208    if (force) {
1209      dispatch(queryAction());
1210    } else if (maxAge) {
1211      const lastFulfilledTs = latestStateValue == null ? void 0 : latestStateValue.fulfilledTimeStamp;
1212      if (!lastFulfilledTs) {
1213        dispatch(queryAction());
1214        return;
1215      }
1216      const shouldRetrigger = (Number(/* @__PURE__ */ new Date()) - Number(new Date(lastFulfilledTs))) / 1e3 >= maxAge;
1217      if (shouldRetrigger) {
1218        dispatch(queryAction());
1219      }
1220    } else {
1221      dispatch(queryAction(false));
1222    }
1223  };
1224  function matchesEndpoint(endpointName) {
1225    return (action) => {
1226      var _a, _b;
1227      return ((_b = (_a = action == null ? void 0 : action.meta) == null ? void 0 : _a.arg) == null ? void 0 : _b.endpointName) === endpointName;
1228    };
1229  }
1230  function buildMatchThunkActions(thunk, endpointName) {
1231    return {
1232      matchPending: isAllOf(isPending(thunk), matchesEndpoint(endpointName)),
1233      matchFulfilled: isAllOf(isFulfilled(thunk), matchesEndpoint(endpointName)),
1234      matchRejected: isAllOf(isRejected(thunk), matchesEndpoint(endpointName))
1235    };
1236  }
1237  return {
1238    queryThunk,
1239    mutationThunk,
1240    infiniteQueryThunk,
1241    prefetch,
1242    updateQueryData,
1243    upsertQueryData,
1244    patchQueryData,
1245    buildMatchThunkActions
1246  };
1247}
1248function getNextPageParam(options, {
1249  pages,
1250  pageParams
1251}, queryArg) {
1252  const lastIndex = pages.length - 1;
1253  return options.getNextPageParam(pages[lastIndex], pages, pageParams[lastIndex], pageParams, queryArg);
1254}
1255function getPreviousPageParam(options, {
1256  pages,
1257  pageParams
1258}, queryArg) {
1259  var _a;

1260  return (_a = options.getPreviousPageParam) == null ? void 0 : _a.call(options, pages[0], pages, pageParams[0], pageParams, queryArg);
1261}
1262function calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {
1263  return calculateProvidedBy(endpointDefinitions[action.meta.arg.endpointName][type], isFulfilled(action) ? action.payload : void 0, isRejectedWithValue(action) ? action.payload : void 0, action.meta.arg.originalArgs, "baseQueryMeta" in action.meta ? action.meta.baseQueryMeta : void 0, assertTagType);
1264}
1265function getCurrent(value) {
1266  return isDraft(value) ? current(value) : value;
1267}
1268function updateQuerySubstateIfExists(state, queryCacheKey, update) {
1269  const substate = state[queryCacheKey];
1270  if (substate) {
1271    update(substate);
1272  }
1273}
1274function getMutationCacheKey(id) {
1275  return ("arg" in id ? id.arg.fixedCacheKey : id.fixedCacheKey) ?? id.requestId;
1276}
1277function updateMutationSubstateIfExists(state, id, update) {
1278  const substate = state[getMutationCacheKey(id)];
1279  if (substate) {
1280    update(substate);
1281  }
1282}
1283var initialState = {};
1284function buildSlice({
1285  reducerPath,
1286  queryThunk,
1287  mutationThunk,
1288  serializeQueryArgs,
1289  context: {
1290    endpointDefinitions: definitions,
1291    apiUid,
1292    extractRehydrationInfo,
1293    hasRehydrationInfo
1294  },
1295  assertTagType,
1296  config
1297}) {
1298  const resetApiState = createAction(`${reducerPath}/resetApiState`);
1299  function writePendingCacheEntry(draft, arg, upserting, meta) {
1300    var _a;
1301    draft[_a = arg.queryCacheKey] ?? (draft[_a] = {
1302      status: STATUS_UNINITIALIZED,
1303      endpointName: arg.endpointName
1304    });
1305    updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {
1306      substate.status = STATUS_PENDING;
1307      substate.requestId = upserting && substate.requestId ? (
1308        // for `upsertQuery` **updates**, keep the current `requestId`
1309        substate.requestId
1310      ) : (
1311        // for normal queries or `upsertQuery` **inserts** always update the `requestId`
1312        meta.requestId
1313      );
1314      if (arg.originalArgs !== void 0) {
1315        substate.originalArgs = arg.originalArgs;
1316      }
1317      substate.startedTimeStamp = meta.startedTimeStamp;
1318      const endpointDefinition = definitions[meta.arg.endpointName];
1319      if (isInfiniteQueryDefinition(endpointDefinition) && "direction" in arg) {
1320        ;
1321        substate.direction = arg.direction;
1322      }
1323    });
1324  }
1325  function writeFulfilledCacheEntry(draft, meta, payload, upserting) {
1326    updateQuerySubstateIfExists(draft, meta.arg.queryCacheKey, (substate) => {
1327      if (substate.requestId !== meta.requestId && !upserting) return;
1328      const {
1329        merge
1330      } = definitions[meta.arg.endpointName];
1331      substate.status = STATUS_FULFILLED;
1332      if (merge) {
1333        if (substate.data !== void 0) {
1334          const {
1335            fulfilledTimeStamp,
1336            arg,
1337            baseQueryMeta,
1338            requestId
1339          } = meta;
1340          let newData = produce(substate.data, (draftSubstateData) => {
1341            return merge(draftSubstateData, payload, {
1342              arg: arg.originalArgs,
1343              baseQueryMeta,
1344              fulfilledTimeStamp,
1345              requestId
1346            });
1347          });
1348          substate.data = newData;
1349        } else {
1350          substate.data = payload;
1351        }
1352      } else {
1353        substate.data = definitions[meta.arg.endpointName].structuralSharing ?? true ? copyWithStructuralSharing(isDraft(substate.data) ? original(substate.data) : substate.data, payload) : payload;
1354      }
1355      delete substate.error;
1356      substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;
1357    });
1358  }
1359  const querySlice = createSlice({
1360    name: `${reducerPath}/queries`,
1361    initialState,
1362    reducers: {
1363      removeQueryResult: {
1364        reducer(draft, {
1365          payload: {
1366            queryCacheKey
1367          }
1368        }) {
1369          delete draft[queryCacheKey];
1370        },
1371        prepare: prepareAutoBatched()
1372      },
1373      cacheEntriesUpserted: {
1374        reducer(draft, action) {
1375          for (const entry of action.payload) {
1376            const {
1377              queryDescription: arg,
1378              value
1379            } = entry;
1380            writePendingCacheEntry(draft, arg, true, {
1381              arg,
1382              requestId: action.meta.requestId,
1383              startedTimeStamp: action.meta.timestamp
1384            });
1385            writeFulfilledCacheEntry(
1386              draft,
1387              {
1388                arg,
1389                requestId: action.meta.requestId,
1390                fulfilledTimeStamp: action.meta.timestamp,
1391                baseQueryMeta: {}
1392              },
1393              value,
1394              // We know we're upserting here
1395              true
1396            );
1397          }
1398        },
1399        prepare: (payload) => {
1400          const queryDescriptions = payload.map((entry) => {
1401            const {
1402              endpointName,
1403              arg,
1404              value
1405            } = entry;
1406            const endpointDefinition = definitions[endpointName];
1407            const queryDescription = {
1408              type: ENDPOINT_QUERY,
1409              endpointName,
1410              originalArgs: entry.arg,
1411              queryCacheKey: serializeQueryArgs({
1412                queryArgs: arg,
1413                endpointDefinition,
1414                endpointName
1415              })
1416            };
1417            return {
1418              queryDescription,
1419              value
1420            };
1421          });
1422          const result = {
1423            payload: queryDescriptions,
1424            meta: {
1425              [SHOULD_AUTOBATCH]: true,
1426              requestId: nanoid(),
1427              timestamp: Date.now()
1428            }
1429          };
1430          return result;
1431        }
1432      },
1433      queryResultPatched: {
1434        reducer(draft, {
1435          payload: {
1436            queryCacheKey,
1437            patches
1438          }
1439        }) {
1440          updateQuerySubstateIfExists(draft, queryCacheKey, (substate) => {
1441            substate.data = applyPatches(substate.data, patches.concat());
1442          });
1443        },
1444        prepare: prepareAutoBatched()
1445      }
1446    },
1447    extraReducers(builder) {
1448      builder.addCase(queryThunk.pending, (draft, {
1449        meta,
1450        meta: {
1451          arg
1452        }
1453      }) => {
1454        const upserting = isUpsertQuery(arg);
1455        writePendingCacheEntry(draft, arg, upserting, meta);
1456      }).addCase(queryThunk.fulfilled, (draft, {
1457        meta,
1458        payload
1459      }) => {
1460        const upserting = isUpsertQuery(meta.arg);
1461        writeFulfilledCacheEntry(draft, meta, payload, upserting);
1462      }).addCase(queryThunk.rejected, (draft, {
1463        meta: {
1464          condition,
1465          arg,
1466          requestId
1467        },
1468        error,
1469        payload
1470      }) => {
1471        updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {
1472          if (condition) {
1473          } else {
1474            if (substate.requestId !== requestId) return;
1475            substate.status = STATUS_REJECTED;
1476            substate.error = payload ?? error;
1477          }
1478        });
1479      }).addMatcher(hasRehydrationInfo, (draft, action) => {
1480        const {
1481          queries
1482        } = extractRehydrationInfo(action);
1483        for (const [key, entry] of Object.entries(queries)) {
1484          if (

1485            // do not rehydrate entries that were currently in flight.
1486            (entry == null ? void 0 : entry.status) === STATUS_FULFILLED || (entry == null ? void 0 : entry.status) === STATUS_REJECTED
1487          ) {
1488            draft[key] = entry;
1489          }
1490        }
1491      });
1492    }
1493  });
1494  const mutationSlice = createSlice({
1495    name: `${reducerPath}/mutations`,
1496    initialState,
1497    reducers: {
1498      removeMutationResult: {
1499        reducer(draft, {
1500          payload
1501        }) {
1502          const cacheKey = getMutationCacheKey(payload);
1503          if (cacheKey in draft) {
1504            delete draft[cacheKey];
1505          }
1506        },
1507        prepare: prepareAutoBatched()
1508      }
1509    },
1510    extraReducers(builder) {
1511      builder.addCase(mutationThunk.pending, (draft, {
1512        meta,
1513        meta: {
1514          requestId,
1515          arg,
1516          startedTimeStamp
1517        }
1518      }) => {
1519        if (!arg.track) return;
1520        draft[getMutationCacheKey(meta)] = {
1521          requestId,
1522          status: STATUS_PENDING,
1523          endpointName: arg.endpointName,
1524          startedTimeStamp
1525        };
1526      }).addCase(mutationThunk.fulfilled, (draft, {
1527        payload,
1528        meta
1529      }) => {
1530        if (!meta.arg.track) return;
1531        updateMutationSubstateIfExists(draft, meta, (substate) => {
1532          if (substate.requestId !== meta.requestId) return;
1533          substate.status = STATUS_FULFILLED;
1534          substate.data = payload;
1535          substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;
1536        });
1537      }).addCase(mutationThunk.rejected, (draft, {
1538        payload,
1539        error,
1540        meta
1541      }) => {
1542        if (!meta.arg.track) return;
1543        updateMutationSubstateIfExists(draft, meta, (substate) => {
1544          if (substate.requestId !== meta.requestId) return;
1545          substate.status = STATUS_REJECTED;
1546          substate.error = payload ?? error;
1547        });
1548      }).addMatcher(hasRehydrationInfo, (draft, action) => {
1549        const {
1550          mutations
1551        } = extractRehydrationInfo(action);
1552        for (const [key, entry] of Object.entries(mutations)) {
1553          if (
1554            // do not rehydrate entries that were currently in flight.
1555            ((entry == null ? void 0 : entry.status) === STATUS_FULFILLED || (entry == null ? void 0 : entry.status) === STATUS_REJECTED) && // only rehydrate endpoints that were persisted using a `fixedCacheKey`
1556            key !== (entry == null ? void 0 : entry.requestId)
1557          ) {
1558            draft[key] = entry;
1559          }
1560        }
1561      });
1562    }
1563  });
1564  const initialInvalidationState = {
1565    tags: {},
1566    keys: {}
1567  };
1568  const invalidationSlice = createSlice({
1569    name: `${reducerPath}/invalidation`,
1570    initialState: initialInvalidationState,
1571    reducers: {
1572      updateProvidedBy: {
1573        reducer(draft, action) {
1574          var _a, _b, _c;
1575          for (const {
1576            queryCacheKey,
1577            providedTags
1578          } of action.payload) {
1579            removeCacheKeyFromTags(draft, queryCacheKey);
1580            for (const {
1581              type,
1582              id
1583            } of providedTags) {
1584              const subscribedQueries = (_b = (_a = draft.tags)[type] ?? (_a[type] = {}))[_c = id || "__internal_without_id"] ?? (_b[_c] = []);
1585              const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
1586              if (!alreadySubscribed) {
1587                subscribedQueries.push(queryCacheKey);
1588              }
1589            }
1590            draft.keys[queryCacheKey] = providedTags;
1591          }
1592        },
1593        prepare: prepareAutoBatched()
1594      }
1595    },
1596    extraReducers(builder) {
1597      builder.addCase(querySlice.actions.removeQueryResult, (draft, {
1598        payload: {
1599          queryCacheKey
1600        }
1601      }) => {
1602        removeCacheKeyFromTags(draft, queryCacheKey);
1603      }).addMatcher(hasRehydrationInfo, (draft, action) => {
1604        var _a, _b, _c;
1605        const {
1606          provided
1607        } = extractRehydrationInfo(action);
1608        for (const [type, incomingTags] of Object.entries(provided.tags ?? {})) {
1609          for (const [id, cacheKeys] of Object.entries(incomingTags)) {
1610            const subscribedQueries = (_b = (_a = draft.tags)[type] ?? (_a[type] = {}))[_c = id || "__internal_without_id"] ?? (_b[_c] = []);

1611            for (const queryCacheKey of cacheKeys) {
1612              const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
1613              if (!alreadySubscribed) {
1614                subscribedQueries.push(queryCacheKey);
1615              }
1616              draft.keys[queryCacheKey] = provided.keys[queryCacheKey];
1617            }
1618          }
1619        }
1620      }).addMatcher(isAnyOf(isFulfilled(queryThunk), isRejectedWithValue(queryThunk)), (draft, action) => {
1621        writeProvidedTagsForQueries(draft, [action]);
1622      }).addMatcher(querySlice.actions.cacheEntriesUpserted.match, (draft, action) => {
1623        const mockActions = action.payload.map(({
1624          queryDescription,
1625          value
1626        }) => {
1627          return {
1628            type: "UNKNOWN",
1629            payload: value,
1630            meta: {
1631              requestStatus: "fulfilled",
1632              requestId: "UNKNOWN",
1633              arg: queryDescription
1634            }
1635          };
1636        });
1637        writeProvidedTagsForQueries(draft, mockActions);
1638      });
1639    }
1640  });
1641  function removeCacheKeyFromTags(draft, queryCacheKey) {
1642    var _a;
1643    const existingTags = getCurrent(draft.keys[queryCacheKey] ?? []);
1644    for (const tag of existingTags) {
1645      const tagType = tag.type;
1646      const tagId = tag.id ?? "__internal_without_id";
1647      const tagSubscriptions = (_a = draft.tags[tagType]) == null ? void 0 : _a[tagId];
1648      if (tagSubscriptions) {
1649        draft.tags[tagType][tagId] = getCurrent(tagSubscriptions).filter((qc) => qc !== queryCacheKey);
1650      }
1651    }
1652    delete draft.keys[queryCacheKey];
1653  }
1654  function writeProvidedTagsForQueries(draft, actions3) {
1655    const providedByEntries = actions3.map((action) => {
1656      const providedTags = calculateProvidedByThunk(action, "providesTags", definitions, assertTagType);
1657      const {
1658        queryCacheKey
1659      } = action.meta.arg;
1660      return {
1661        queryCacheKey,
1662        providedTags
1663      };
1664    });
1665    invalidationSlice.caseReducers.updateProvidedBy(draft, invalidationSlice.actions.updateProvidedBy(providedByEntries));
1666  }
1667  const subscriptionSlice = createSlice({
1668    name: `${reducerPath}/subscriptions`,
1669    initialState,
1670    reducers: {
1671      updateSubscriptionOptions(d, a) {
1672      },
1673      unsubscribeQueryResult(d, a) {
1674      },
1675      internal_getRTKQSubscriptions() {
1676      }
1677    }
1678  });
1679  const internalSubscriptionsSlice = createSlice({
1680    name: `${reducerPath}/internalSubscriptions`,
1681    initialState,
1682    reducers: {
1683      subscriptionsUpdated: {
1684        reducer(state, action) {
1685          return applyPatches(state, action.payload);
1686        },
1687        prepare: prepareAutoBatched()
1688      }
1689    }
1690  });
1691  const configSlice = createSlice({
1692    name: `${reducerPath}/config`,
1693    initialState: {
1694      online: isOnline(),
1695      focused: isDocumentVisible(),
1696      middlewareRegistered: false,
1697      ...config
1698    },
1699    reducers: {
1700      middlewareRegistered(state, {
1701        payload
1702      }) {
1703        state.middlewareRegistered = state.middlewareRegistered === "conflict" || apiUid !== payload ? "conflict" : true;
1704      }
1705    },
1706    extraReducers: (builder) => {
1707      builder.addCase(onOnline, (state) => {
1708        state.online = true;
1709      }).addCase(onOffline, (state) => {
1710        state.online = false;
1711      }).addCase(onFocus, (state) => {
1712        state.focused = true;
1713      }).addCase(onFocusLost, (state) => {
1714        state.focused = false;
1715      }).addMatcher(hasRehydrationInfo, (draft) => ({
1716        ...draft
1717      }));
1718    }
1719  });
1720  const combinedReducer = combineReducers({
1721    queries: querySlice.reducer,
1722    mutations: mutationSlice.reducer,
1723    provided: invalidationSlice.reducer,
1724    subscriptions: internalSubscriptionsSlice.reducer,
1725    config: configSlice.reducer
1726  });
1727  const reducer = (state, action) => combinedReducer(resetApiState.match(action) ? void 0 : state, action);
1728  const actions2 = {
1729    ...configSlice.actions,
1730    ...querySlice.actions,
1731    ...subscriptionSlice.actions,
1732    ...internalSubscriptionsSlice.actions,
1733    ...mutationSlice.actions,
1734    ...invalidationSlice.actions,
1735    resetApiState
1736  };
1737  return {
1738    reducer,
1739    actions: actions2
1740  };
1741}
1742var skipToken = Symbol.for("RTKQ/skipToken");
1743var initialSubState = {
1744  status: STATUS_UNINITIALIZED
1745};
1746var defaultQuerySubState = produce(initialSubState, () => {
1747});
1748var defaultMutationSubState = produce(initialSubState, () => {
1749});
1750function buildSelectors({
1751  serializeQueryArgs,
1752  reducerPath,
1753  createSelector: createSelector2
1754}) {
1755  const selectSkippedQuery = (state) => defaultQuerySubState;
1756  const selectSkippedMutation = (state) => defaultMutationSubState;
1757  return {
1758    buildQuerySelector,
1759    buildInfiniteQuerySelector,
1760    buildMutationSelector,
1761    selectInvalidatedBy,
1762    selectCachedArgsForQuery,
1763    selectApiState,
1764    selectQueries,
1765    selectMutations,
1766    selectQueryEntry,
1767    selectConfig
1768  };
1769  function withRequestFlags(substate) {
1770    return {
1771      ...substate,
1772      ...getRequestStatusFlags(substate.status)
1773    };
1774  }
1775  function selectApiState(rootState) {
1776    const state = rootState[reducerPath];
1777    if (true) {
1778      if (!state) {
1779        if (selectApiState.triggered) return state;
1780        selectApiState.triggered = true;
1781        console.error(`Error: No data found at \`state.${reducerPath}\`. Did you forget to add the reducer to the store?`);
1782      }
1783    }
1784    return state;
1785  }
1786  function selectQueries(rootState) {
1787    var _a;
1788    return (_a = selectApiState(rootState)) == null ? void 0 : _a.queries;
1789  }
1790  function selectQueryEntry(rootState, cacheKey) {
1791    var _a;
1792    return (_a = selectQueries(rootState)) == null ? void 0 : _a[c

1897    return getNextPageParam(options, data, queryArg) != null;
1898  }
1899  function getHasPreviousPage(options, data, queryArg) {
1900    if (!data || !options.getPreviousPageParam) return false;
1901    return getPreviousPageParam(options, data, queryArg) != null;
1902  }
1903}
1904var cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;
1905var defaultSerializeQueryArgs = ({
1906  endpointName,
1907  queryArgs
1908}) => {
1909  let serialized = "";
1910  const cached = cache == null ? void 0 : cache.get(queryArgs);
1911  if (typeof cached === "string") {
1912    serialized = cached;
1913  } else {
1914    const stringified = JSON.stringify(queryArgs, (key, value) => {
1915      value = typeof value === "bigint" ? {
1916        $bigint: value.toString()
1917      } : value;
1918      value = isPlainObject(value) ? Object.keys(value).sort().reduce((acc, key2) => {
1919        acc[key2] = value[key2];
1920        return acc;
1921      }, {}) : value;
1922      return value;
1923    });
1924    if (isPlainObject(queryArgs)) {
1925      cache == null ? void 0 : cache.set(queryArgs, stringified);
1926    }
1927    serialized = stringified;
1928  }
1929  return `${endpointName}(${serialized})`;
1930};
1931function buildCreateApi(...modules) {
1932  return function baseCreateApi(options) {
1933    const extractRehydrationInfo = weakMapMemoize((action) => {
1934      var _a;
1935      return (_a = options.extractRehydrationInfo) == null ? void 0 : _a.call(options, action, {
1936        reducerPath: options.reducerPath ?? "api"
1937      });
1938    });
1939    const optionsWithDefaults = {
1940      reducerPath: "api",
1941      keepUnusedDataFor: 60,
1942      refetchOnMountOrArgChange: false,
1943      refetchOnFocus: false,
1944      refetchOnReconnect: false,
1945      invalidationBehavior: "delayed",
1946      ...options,
1947      extractRehydrationInfo,
1948      serializeQueryArgs(queryArgsApi) {
1949        let finalSerializeQueryArgs = defaultSerializeQueryArgs;
1950        if ("serializeQueryArgs" in queryArgsApi.endpointDefinition) {
1951          const endpointSQA = queryArgsApi.endpointDefinition.serializeQueryArgs;
1952          finalSerializeQueryArgs = (queryArgsApi2) => {
1953            const initialResult = endpointSQA(queryArgsApi2);
1954            if (typeof initialResult === "string") {
1955              return initialResult;
1956            } else {
1957              return defaultSerializeQueryArgs({
1958                ...queryArgsApi2,
1959                queryArgs: initialResult
1960              });
1961            }
1962          };
1963        } else if (options.serializeQueryArgs) {
1964          finalSerializeQueryArgs = options.serializeQueryArgs;
1965        }
1966        return finalSerializeQueryArgs(queryArgsApi);
1967      },
1968      tagTypes: [...options.tagTypes || []]
1969    };
1970    const context = {
1971      endpointDefinitions: {},
1972      batch(fn) {
1973        fn();
1974      },
1975      apiUid: nanoid(),
1976      extractRehydrationInfo,
1977      hasRehydrationInfo: weakMapMemoize((action) => extractRehydrationInfo(action) != null)
1978    };
1979    const api = {
1980      injectEndpoints,
1981      enhanceEndpoints({
1982        addTagTypes,
1983        endpoints
1984      }) {
1985        if (addTagTypes) {
1986          for (const eT of addTagTypes) {
1987            if (!optionsWithDefaults.tagTypes.includes(eT)) {
1988              ;
1989              optionsWithDefaults.tagTypes.push(eT);
1990            }
1991          }
1992        }
1993        if (endpoints) {
1994          for (const [endpointName, partialDefinition] of Object.entries(endpoints)) {
1995            if (typeof partialDefinition === "function") {
1996              partialDefinition(getEndpointDefinition(context, endpointName));
1997            } else {
1998              Object.assign(getEndpointDefinition(context, endpointName) || {}, partialDefinition);
1999            }
2000          }
2001        }
2002        return api;
2003      }
2004    };
2005    const initializedModules = modules.map((m) => m.init(api, optionsWithDefaults, context));
2006    function injectEndpoints(inject) {
2007      const evaluatedEndpoints = inject.endpoints({
2008        query: (x) => ({
2009          ...x,
2010          type: ENDPOINT_QUERY
2011        }),
2012        mutation: (x) => ({
2013          ...x,
2014          type: ENDPOINT_MUTATION
2015        }),
2016        infiniteQuery: (x) => ({
2017          ...x,
2018          type: ENDPOINT_INFINITEQUERY
2019        })
2020      });
2021      for (const [endpointName, definition] of Object.entries(evaluatedEndpoints)) {
2022        if (inject.overrideExisting !== true && endpointName in context.endpointDefinitions) {
2023          if (inject.overrideExisting === "throw") {
2024            throw new Error(false ? formatProdErrorMessage(39) : `called \`injectEndpoints\` to override already-existing endpointName ${endpointName} without specifying \`overrideExisting: true\``);
2025          } else if (typeof process !== "undefined" && true) {
2026            console.error(`called \`injectEndpoints\` to override already-existing endpointName ${endpointName} without specifying \`overrideExisting: true\``);
2027          }
2028          continue;
2029        }
2030        if (typeof process !== "undefined" && true) {
2031          if (isInfiniteQueryDefinition(definition)) {
2032            const {
2033              infiniteQueryOptions
2034            } = definition;
2035            const {
2036              maxPages,
2037              getPreviousPageParam: getPreviousPageParam2
2038            } = infiniteQueryOptions;

2039            if (typeof maxPages === "number") {
2040              if (maxPages < 1) {
2041                throw new Error(false ? formatProdErrorMessage(40) : `maxPages for endpoint '${endpointName}' must be a number greater than 0`);
2042              }
2043              if (typeof getPreviousPageParam2 !== "function") {
2044                throw new Error(false ? formatProdErrorMessage(41) : `getPreviousPageParam for endpoint '${endpointName}' must be a function if maxPages is used`);
2045              }
2046            }
2047          }
2048        }
2049        context.endpointDefinitions[endpointName] = definition;
2050        for (const m of initializedModules) {
2051          m.injectEndpoint(endpointName, definition);
2052        }
2053      }
2054      return api;
2055    }
2056    return api.injectEndpoints({
2057      endpoints: options.endpoints
2058    });
2059  };
2060}
2061var _NEVER = Symbol();
2062function fakeBaseQuery() {
2063  return function() {
2064    throw new Error(false ? formatProdErrorMessage(33) : "When using `fakeBaseQuery`, all queries & mutations must use the `queryFn` definition syntax.");
2065  };
2066}
2067function assertCast(v) {
2068}
2069function safeAssign(target, ...args) {
2070  return Object.assign(target, ...args);
2071}
2072var buildBatchedActionsHandler = ({
2073  api,
2074  queryThunk,
2075  internalState,
2076  mwApi
2077}) => {
2078  const subscriptionsPrefix = `${api.reducerPath}/subscriptions`;
2079  let previousSubscriptions = null;
2080  let updateSyncTimer = null;
2081  const {
2082    updateSubscriptionOptions,
2083    unsubscribeQueryResult
2084  } = api.internalActions;
2085  const actuallyMutateSubscriptions = (currentSubscriptions, action) => {
2086    if (updateSubscriptionOptions.match(action)) {
2087      const {
2088        queryCacheKey,
2089        requestId,
2090        options
2091      } = action.payload;
2092      const sub = currentSubscriptions.get(queryCacheKey);
2093      if (sub == null ? void 0 : sub.has(requestId)) {
2094        sub.set(requestId, options);
2095      }
2096      return true;
2097    }
2098    if (unsubscribeQueryResult.match(action)) {
2099      const {
2100        queryCacheKey,
2101        requestId
2102      } = action.payload;
2103      const sub = currentSubscriptions.get(queryCacheKey);
2104      if (sub) {
2105        sub.delete(requestId);
2106      }
2107      return true;
2108    }
2109    if (api.internalActions.removeQueryResult.match(action)) {
2110      currentSubscriptions.delete(action.payload.queryCacheKey);
2111      return true;
2112    }
2113    if (queryThunk.pending.match(action)) {
2114      const {
2115        meta: {
2116          arg,
2117          requestId
2118        }
2119      } = action;
2120      const substate = getOrInsertComputed(currentSubscriptions, arg.queryCacheKey, createNewMap);
2121      if (arg.subscribe) {
2122        substate.set(requestId, arg.subscriptionOptions ?? substate.get(requestId) ?? {});
2123      }
2124      return true;
2125    }
2126    let mutated = false;
2127    if (queryThunk.rejected.match(action)) {
2128      const {
2129        meta: {
2130          condition,
2131          arg,
2132          requestId
2133        }
2134      } = action;
2135      if (condition && arg.subscribe) {
2136        const substate = getOrInsertComputed(currentSubscriptions, arg.queryCacheKey, createNewMap);
2137        substate.set(requestId, arg.subscriptionOptions ?? substate.get(requestId) ?? {});
2138        mutated = true;
2139      }
2140    }
2141    return mutated;
2142  };
2143  const getSubscriptions = () => internalState.currentSubscriptions;
2144  const getSubscriptionCount = (queryCacheKey) => {
2145    const subscriptions = getSubscriptions();
2146    const subscriptionsForQueryArg = subscriptions.get(queryCacheKey);
2147    return (subscriptionsForQueryArg == null ? void 0 : subscriptionsForQueryArg.size) ?? 0;
2148  };
2149  const isRequestSubscribed = (queryCacheKey, requestId) => {
2150    var _a;
2151    const subscriptions = getSubscriptions();
2152    return !!((_a = subscriptions == null ? void 0 : subscriptions.get(queryCacheKey)) == null ? void 0 : _a.get(requestId));
2153  };
2154  const subscriptionSelectors = {
2155    getSubscriptions,
2156    getSubscriptionCount,
2157    isRequestSubscribed
2158  };
2159  function serializeSubscriptions(currentSubscriptions) {
2160    return JSON.parse(JSON.stringify(Object.fromEntries([...currentSubscriptions].map(([k, v]) => [k, Object.fromEntries(v)]))));
2161  }
2162  return (action, mwApi2) => {
2163    if (!previousSubscriptions) {
2164      previousSubscriptions = serializeSubscriptions(internalState.currentSubscriptions);
2165    }
2166    if (api.util.resetApiState.match(action)) {
2167      previousSubscriptions = {};
2168      internalState.currentSubscriptions.clear();
2169      updateSyncTimer = null;
2170      return [true, false];
2171    }
2172    if (api.internalActions.internal_getRTKQSubscriptions.match(action)) {
2173      return [false, subscriptionSelectors];
2174    }
2175    const didMutate = actuallyMutateSubscriptions(internalState.currentSubscriptions, action);
2176    let actionShouldContinue = true;
2177    if (false) {
2178      return [false, internalState.currentPolls];
2179    }
2180    if (didMutate) {
2181      if (!updateSyncTimer) {
2182        updateSyncTimer = setTimeout(() => {
2183          const newSubscriptions = serializeSubscriptions(internalState.currentSubscriptions);
2184          const [, patches] = produceWithPatches(previousSubscriptions, () => newSubscriptions);
2185          mwApi2.next(api.internalActions.subscriptionsUpdated(patches));
2186          previousSubscriptions = newSubscriptions;
2187          updateSyncTimer = null;
2188        }, 500);
2189      }
2190      const isSubscriptionSliceAction = typeof action.type == "string" && !!action.type.startsWith(subscriptionsPrefix);
2191      const isAdditionalSubscriptionAction = queryThunk.rejected.match(action) && action.meta.condition && !!action.meta.arg.subscribe;
2192      actionShouldContinue = !isSubscriptionSliceAction && !isAdditionalSubscriptionAction;
2193    }
2194    return [actionShouldContinue, false];
2195  };
2196};
2197var THIRTY_TWO_BIT_MAX_TIMER_SECONDS = 2147483647 / 1e3 - 1;
2198var buildCacheCollectionHandler = ({
2199  reducerPath,
2200  api,
2201  queryThunk,

2202  context,
2203  internalState,
2204  selectors: {
2205    selectQueryEntry,
2206    selectConfig
2207  },
2208  getRunningQueryThunk,
2209  mwApi
2210}) => {
2211  const {
2212    removeQueryResult,
2213    unsubscribeQueryResult,
2214    cacheEntriesUpserted
2215  } = api.internalActions;
2216  const canTriggerUnsubscribe = isAnyOf(unsubscribeQueryResult.match, queryThunk.fulfilled, queryThunk.rejected, cacheEntriesUpserted.match);
2217  function anySubscriptionsRemainingForKey(queryCacheKey) {
2218    const subscriptions = internalState.currentSubscriptions.get(queryCacheKey);
2219    if (!subscriptions) {
2220      return false;
2221    }
2222    const hasSubscriptions = subscriptions.size > 0;
2223    return hasSubscriptions;
2224  }
2225  const currentRemovalTimeouts = {};
2226  function abortAllPromises(promiseMap) {
2227    var _a;
2228    for (const promise of promiseMap.values()) {
2229      (_a = promise == null ? void 0 : promise.abort) == null ? void 0 : _a.call(promise);
2230    }
2231  }
2232  const handler = (action, mwApi2) => {
2233    const state = mwApi2.getState();
2234    const config = selectConfig(state);
2235    if (canTriggerUnsubscribe(action)) {
2236      let queryCacheKeys;
2237      if (cacheEntriesUpserted.match(action)) {
2238        queryCacheKeys = action.payload.map((entry) => entry.queryDescription.queryCacheKey);
2239      } else {
2240        const {
2241          queryCacheKey
2242        } = unsubscribeQueryResult.match(action) ? action.payload : action.meta.arg;
2243        queryCacheKeys = [queryCacheKey];
2244      }
2245      handleUnsubscribeMany(queryCacheKeys, mwApi2, config);
2246    }
2247    if (api.util.resetApiState.match(action)) {
2248      for (const [key, timeout] of Object.entries(currentRemovalTimeouts)) {
2249        if (timeout) clearTimeout(timeout);
2250        delete currentRemovalTimeouts[key];
2251      }
2252      abortAllPromises(internalState.runningQueries);
2253      abortAllPromises(internalState.runningMutations);
2254    }
2255    if (context.hasRehydrationInfo(action)) {
2256      const {
2257        queries
2258      } = context.extractRehydrationInfo(action);
2259      handleUnsubscribeMany(Object.keys(queries), mwApi2, config);
2260    }
2261  };
2262  function handleUnsubscribeMany(cacheKeys, api2, config) {
2263    const state = api2.getState();
2264    for (const queryCacheKey of cacheKeys) {
2265      const entry = selectQueryEntry(state, queryCacheKey);
2266      if (entry == null ? void 0 : entry.endpointName) {
2267        handleUnsubscribe(queryCacheKey, entry.endpointName, api2, config);
2268      }
2269    }
2270  }
2271  function handleUnsubscribe(queryCacheKey, endpointName, api2, config) {
2272    const endpointDefinition = getEndpointDefinition(context, endpointName);
2273    const keepUnusedDataFor = (endpointDefinition == null ? void 0 : endpointDefinition.keepUnusedDataFor) ?? config.keepUnusedDataFor;
2274    if (keepUnusedDataFor === Infinity) {
2275      return;
2276    }
2277    const finalKeepUnusedDataFor = Math.max(0, Math.min(keepUnusedDataFor, THIRTY_TWO_BIT_MAX_TIMER_SECONDS));
2278    if (!anySubscriptionsRemainingForKey(queryCacheKey)) {
2279      const currentTimeout = currentRemovalTimeouts[queryCacheKey];
2280      if (currentTimeout) {
2281        clearTimeout(currentTimeout);
2282      }
2283      currentRemovalTimeouts[queryCacheKey] = setTimeout(() => {
2284        if (!anySubscriptionsRemainingForKey(queryCacheKey)) {
2285          const entry = selectQueryEntry(api2.getState(), queryCacheKey);
2286          if (entry == null ? void 0 : entry.endpointName) {
2287            const runningQuery = api2.dispatch(getRunningQueryThunk(entry.endpointName, entry.originalArgs));
2288            runningQuery == null ? void 0 : runningQuery.abort();
2289          }
2290          api2.dispatch(removeQueryResult({
2291            queryCacheKey
2292          }));
2293        }
2294        delete currentRemovalTimeouts[queryCacheKey];
2295      }, finalKeepUnusedDataFor * 1e3);
2296    }
2297  }
2298  return handler;
2299};
2300var neverResolvedError = new Error("Promise never resolved before cacheEntryRemoved.");
2301var buildCacheLifecycleHandler = ({
2302  api,
2303  reducerPath,
2304  context,
2305  queryThunk,
2306  mutationThunk,
2307  internalState,
2308  selectors: {
2309    selectQueryEntry,
2310    selectApiState
2311  }
2312}) => {
2313  const isQueryThunk = isAsyncThunkAction(queryThunk);
2314  const isMutationThunk = isAsyncThunkAction(mutationThunk);
2315  const isFulfilledThunk = isFulfilled(queryThunk, mutationThunk);
2316  const lifecycleMap = {};
2317  const {
2318    removeQueryResult,
2319    removeMutationResult,
2320    cacheEntriesUpserted
2321  } = api.internalActions;
2322  function resolveLifecycleEntry(cacheKey, data, meta) {
2323    const lifecycle = lifecycleMap[cacheKey];
2324    if (lifecycle == null ? void 0 : lifecycle.valueResolved) {
2325      lifecycle.valueResolved({
2326        data,
2327        meta
2328      });
2329      delete lifecycle.valueResolved;
2330    }
2331  }
2332  function removeLifecycleEntry(cacheKey) {
2333    const lifecycle = lifecycleMap[cacheKey];
2334    if (lifecycle) {
2335      delete lifecycleMap[cacheKey];
2336      lifecycle.cacheEntryRemoved();
2337    }
2338  }
2339  function getActionMetaFields(action) {
2340    const {
2341      arg,
2342      requestId
2343    } = action.meta;
2344    const {
2345      endpointName,
2346      originalArgs
2347    } = arg;
2348    return [endpointName, originalArgs, requestId];
2349  }
2350  const handler = (action, mwApi, stateBefore) => {
2351    const cacheKey = getCacheKey(action);
2352    function checkForNewCacheKey(endpointName, cacheKey2, requestId, originalArgs) {
2353      const oldEntry = selectQueryEntry(stateBefore, cacheKey2);
2354      const newEntry = selectQueryEntry(mwApi.getState(), cacheKey2);
2355      if (!oldEntry && newEntry) {
2356        handleNewKey(endpointName, originalArgs, cacheKey2, mwApi, requestId);
2357      }
2358    }
2359    if (queryThunk.pending.match(action)) {
2360      const [endpointName, originalArgs, requestId] = getActionMetaFields(action);
2361      checkForNewCacheKey(endpointName, cacheKey, requestId, originalArgs);
2362    } else if (cacheEntriesUpserted.match(action)) {
2363      for (const {
2364        queryDescription,
2365        value
2366      } of action.payload) {
2367        const {
2368          endpointName,
2369          originalArgs,
2370          queryCacheKey
2371        } = queryDescription;
2372        checkForNewCacheKey(endpointName, queryCacheKey, action.meta.requestId, originalArgs);
2373        resolveLifecycleEntry(queryCacheKey, value, {});
2374      }
2375    } else if (mutationThunk.pending.match(action)) {
2376      const state = mwApi.getState()[reducerPath].mutations[cacheKey];
2377      if (state) {
2378        const [endpointName, originalArgs, requestId] = getActionMetaFields(action);
2379        handleNewKey(endpointName, originalArgs, cacheKey, mwApi, requestId);
2380      }
2381    } else if (isFulfilledThunk(action)) {
2382      resolveLifecycleEntry(cacheKey, action.payload, action.meta.baseQueryMeta);
2383    } else if (removeQueryResult.match(action) || removeMutationResult.match(action)) {
2384      removeLifecycleEntry(cacheKey);
2385    } else if (api.util.resetApiState.match(action)) {
2386      for (const cacheKey2 of Object.keys(lifecycleMap)) {
2387        removeLifecycleEntry(cacheKey2);
2388      }
2389    }
2390  };
2391  function getCacheKey(action) {
2392    if (isQueryThunk(action)) return action.meta.arg.queryCacheKey;
2393    if (isMutationThunk(action)) {
2394      return action.meta.arg.fixedCacheKey ?? action.meta.requestId;
2395    }
2396    if (removeQueryResult.match(action)) return action.payload.queryCacheKey;
2397    if (removeMutationResult.match(action)) return getMutationCacheKey(action.payload);
2398    return "";
2399  }
2400  function handleNewKey(endpointName, originalArgs, queryCacheKey, mwApi, requestId) {
2401    const endpointDefinition = getEndpointDefinition(context, endpointName);
2402    const onCacheEntryAdded = endpointDefinition == null ? void 0 : endpointDefinition.onCacheEntryAdded;
2403    if (!onCacheEntryAdded) return;
2404    const lifecycle = {};
2405    const cacheEntryRemoved = new Promise((resolve) => {
2406      lifecycle.cacheEntryRemoved = resolve;
2407    });
2408    const cacheDataLoaded = Promise.race([new Promise((resolve) => {
2409      lifecycle.valueResolved = resolve;
2410    }), cacheEntryRemoved.then(() => {
2411      throw neverResolvedError;
2412    })]);
2413    cacheDataLoaded.catch(() => {
2414    });
2415    lifecycleMap[queryCacheKey] = lifecycle;
2416    const selector = api.endpoints[endpointName].select(isAnyQueryDefinition(endpointDefinition) ? originalArgs : queryCacheKey);
2417    const extra = mwApi.dispatch((_, __, extra2) => extra2);
2418    const lifecycleApi = {
2419      ...mwApi,
2420      getCacheEntry: () => selector(mwApi.getState()),
2421      requestId,
2422      extra,
2423      updateCachedData: isAnyQueryDefinition(endpointDefinition) ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
2424      cacheDataLoaded,
2425      cacheEntryRemoved
2426    };
2427    const runningHandler = onCacheEntryAdded(originalArgs, lifecycleApi);
2428    Promise.resolve(runningHandler).catch((e) => {
2429      if (e === neverResolvedError) return;
2430      throw e;
2431    });
2432  }
2433  return handler;
2434};
2435var buildDevCheckHandler = ({
2436  api,
2437  context: {
2438    apiUid
2439  },
2440  reducerPath
2441}) => {
2442  return (action, mwApi) => {
2443    var _a, _b;
2444    if (api.util.resetApiState.match(action)) {
2445      mwApi.dispatch(api.internalActions.middlewareRegistered(apiUid));
2446    }
2447    if (typeof process !== "undefined" && true) {
2448      if (api.internalActions.middlewareRegistered.match(action) && action.payload === apiUid && ((_b = (_a = mwApi.getState()[reducerPath]) == null ? void 0 : _a.config) == null ? void 0 : _b.middlewareRegistered) === "conflict") {
2449        console.warn(`There is a mismatch between slice and middleware for the reducerPath "${reducerPath}".
2450You can only have one api per reducer path, this will lead to crashes in various situations!${reducerPath === "api" ? `
2451If you have multiple apis, you *have* to specify the reducerPath option when using createApi!` : ""}`);
2452      }
2453    }
2454  };
2455};
2456var buildInvalidationByTagsHandler = ({
2457  reducerPath,
2458  context,
2459  context: {
2460    endpointDefinitions
2461  },
2462  mutationThunk,
2463  queryThunk,
2464  api,
2465  assertTagType,
2466  refetchQuery,
2467  internalState
2468}) => {
2469  const {
2470    removeQueryResult
2471  } = api.internalActions;
2472  const isThunkActionWithTags = isAnyOf(isFulfilled(mutationThunk), isRejectedWithValue(mutationThunk));
2473  const isQueryEnd = isAnyOf(isFulfilled(queryThunk, mutationThunk), isRejected(queryThunk, mutationThunk));
2474  let pendingTagInvalidations = [];
2475  let pendingRequestCount = 0;
2476  const handler = (action, mwApi) => {
2477    if (queryThunk.pending.match(action) || mutationThunk.pending.match(action)) {
2478      pendingRequestCount++;
2479    }
2480    if (isQueryEnd(action)) {
2481      pendingRequestCount = Math.max(0, pendingRequestCount - 1);
2482    }
2483    if (isThunkActionWithTags(action)) {
2484      invalidateTags(calculateProvidedByThunk(action, "invalidatesTags", endpointDefinitions, assertTagType), mwApi);
2485    } else if (isQueryEnd(action)) {
2486      invalidateTags([], mwApi);
2487    } else if (api.util.invalidateTags.match(action)) {
2488      invalidateTags(calculateProvidedBy(action.payload, void 0, void 0, void 0, void 0, assertTagType), mwApi);
2489    }
2490  };
2491  function hasPendingRequests() {
2492    return pendingRequestCount > 0;
2493  }
2494  function invalidateTags(newTags, mwApi) {
2495    const rootState = mwApi.getState();
2496    const state = rootState[reducerPath];
2497    pendingTagInvalidations.push(...newTags);
2498    if (state.config.invalidationBehavior === "delayed" && hasPendingRequests()) {
2499      return;
2500    }
2501    const tags = pendingTagInvalidations;
2502    pendingTagInvalidations = [];
2503    if (tags.length === 0) return;
2504    const toInvalidate = api.util.selectInvalidatedBy(rootState, tags);
2505    context.batch(() => {
2506      const valuesArray = Array.from(toInvalidate.values());
2507      for (const {
2508        queryCacheKey
2509      } of valuesArray) {
2510        const querySubState = state.queries[queryCacheKey];
2511        const subscriptionSubState = getOrInsertComputed(internalState.currentSubscriptions, queryCacheKey, createNewMap);
2512        if (querySubState) {
2513          if (subscriptionSubState.size === 0) {
2514            mwApi.dispatch(removeQueryResult({
2515              queryCacheKey
2516            }));
2517          } else if (querySubState.status !== STATUS_UNINITIALIZED) {
2518            mwApi.dispatch(refetchQuery(querySubState));
2519          }
2520        }
2521      }
2522    });
2523  }
2524  return handler;
2525};
2526var buildPollingHandler = ({
2527  reducerPath,
2528  queryThunk,
2529  api,
2530  refetchQuery,
2531  internalState
2532}) => {
2533  const {
2534    currentPolls,
2535    currentSubscriptions
2536  } = internalState;
2537  const pendingPollingUpdates = /* @__PURE__ */ new Set();
2538  let pollingUpdateTimer = null;
2539  const handler = (action, mwApi) => {
2540    if (api.internalActions.updateSubscriptionOptions.match(action) || api.internalActions.unsubscribeQueryResult.match(action)) {
2541      schedulePollingUpdate(action.payload.queryCacheKey, mwApi);
2542    }
2543    if (queryThunk.pending.match(action) || queryThunk.rejected.match(action) && action.meta.condition) {
2544      schedulePollingUpdate(action.meta.arg.queryCacheKey, mwApi);
2545    }
2546    if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action) && !action.meta.condition) {
2547      startNextPoll(action.meta.arg, mwApi);
2548    }
2549    if (api.util.resetApiState.match(action)) {
2550      clearPolls();
2551      if (pollingUpdateTimer) {
2552        clearTimeout(pollingUpdateTimer);
2553        pollingUpdateTimer = null;
2554      }
2555      pendingPollingUpdates.clear();
2556    }
2557  };
2558  function schedulePollingUpdate(queryCacheKey, api2) {
2559    pendingPollingUpdates.add(queryCacheKey);
2560    if (!pollingUpdateTimer) {
2561      pollingUpdateTimer = setTimeout(() => {
2562        for (const key of pendingPollingUpdates) {
2563          updatePollingInterval({
2564            queryCacheKey: key
2565          }, api2);
2566        }
2567        pendingPollingUpdates.clear();
2568        pollingUpdateTimer = null;
2569      }, 0);
2570    }
2571  }
2572  function startNextPoll({
2573    queryCacheKey
2574  }, api2) {
2575    const state = api2.getState()[reducerPath];
2576    const querySubState = state.queries[queryCacheKey];
2577    const subscriptions = currentSubscriptions.get(queryCacheKey);
2578    if (!querySubState || querySubState.status === STATUS_UNINITIALIZED) return;
2579    const {
2580      lowestPollingInterval,
2581      skipPollingIfUnfocused
2582    } = findLowestPollingInterval(subscriptions);
2583    if (!Number.isFinite(lowestPollingInterval)) return;
2584    const currentPoll = currentPolls.get(queryCacheKey);
2585    if (currentPoll == null ? void 0 : currentPoll.timeout) {
2586      clearTimeout(currentPoll.timeout);
2587      currentPoll.timeout = void 0;
2588    }
2589    const nextPollTimestamp = Date.now() + lowestPollingInterval;
2590    currentPolls.set(queryCacheKey, {
2591      nextPollTimestamp,
2592      pollingInterval: lowestPollingInterval,
2593      timeout: setTimeout(() => {
2594        if (state.config.focused || !skipPollingIfUnfocused) {
2595          api2.dispatch(refetchQuery(querySubState));
2596        }
2597        startNextPoll({
2598          queryCacheKey
2599        }, api2);
2600      }, lowestPollingInterval)
2601    });
2602  }
2603  function updatePollingInterval({
2604    queryCacheKey
2605  }, api2) {
2606    const state = api2.getState()[reducerPath];
2607    const querySubState = state.queries[queryCacheKey];
2608    const subscriptions = currentSubscriptions.get(queryCacheKey);
2609    if (!querySubState || querySubState.status === STATUS_UNINITIALIZED) {
2610      return;
2611    }
2612    const {
2613      lowestPollingInterval
2614    } = findLowestPollingInterval(subscriptions);
2615    if (false) {
2616      const updateCounters = currentPolls.pollUpdateCounters ?? (currentPolls.pollUpdateCounters = {});
2617      updateCounters[queryCacheKey] ?? (updateCounters[queryCacheKey] = 0);
2618      updateCounters[queryCacheKey]++;
2619    }
2620    if (!Number.isFinite(lowestPollingInterval)) {
2621      cleanupPollForKey(queryCacheKey);
2622      return;
2623    }
2624    const currentPoll = currentPolls.get(queryCacheKey);
2625    const nextPollTimestamp = Date.now() + lowestPollingInterval;
2626    if (!currentPoll || nextPollTimestamp < currentPoll.nextPollTimestamp) {
2627      startNextPoll({
2628        queryCacheKey
2629      }, api2);
2630    }
2631  }
2632  function cleanupPollForKey(key) {
2633    const existingPoll = currentPolls.get(key);
2634    if (existingPoll == null ? void 0 : existingPoll.timeout) {
2635      clearTimeout(existingPoll.timeout);
2636    }
2637    currentPolls.delete(key);
2638  }
2639  function clearPolls() {
2640    for (const key of currentPolls.keys()) {
2641      cleanupPollForKey(key);
2642    }
2643  }
2644  function findLowestPollingInterval(subscribers = /* @__PURE__ */ new Map()) {
2645    let skipPollingIfUnfocused = false;
2646    let lowestPollingInterval = Number.POSITIVE_INFINITY;
2647    for (const entry of subscribers.values()) {
2648      if (!!entry.pollingInterval) {
2649        lowestPollingInterval = Math.min(entry.pollingInterval, lowestPollingInterval);
2650        skipPollingIfUnfocused = entry.skipPollingIfUnfocused || skipPollingIfUnfocused;
2651      }
2652    }
2653    return {
2654      lowestPollingInterval,
2655      skipPollingIfUnfocused
2656    };
2657  }
2658  return handler;
2659};
2660var buildQueryLifecycleHandler = ({
2661  api,
2662  context,
2663  queryThunk,
2664  mutationThunk
2665}) => {
2666  const isPendingThunk = isPending(queryThunk, mutationThunk);
2667  const isRejectedThunk = isRejected(queryThunk, mutationThunk);
2668  const isFullfilledThunk = isFulfilled(queryThunk, mutationThunk);
2669  const lifecycleMap = {};
2670  const handler = (action, mwApi) => {
2671    var _a, _b;
2672    if (isPendingThunk(action)) {
2673      const {
2674        requestId,
2675        arg: {
2676          endpointName,
2677          originalArgs
2678        }
2679      } = action.meta;
2680      const endpointDefinition = getEndpointDefinition(context, endpointName);
2681      const onQueryStarted = endpointDefinition == null ? void 0 : endpointDefinition.onQueryStarted;
2682      if (onQueryStarted) {
2683        const lifecycle = {};
2684        const queryFulfilled = new Promise((resolve, reject) => {
2685          lifecycle.resolve = resolve;
2686          lifecycle.reject = reject;
2687        });
2688        queryFulfilled.catch(() => {
2689        });
2690        lifecycleMap[requestId] = lifecycle;
2691        const selector = api.endpoints[endpointName].select(isAnyQueryDefinition(endpointDefinition) ? originalArgs : requestId);
2692        const extra = mwApi.dispatch((_, __, extra2) => extra2);
2693        const lifecycleApi = {
2694          ...mwApi,
2695          getCacheEntry: () => selector(mwApi.getState()),
2696          requestId,
2697          extra,
2698          updateCachedData: isAnyQueryDefinition(endpointDefinition) ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
2699          queryFulfilled
2700        };
2701        onQueryStarted(originalArgs, lifecycleApi);
2702      }
2703    } else if (isFullfilledThunk(action)) {
2704      const {
2705        requestId,
2706        baseQueryMeta
2707      } = action.meta;
2708      (_a = lifecycleMap[requestId]) == null ? void 0 : _a.resolve({
2709        data: action.payload,
2710        meta: baseQueryMeta
2711      });
2712      delete lifecycleMap[requestId];
2713    } else if (isRejectedThunk(action)) {
2714      const {
2715        requestId,
2716        rejectedWithValue,
2717        baseQueryMeta
2718      } = action.meta;
2719      (_b = lifecycleMap[requestId]) == null ? void 0 : _b.reject({
2720        error: action.payload ?? action.error,
2721        isUnhandledError: !rejectedWithValue,
2722        meta: baseQueryMeta
2723      });
2724      delete lifecycleMap[requestId];
2725    }
2726  };
2727  return handler;
2728};
2729var buildWindowEventHandler = ({
2730  reducerPath,
2731  context,
2732  api,
2733  refetchQuery,
2734  internalState
2735}) => {
2736  const {
2737    removeQueryResult
2738  } = api.internalActions;
2739  const handler = (action, mwApi) => {
2740    if (onFocus.match(action)) {
2741      refetchValidQueries(mwApi, "refetchOnFocus");
2742    }
2743    if (onOnline.match(action)) {
2744      refetchValidQueries(mwApi, "refetchOnReconnect");
2745    }
2746  };
2747  function refetchValidQueries(api2, type) {
2748    const state = api2.getState()[reducerPath];
2749    const queries = state.queries;
2750    const subscriptions = internalState.currentSubscriptions;
2751    context.batch(() => {
2752      for (const queryCacheKey of subscriptions.keys()) {
2753        const querySubState = queries[queryCacheKey];
2754        const subscriptionSubState = subscriptions.get(queryCacheKey);
2755        if (!subscriptionSubState || !querySubState) continue;
2756        const values = [...subscriptionSubState.values()];
2757        const shouldRefetch = values.some((sub) => sub[type] === true) || values.every((sub) => sub[type] === void 0) && state.config[type];
2758        if (shouldRefetch) {
2759          if (subscriptionSubState.size === 0) {
2760            api2.dispatch(removeQueryResult({
2761              queryCacheKey
2762            }));
2763          } else if (querySubState.status !== STATUS_UNINITIALIZED) {
2764            api2.dispatch(refetchQuery(querySubState));
2765          }
2766        }
2767      }
2768    });
2769  }
2770  return handler;
2771};
2772function buildMiddleware(input) {
2773  const {
2774    reducerPath,
2775    queryThunk,
2776    api,
2777    context,
2778    getInternalState
2779  } = input;
2780  const {
2781    apiUid
2782  } = context;
2783  const actions2 = {
2784    invalidateTags: createAction(`${reducerPath}/invalidateTags`)
2785  };
2786  const isThisApiSliceAction = (action) => action.type.startsWith(`${reducerPath}/`);
2787  const handlerBuilders = [buildDevCheckHandler, buildCacheCollectionHandler, buildInvalidationByTagsHandler, buildPollingHandler, buildCacheLifecycleHandler, buildQueryLifecycleHandler];
2788  const middleware = (mwApi) => {
2789    let initialized2 = false;