@open-kingdom/shared-frontend-data-access-api-client 0.0.2-2

package/dist/index.js

@@ -0,0 +1,4047 @@
+import { nanoid as zn, formatProdErrorMessage as ye, isPlainObject as Ue, createAction as De, createSelector as Rr, createNextState as Kt, createAsyncThunk as cn, createSlice as Se, prepareAutoBatched as ke, isAnyOf as $e, isFulfilled as _e, isRejectedWithValue as Ht, combineReducers as Or, SHOULD_AUTOBATCH as Un, isAllOf as Pt, isRejected as Wt, isPending as $n, isAction as Ir, isAsyncThunkAction as an, createListenerMiddleware as Ar } from "@reduxjs/toolkit";
+import * as he from "react";
+import Ln, { useCallback as ge, useDebugValue as Rt, useMemo as G, useState as un, useEffect as de, useRef as fe, useLayoutEffect as Cr } from "react";
+var Bt = Symbol.for("immer-nothing"), xe = Symbol.for("immer-draftable"), B = Symbol.for("immer-state"), jn = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(e) {
+    return `The plugin for '${e}' has not been loaded into Immer. To enable the plugin, import and call \`enable${e}()\` when initializing your application.`;
+  },
+  function(e) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${e}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(e) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + e;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(e) {
+    return `'current' expects a draft, got: ${e}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(e) {
+    return `'original' expects a draft, got: ${e}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function W(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const n = jn[e], r = pe(n) ? n.apply(null, t) : n;
+    throw new Error(`[Immer] ${r}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var J = Object, Ee = J.getPrototypeOf, Le = "constructor", Ye = "prototype", Mt = "configurable", ft = "enumerable", ut = "writable", je = "value", Z = (e) => !!e && !!e[B];
+function re(e) {
+  return e ? Kn(e) || Je(e) || !!e[xe] || !!e[Le]?.[xe] || Xe(e) || Ze(e) : !1;
+}
+var Tr = J[Ye][Le].toString(), ln = /* @__PURE__ */ new WeakMap();
+function Kn(e) {
+  if (!e || !Ae(e))
+    return !1;
+  const t = Ee(e);
+  if (t === null || t === J[Ye])
+    return !0;
+  const n = J.hasOwnProperty.call(t, Le) && t[Le];
+  if (n === Object)
+    return !0;
+  if (!pe(n))
+    return !1;
+  let r = ln.get(n);
+  return r === void 0 && (r = Function.toString.call(n), ln.set(n, r)), r === Tr;
+}
+function Dr(e) {
+  return Z(e) || W(15, e), e[B].base_;
+}
+function Ne(e, t, n = !0) {
+  we(e) === 0 ? (n ? Reflect.ownKeys(e) : J.keys(e)).forEach((i) => {
+    t(i, e[i], e);
+  }) : e.forEach((r, i) => t(i, r, e));
+}
+function we(e) {
+  const t = e[B];
+  return t ? t.type_ : Je(e) ? 1 : Xe(e) ? 2 : Ze(e) ? 3 : 0;
+}
+var Ve = (e, t, n = we(e)) => n === 2 ? e.has(t) : J[Ye].hasOwnProperty.call(e, t), se = (e, t, n = we(e)) => (
+  // @ts-ignore
+  n === 2 ? e.get(t) : e[t]
+), dt = (e, t, n, r = we(e)) => {
+  r === 2 ? e.set(t, n) : r === 3 ? e.add(n) : e[t] = n;
+};
+function Nr(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+var Je = Array.isArray, Xe = (e) => e instanceof Map, Ze = (e) => e instanceof Set, Ae = (e) => typeof e == "object", pe = (e) => typeof e == "function", Ot = (e) => typeof e == "boolean", kr = (e) => Ae(e) ? e?.[B] : null, ce = (e) => e.copy_ || e.base_, Gt = (e) => e.modified_ ? e.copy_ : e.base_;
+function Qt(e, t) {
+  if (Xe(e))
+    return new Map(e);
+  if (Ze(e))
+    return new Set(e);
+  if (Je(e))
+    return Array[Ye].slice.call(e);
+  const n = Kn(e);
+  if (t === !0 || t === "class_only" && !n) {
+    const r = J.getOwnPropertyDescriptors(e);
+    delete r[B];
+    let i = Reflect.ownKeys(r);
+    for (let a = 0; a < i.length; a++) {
+      const v = i[a], _ = r[v];
+      _[ut] === !1 && (_[ut] = !0, _[Mt] = !0), (_.get || _.set) && (r[v] = {
+        [Mt]: !0,
+        [ut]: !0,
+        // could live with !!desc.set as well here...
+        [ft]: _[ft],
+        [je]: e[v]
+      });
+    }
+    return J.create(Ee(e), r);
+  } else {
+    const r = Ee(e);
+    if (r !== null && n)
+      return { ...e };
+    const i = J.create(r);
+    return J.assign(i, e);
+  }
+}
+function Yt(e, t = !1) {
+  return St(e) || Z(e) || (we(e) > 1 && J.defineProperties(e, {
+    set: rt,
+    add: rt,
+    clear: rt,
+    delete: rt
+  }), J.freeze(e), t && Ne(
+    e,
+    (n, r) => {
+      Yt(r, !0);
+    },
+    !1
+  )), e;
+}
+function Mr() {
+  W(2);
+}
+var rt = {
+  [je]: Mr
+};
+function St(e) {
+  return e === null || !Ae(e) ? !0 : J.isFrozen(e);
+}
+var pt = "MapSet", ht = "Patches", yt = {};
+function Ce(e) {
+  const t = yt[e];
+  return t || W(0, e), t;
+}
+var Qr = (e) => !!yt[e];
+function qr(e, t) {
+  yt[e] || (yt[e] = t);
+}
+var Ke, Hn = () => Ke, Fr = (e, t) => ({
+  drafts_: [],
+  parent_: e,
+  immer_: t,
+  // Whenever the modified draft contains a draft from another scope, we
+  // need to prevent auto-freezing so the unowned draft can be finalized.
+  canAutoFreeze_: !0,
+  unfinalizedDrafts_: 0,
+  handledSet_: /* @__PURE__ */ new Set(),
+  processedForPatches_: /* @__PURE__ */ new Set(),
+  mapSetPlugin_: Qr(pt) ? Ce(pt) : void 0
+});
+function fn(e, t) {
+  t && (e.patchPlugin_ = Ce(ht), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function qt(e) {
+  Ft(e), e.drafts_.forEach(xr), e.drafts_ = null;
+}
+function Ft(e) {
+  e === Ke && (Ke = e.parent_);
+}
+var dn = (e) => Ke = Fr(Ke, e);
+function xr(e) {
+  const t = e[B];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function pn(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const n = t.drafts_[0];
+  if (e !== void 0 && e !== n) {
+    n[B].modified_ && (qt(t), W(4)), re(e) && (e = hn(t, e));
+    const { patchPlugin_: i } = t;
+    i && i.generateReplacementPatches_(
+      n[B].base_,
+      e,
+      t
+    );
+  } else
+    e = hn(t, n);
+  return Vr(t, e, !0), qt(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== Bt ? e : void 0;
+}
+function hn(e, t) {
+  if (St(t))
+    return t;
+  const n = t[B];
+  if (!n)
+    return Jt(t, e.handledSet_, e);
+  if (!bt(n, e))
+    return t;
+  if (!n.modified_)
+    return n.base_;
+  if (!n.finalized_) {
+    const { callbacks_: r } = n;
+    if (r)
+      for (; r.length > 0; )
+        r.pop()(e);
+    Gn(n, e);
+  }
+  return n.copy_;
+}
+function Vr(e, t, n = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && Yt(t, n);
+}
+function Wn(e) {
+  e.finalized_ = !0, e.scope_.unfinalizedDrafts_--;
+}
+var bt = (e, t) => e.scope_ === t, zr = [];
+function Bn(e, t, n, r) {
+  const i = ce(e), a = e.type_;
+  if (r !== void 0 && se(i, r, a) === t) {
+    dt(i, r, n, a);
+    return;
+  }
+  if (!e.draftLocations_) {
+    const _ = e.draftLocations_ = /* @__PURE__ */ new Map();
+    Ne(i, (C, P) => {
+      if (Z(P)) {
+        const T = _.get(P) || [];
+        T.push(C), _.set(P, T);
+      }
+    });
+  }
+  const v = e.draftLocations_.get(t) ?? zr;
+  for (const _ of v)
+    dt(i, _, n, a);
+}
+function Ur(e, t, n) {
+  e.callbacks_.push(function(i) {
+    const a = t;
+    if (!a || !bt(a, i))
+      return;
+    i.mapSetPlugin_?.fixSetContents(a);
+    const v = Gt(a);
+    Bn(e, a.draft_ ?? a, v, n), Gn(a, i);
+  });
+}
+function Gn(e, t) {
+  if (e.modified_ && !e.finalized_ && (e.type_ === 3 || (e.assigned_?.size ?? 0) > 0)) {
+    const { patchPlugin_: r } = t;
+    if (r) {
+      const i = r.getPath(e);
+      i && r.generatePatches_(e, i, t);
+    }
+    Wn(e);
+  }
+}
+function $r(e, t, n) {
+  const { scope_: r } = e;
+  if (Z(n)) {
+    const i = n[B];
+    bt(i, r) && i.callbacks_.push(function() {
+      lt(e);
+      const v = Gt(i);
+      Bn(e, n, v, t);
+    });
+  } else re(n) && e.callbacks_.push(function() {
+    const a = ce(e);
+    se(a, t, e.type_) === n && r.drafts_.length > 1 && (e.assigned_.get(t) ?? !1) === !0 && e.copy_ && Jt(
+      se(e.copy_, t, e.type_),
+      r.handledSet_,
+      r
+    );
+  });
+}
+function Jt(e, t, n) {
+  return !n.immer_.autoFreeze_ && n.unfinalizedDrafts_ < 1 || Z(e) || t.has(e) || !re(e) || St(e) || (t.add(e), Ne(e, (r, i) => {
+    if (Z(i)) {
+      const a = i[B];
+      if (bt(a, n)) {
+        const v = Gt(a);
+        dt(e, r, v, e.type_), Wn(a);
+      }
+    } else re(i) && Jt(i, t, n);
+  })), e;
+}
+function Lr(e, t) {
+  const n = Je(e), r = {
+    type_: n ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : Hn(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    // actually instantiated in `prepareCopy()`
+    assigned_: void 0,
+    // The parent draft state.
+    parent_: t,
+    // The base state.
+    base_: e,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1,
+    // `callbacks` actually gets assigned in `createProxy`
+    callbacks_: void 0
+  };
+  let i = r, a = Xt;
+  n && (i = [r], a = He);
+  const { revoke: v, proxy: _ } = Proxy.revocable(i, a);
+  return r.draft_ = _, r.revoke_ = v, [_, r];
+}
+var Xt = {
+  get(e, t) {
+    if (t === B)
+      return e;
+    const n = ce(e);
+    if (!Ve(n, t, e.type_))
+      return jr(e, n, t);
+    const r = n[t];
+    if (e.finalized_ || !re(r))
+      return r;
+    if (r === It(e.base_, t)) {
+      lt(e);
+      const i = e.type_ === 1 ? +t : t, a = Vt(e.scope_, r, e, i);
+      return e.copy_[i] = a;
+    }
+    return r;
+  },
+  has(e, t) {
+    return t in ce(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(ce(e));
+  },
+  set(e, t, n) {
+    const r = Yn(ce(e), t);
+    if (r?.set)
+      return r.set.call(e.draft_, n), !0;
+    if (!e.modified_) {
+      const i = It(ce(e), t), a = i?.[B];
+      if (a && a.base_ === n)
+        return e.copy_[t] = n, e.assigned_.set(t, !1), !0;
+      if (Nr(n, i) && (n !== void 0 || Ve(e.base_, t, e.type_)))
+        return !0;
+      lt(e), xt(e);
+    }
+    return e.copy_[t] === n && // special case: handle new props with value 'undefined'
+    (n !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(n) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = n, e.assigned_.set(t, !0), $r(e, t, n)), !0;
+  },
+  deleteProperty(e, t) {
+    return lt(e), It(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_.set(t, !1), xt(e)) : e.assigned_.delete(t), e.copy_ && delete e.copy_[t], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(e, t) {
+    const n = ce(e), r = Reflect.getOwnPropertyDescriptor(n, t);
+    return r && {
+      [ut]: !0,
+      [Mt]: e.type_ !== 1 || t !== "length",
+      [ft]: r[ft],
+      [je]: n[t]
+    };
+  },
+  defineProperty() {
+    W(11);
+  },
+  getPrototypeOf(e) {
+    return Ee(e.base_);
+  },
+  setPrototypeOf() {
+    W(12);
+  }
+}, He = {};
+Ne(Xt, (e, t) => {
+  He[e] = function() {
+    const n = arguments;
+    return n[0] = n[0][0], t.apply(this, n);
+  };
+});
+He.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && W(13), He.set.call(this, e, t, void 0);
+};
+He.set = function(e, t, n) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && W(14), Xt.set.call(this, e[0], t, n, e[0]);
+};
+function It(e, t) {
+  const n = e[B];
+  return (n ? ce(n) : e)[t];
+}
+function jr(e, t, n) {
+  const r = Yn(t, n);
+  return r ? je in r ? r[je] : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    r.get?.call(e.draft_)
+  ) : void 0;
+}
+function Yn(e, t) {
+  if (!(t in e))
+    return;
+  let n = Ee(e);
+  for (; n; ) {
+    const r = Object.getOwnPropertyDescriptor(n, t);
+    if (r)
+      return r;
+    n = Ee(n);
+  }
+}
+function xt(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && xt(e.parent_));
+}
+function lt(e) {
+  e.copy_ || (e.assigned_ = /* @__PURE__ */ new Map(), e.copy_ = Qt(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var Kr = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !1, this.produce = (t, n, r) => {
+      if (pe(t) && !pe(n)) {
+        const a = n;
+        n = t;
+        const v = this;
+        return function(C = a, ...P) {
+          return v.produce(C, (T) => n.call(this, T, ...P));
+        };
+      }
+      pe(n) || W(6), r !== void 0 && !pe(r) && W(7);
+      let i;
+      if (re(t)) {
+        const a = dn(this), v = Vt(a, t, void 0);
+        let _ = !0;
+        try {
+          i = n(v), _ = !1;
+        } finally {
+          _ ? qt(a) : Ft(a);
+        }
+        return fn(a, r), pn(i, a);
+      } else if (!t || !Ae(t)) {
+        if (i = n(t), i === void 0 && (i = t), i === Bt && (i = void 0), this.autoFreeze_ && Yt(i, !0), r) {
+          const a = [], v = [];
+          Ce(ht).generateReplacementPatches_(t, i, {
+            patches_: a,
+            inversePatches_: v
+          }), r(a, v);
+        }
+        return i;
+      } else
+        W(1, t);
+    }, this.produceWithPatches = (t, n) => {
+      if (pe(t))
+        return (v, ..._) => this.produceWithPatches(v, (C) => t(C, ..._));
+      let r, i;
+      return [this.produce(t, n, (v, _) => {
+        r = v, i = _;
+      }), r, i];
+    }, Ot(e?.autoFreeze) && this.setAutoFreeze(e.autoFreeze), Ot(e?.useStrictShallowCopy) && this.setUseStrictShallowCopy(e.useStrictShallowCopy), Ot(e?.useStrictIteration) && this.setUseStrictIteration(e.useStrictIteration);
+  }
+  createDraft(e) {
+    re(e) || W(8), Z(e) && (e = Jn(e));
+    const t = dn(this), n = Vt(t, e, void 0);
+    return n[B].isManual_ = !0, Ft(t), n;
+  }
+  finishDraft(e, t) {
+    const n = e && e[B];
+    (!n || !n.isManual_) && W(9);
+    const { scope_: r } = n;
+    return fn(r, t), pn(void 0, r);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(e) {
+    this.autoFreeze_ = e;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(e) {
+    this.useStrictShallowCopy_ = e;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(e) {
+    this.useStrictIteration_ = e;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(e, t) {
+    let n;
+    for (n = t.length - 1; n >= 0; n--) {
+      const i = t[n];
+      if (i.path.length === 0 && i.op === "replace") {
+        e = i.value;
+        break;
+      }
+    }
+    n > -1 && (t = t.slice(n + 1));
+    const r = Ce(ht).applyPatches_;
+    return Z(e) ? r(e, t) : this.produce(
+      e,
+      (i) => r(i, t)
+    );
+  }
+};
+function Vt(e, t, n, r) {
+  const [i, a] = Xe(t) ? Ce(pt).proxyMap_(t, n) : Ze(t) ? Ce(pt).proxySet_(t, n) : Lr(t, n);
+  return (n?.scope_ ?? Hn()).drafts_.push(i), a.callbacks_ = n?.callbacks_ ?? [], a.key_ = r, n && r !== void 0 ? Ur(n, a, r) : a.callbacks_.push(function(C) {
+    C.mapSetPlugin_?.fixSetContents(a);
+    const { patchPlugin_: P } = C;
+    a.modified_ && P && P.generatePatches_(a, [], C);
+  }), i;
+}
+function Jn(e) {
+  return Z(e) || W(10, e), Xn(e);
+}
+function Xn(e) {
+  if (!re(e) || St(e))
+    return e;
+  const t = e[B];
+  let n, r = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, n = Qt(e, t.scope_.immer_.useStrictShallowCopy_), r = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    n = Qt(e, !0);
+  return Ne(
+    n,
+    (i, a) => {
+      dt(n, i, Xn(a));
+    },
+    r
+  ), t && (t.finalized_ = !1), n;
+}
+function Hr() {
+  process.env.NODE_ENV !== "production" && jn.push(
+    'Sets cannot have "replace" patches.',
+    function(d) {
+      return "Unsupported patch operation: " + d;
+    },
+    function(d) {
+      return "Cannot apply patch, path doesn't resolve: " + d;
+    },
+    "Patching reserved attributes like __proto__, prototype and constructor is not allowed"
+  );
+  function t(d, S = []) {
+    if ("key_" in d && d.key_ !== void 0) {
+      const p = d.parent_.copy_ ?? d.parent_.base_, w = kr(se(p, d.key_)), O = se(p, d.key_);
+      if (O === void 0 || O !== d.draft_ && O !== d.base_ && O !== d.copy_ || w != null && w.base_ !== d.base_)
+        return null;
+      const f = d.parent_.type_ === 3;
+      let g;
+      if (f) {
+        const o = d.parent_;
+        g = Array.from(o.drafts_.keys()).indexOf(d.key_);
+      } else
+        g = d.key_;
+      if (!(f && p.size > g || Ve(p, g)))
+        return null;
+      S.push(g);
+    }
+    if (d.parent_)
+      return t(d.parent_, S);
+    S.reverse();
+    try {
+      n(d.copy_, S);
+    } catch {
+      return null;
+    }
+    return S;
+  }
+  function n(d, S) {
+    let p = d;
+    for (let w = 0; w < S.length - 1; w++) {
+      const O = S[w];
+      if (p = se(p, O), !Ae(p) || p === null)
+        throw new Error(`Cannot resolve path at '${S.join("/")}'`);
+    }
+    return p;
+  }
+  const r = "replace", i = "add", a = "remove";
+  function v(d, S, p) {
+    if (d.scope_.processedForPatches_.has(d))
+      return;
+    d.scope_.processedForPatches_.add(d);
+    const { patches_: w, inversePatches_: O } = p;
+    switch (d.type_) {
+      case 0:
+      case 2:
+        return C(
+          d,
+          S,
+          w,
+          O
+        );
+      case 1:
+        return _(
+          d,
+          S,
+          w,
+          O
+        );
+      case 3:
+        return P(
+          d,
+          S,
+          w,
+          O
+        );
+    }
+  }
+  function _(d, S, p, w) {
+    let { base_: O, assigned_: f } = d, g = d.copy_;
+    g.length < O.length && ([O, g] = [g, O], [p, w] = [w, p]);
+    for (let o = 0; o < O.length; o++) {
+      const c = g[o], E = O[o];
+      if (f?.get(o.toString()) && c !== E) {
+        const b = c?.[B];
+        if (b && b.modified_)
+          continue;
+        const h = S.concat([o]);
+        p.push({
+          op: r,
+          path: h,
+          // Need to maybe clone it, as it can in fact be the original value
+          // due to the base/copy inversion at the start of this function
+          value: R(c)
+        }), w.push({
+          op: r,
+          path: h,
+          value: R(E)
+        });
+      }
+    }
+    for (let o = O.length; o < g.length; o++) {
+      const c = S.concat([o]);
+      p.push({
+        op: i,
+        path: c,
+        // Need to maybe clone it, as it can in fact be the original value
+        // due to the base/copy inversion at the start of this function
+        value: R(g[o])
+      });
+    }
+    for (let o = g.length - 1; O.length <= o; --o) {
+      const c = S.concat([o]);
+      w.push({
+        op: a,
+        path: c
+      });
+    }
+  }
+  function C(d, S, p, w) {
+    const { base_: O, copy_: f, type_: g } = d;
+    Ne(d.assigned_, (o, c) => {
+      const E = se(O, o, g), b = se(f, o, g), h = c ? Ve(O, o) ? r : i : a;
+      if (E === b && h === r)
+        return;
+      const l = S.concat(o);
+      p.push(
+        h === a ? { op: h, path: l } : { op: h, path: l, value: R(b) }
+      ), w.push(
+        h === i ? { op: a, path: l } : h === a ? { op: i, path: l, value: R(E) } : { op: r, path: l, value: R(E) }
+      );
+    });
+  }
+  function P(d, S, p, w) {
+    let { base_: O, copy_: f } = d, g = 0;
+    O.forEach((o) => {
+      if (!f.has(o)) {
+        const c = S.concat([g]);
+        p.push({
+          op: a,
+          path: c,
+          value: o
+        }), w.unshift({
+          op: i,
+          path: c,
+          value: o
+        });
+      }
+      g++;
+    }), g = 0, f.forEach((o) => {
+      if (!O.has(o)) {
+        const c = S.concat([g]);
+        p.push({
+          op: i,
+          path: c,
+          value: o
+        }), w.unshift({
+          op: a,
+          path: c,
+          value: o
+        });
+      }
+      g++;
+    });
+  }
+  function T(d, S, p) {
+    const { patches_: w, inversePatches_: O } = p;
+    w.push({
+      op: r,
+      path: [],
+      value: S === Bt ? void 0 : S
+    }), O.push({
+      op: r,
+      path: [],
+      value: d
+    });
+  }
+  function I(d, S) {
+    return S.forEach((p) => {
+      const { path: w, op: O } = p;
+      let f = d;
+      for (let E = 0; E < w.length - 1; E++) {
+        const b = we(f);
+        let h = w[E];
+        typeof h != "string" && typeof h != "number" && (h = "" + h), (b === 0 || b === 1) && (h === "__proto__" || h === Le) && W(19), pe(f) && h === Ye && W(19), f = se(f, h), Ae(f) || W(18, w.join("/"));
+      }
+      const g = we(f), o = A(p.value), c = w[w.length - 1];
+      switch (O) {
+        case r:
+          switch (g) {
+            case 2:
+              return f.set(c, o);
+            case 3:
+              W(16);
+            default:
+              return f[c] = o;
+          }
+        case i:
+          switch (g) {
+            case 1:
+              return c === "-" ? f.push(o) : f.splice(c, 0, o);
+            case 2:
+              return f.set(c, o);
+            case 3:
+              return f.add(o);
+            default:
+              return f[c] = o;
+          }
+        case a:
+          switch (g) {
+            case 1:
+              return f.splice(c, 1);
+            case 2:
+              return f.delete(c);
+            case 3:
+              return f.delete(p.value);
+            default:
+              return delete f[c];
+          }
+        default:
+          W(17, O);
+      }
+    }), d;
+  }
+  function A(d) {
+    if (!re(d))
+      return d;
+    if (Je(d))
+      return d.map(A);
+    if (Xe(d))
+      return new Map(
+        Array.from(d.entries()).map(([p, w]) => [p, A(w)])
+      );
+    if (Ze(d))
+      return new Set(Array.from(d).map(A));
+    const S = Object.create(Ee(d));
+    for (const p in d)
+      S[p] = A(d[p]);
+    return Ve(d, xe) && (S[xe] = d[xe]), S;
+  }
+  function R(d) {
+    return Z(d) ? A(d) : d;
+  }
+  qr(ht, {
+    applyPatches_: I,
+    generatePatches_: v,
+    generateReplacementPatches_: T,
+    getPath: t
+  });
+}
+var We = new Kr();
+We.produce;
+var Zn = /* @__PURE__ */ We.produceWithPatches.bind(
+  We
+), yn = /* @__PURE__ */ We.applyPatches.bind(We), Wr = class extends Error {
+  /**
+   * The schema issues.
+   */
+  issues;
+  /**
+   * Creates a schema error with useful information.
+   *
+   * @param issues The schema issues.
+   */
+  constructor(e) {
+    super(e[0].message), this.name = "SchemaError", this.issues = e;
+  }
+}, Br = (e, t, n) => {
+  if (t.length === 1 && t[0] === n) {
+    let r = !1;
+    try {
+      const i = {};
+      e(i) === i && (r = !0);
+    } catch {
+    }
+    if (r) {
+      let i;
+      try {
+        throw new Error();
+      } catch (a) {
+        ({ stack: i } = a);
+      }
+      console.warn(
+        `The result function returned its own inputs without modification. e.g
+\`createSelector([state => state.todos], todos => todos)\`
+This could lead to inefficient memoization and unnecessary re-renders.
+Ensure transformation logic is in the result function, and extraction logic is in the input selectors.`,
+        { stack: i }
+      );
+    }
+  }
+}, Gr = (e, t, n) => {
+  const { memoize: r, memoizeOptions: i } = t, { inputSelectorResults: a, inputSelectorResultsCopy: v } = e, _ = r(() => ({}), ...i);
+  if (!(_.apply(null, a) === _.apply(null, v))) {
+    let P;
+    try {
+      throw new Error();
+    } catch (T) {
+      ({ stack: P } = T);
+    }
+    console.warn(
+      `An input selector returned a different result when passed same arguments.
+This means your output selector will likely run more frequently than intended.
+Avoid returning a new reference inside your input selector, e.g.
+\`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)\``,
+      {
+        arguments: n,
+        firstInputs: a,
+        secondInputs: v,
+        stack: P
+      }
+    );
+  }
+}, Yr = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+};
+function Jr(e, t = `expected a function, instead received ${typeof e}`) {
+  if (typeof e != "function")
+    throw new TypeError(t);
+}
+function Xr(e, t = `expected an object, instead received ${typeof e}`) {
+  if (typeof e != "object")
+    throw new TypeError(t);
+}
+function Zr(e, t = "expected all items to be functions, instead received the following types: ") {
+  if (!e.every((n) => typeof n == "function")) {
+    const n = e.map(
+      (r) => typeof r == "function" ? `function ${r.name || "unnamed"}()` : typeof r
+    ).join(", ");
+    throw new TypeError(`${t}[${n}]`);
+  }
+}
+var gn = (e) => Array.isArray(e) ? e : [e];
+function ei(e) {
+  const t = Array.isArray(e[0]) ? e[0] : e;
+  return Zr(
+    t,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), t;
+}
+function mn(e, t) {
+  const n = [], { length: r } = e;
+  for (let i = 0; i < r; i++)
+    n.push(e[i].apply(null, t));
+  return n;
+}
+var ti = (e, t) => {
+  const { identityFunctionCheck: n, inputStabilityCheck: r } = {
+    ...Yr,
+    ...t
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: n === "always" || n === "once" && e,
+      run: Br
+    },
+    inputStabilityCheck: {
+      shouldRun: r === "always" || r === "once" && e,
+      run: Gr
+    }
+  };
+}, ni = class {
+  constructor(e) {
+    this.value = e;
+  }
+  deref() {
+    return this.value;
+  }
+}, ri = typeof WeakRef < "u" ? WeakRef : ni, ii = 0, vn = 1;
+function it() {
+  return {
+    s: ii,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function gt(e, t = {}) {
+  let n = it();
+  const { resultEqualityCheck: r } = t;
+  let i, a = 0;
+  function v() {
+    let _ = n;
+    const { length: C } = arguments;
+    for (let I = 0, A = C; I < A; I++) {
+      const R = arguments[I];
+      if (typeof R == "function" || typeof R == "object" && R !== null) {
+        let d = _.o;
+        d === null && (_.o = d = /* @__PURE__ */ new WeakMap());
+        const S = d.get(R);
+        S === void 0 ? (_ = it(), d.set(R, _)) : _ = S;
+      } else {
+        let d = _.p;
+        d === null && (_.p = d = /* @__PURE__ */ new Map());
+        const S = d.get(R);
+        S === void 0 ? (_ = it(), d.set(R, _)) : _ = S;
+      }
+    }
+    const P = _;
+    let T;
+    if (_.s === vn)
+      T = _.v;
+    else if (T = e.apply(null, arguments), a++, r) {
+      const I = i?.deref?.() ?? i;
+      I != null && r(I, T) && (T = I, a !== 0 && a--), i = typeof T == "object" && T !== null || typeof T == "function" ? new ri(T) : T;
+    }
+    return P.s = vn, P.v = T, T;
+  }
+  return v.clearCache = () => {
+    n = it(), v.resetResultsCount();
+  }, v.resultsCount = () => a, v.resetResultsCount = () => {
+    a = 0;
+  }, v;
+}
+function oi(e, ...t) {
+  const n = typeof e == "function" ? {
+    memoize: e,
+    memoizeOptions: t
+  } : e, r = (...i) => {
+    let a = 0, v = 0, _, C = {}, P = i.pop();
+    typeof P == "object" && (C = P, P = i.pop()), Jr(
+      P,
+      `createSelector expects an output function after the inputs, but received: [${typeof P}]`
+    );
+    const T = {
+      ...n,
+      ...C
+    }, {
+      memoize: I,
+      memoizeOptions: A = [],
+      argsMemoize: R = gt,
+      argsMemoizeOptions: d = [],
+      devModeChecks: S = {}
+    } = T, p = gn(A), w = gn(d), O = ei(i), f = I(function() {
+      return a++, P.apply(
+        null,
+        arguments
+      );
+    }, ...p);
+    let g = !0;
+    const o = R(function() {
+      v++;
+      const E = mn(
+        O,
+        arguments
+      );
+      if (_ = f.apply(null, E), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: b, inputStabilityCheck: h } = ti(g, S);
+        if (b.shouldRun && b.run(
+          P,
+          E,
+          _
+        ), h.shouldRun) {
+          const l = mn(
+            O,
+            arguments
+          );
+          h.run(
+            { inputSelectorResults: E, inputSelectorResultsCopy: l },
+            { memoize: I, memoizeOptions: p },
+            arguments
+          );
+        }
+        g && (g = !1);
+      }
+      return _;
+    }, ...w);
+    return Object.assign(o, {
+      resultFunc: P,
+      memoizedResultFunc: f,
+      dependencies: O,
+      dependencyRecomputations: () => v,
+      resetDependencyRecomputations: () => {
+        v = 0;
+      },
+      lastResult: () => _,
+      recomputations: () => a,
+      resetRecomputations: () => {
+        a = 0;
+      },
+      memoize: I,
+      argsMemoize: R
+    });
+  };
+  return Object.assign(r, {
+    withTypes: () => r
+  }), r;
+}
+var er = /* @__PURE__ */ oi(gt), si = Object.assign(
+  (e, t = er) => {
+    Xr(
+      e,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof e}`
+    );
+    const n = Object.keys(e), r = n.map(
+      (a) => e[a]
+    );
+    return t(
+      r,
+      (...a) => a.reduce((v, _, C) => (v[n[C]] = _, v), {})
+    );
+  },
+  { withTypes: () => si }
+), tr = /* @__PURE__ */ ((e) => (e.uninitialized = "uninitialized", e.pending = "pending", e.fulfilled = "fulfilled", e.rejected = "rejected", e))(tr || {}), ae = "uninitialized", zt = "pending", qe = "fulfilled", Fe = "rejected";
+function Sn(e) {
+  return {
+    status: e,
+    isUninitialized: e === ae,
+    isLoading: e === zt,
+    isSuccess: e === qe,
+    isError: e === Fe
+  };
+}
+var bn = Ue;
+function Zt(e, t) {
+  if (e === t || !(bn(e) && bn(t) || Array.isArray(e) && Array.isArray(t)))
+    return t;
+  const n = Object.keys(t), r = Object.keys(e);
+  let i = n.length === r.length;
+  const a = Array.isArray(t) ? [] : {};
+  for (const v of n)
+    a[v] = Zt(e[v], t[v]), i && (i = e[v] === a[v]);
+  return i ? e : a;
+}
+function Ut(e, t, n) {
+  return e.reduce((r, i, a) => (t(i, a) && r.push(n(i, a)), r), []).flat();
+}
+function ci(e) {
+  return new RegExp("(^|:)//").test(e);
+}
+function ai() {
+  return typeof document > "u" ? !0 : document.visibilityState !== "hidden";
+}
+function en(e) {
+  return e != null;
+}
+function _n(e) {
+  return [...e?.values() ?? []].filter(en);
+}
+function ui() {
+  return typeof navigator > "u" || navigator.onLine === void 0 ? !0 : navigator.onLine;
+}
+var li = (e) => e.replace(/\/$/, ""), fi = (e) => e.replace(/^\//, "");
+function di(e, t) {
+  if (!e)
+    return t;
+  if (!t)
+    return e;
+  if (ci(t))
+    return t;
+  const n = e.endsWith("/") || !t.startsWith("?") ? "/" : "";
+  return e = li(e), t = fi(t), `${e}${n}${t}`;
+}
+function mt(e, t, n) {
+  return e.has(t) ? e.get(t) : e.set(t, n(t)).get(t);
+}
+var $t = () => /* @__PURE__ */ new Map(), En = (...e) => fetch(...e), pi = (e) => e.status >= 200 && e.status <= 299, hi = (e) => (
+  /*applicat*/
+  /ion\/(vnd\.api\+)?json/.test(e.get("content-type") || "")
+);
+function wn(e) {
+  if (!Ue(e))
+    return e;
+  const t = {
+    ...e
+  };
+  for (const [n, r] of Object.entries(t))
+    r === void 0 && delete t[n];
+  return t;
+}
+var yi = (e) => typeof e == "object" && (Ue(e) || Array.isArray(e) || typeof e.toJSON == "function");
+function gi({
+  baseUrl: e,
+  prepareHeaders: t = (I) => I,
+  fetchFn: n = En,
+  paramsSerializer: r,
+  isJsonContentType: i = hi,
+  jsonContentType: a = "application/json",
+  jsonReplacer: v,
+  timeout: _,
+  responseHandler: C,
+  validateStatus: P,
+  ...T
+} = {}) {
+  return typeof fetch > "u" && n === En && console.warn("Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments."), async (A, R, d) => {
+    const {
+      getState: S,
+      extra: p,
+      endpoint: w,
+      forced: O,
+      type: f
+    } = R;
+    let g, {
+      url: o,
+      headers: c = new Headers(T.headers),
+      params: E = void 0,
+      responseHandler: b = C ?? "json",
+      validateStatus: h = P ?? pi,
+      timeout: l = _,
+      ...s
+    } = typeof A == "string" ? {
+      url: A
+    } : A, u, y = R.signal;
+    l && (u = new AbortController(), R.signal.addEventListener("abort", u.abort), y = u.signal);
+    let m = {
+      ...T,
+      signal: y,
+      ...s
+    };
+    c = new Headers(wn(c)), m.headers = await t(c, {
+      getState: S,
+      arg: A,
+      extra: p,
+      endpoint: w,
+      forced: O,
+      type: f,
+      extraOptions: d
+    }) || c;
+    const N = yi(m.body);
+    if (m.body != null && !N && typeof m.body != "string" && m.headers.delete("content-type"), !m.headers.has("content-type") && N && m.headers.set("content-type", a), N && i(m.headers) && (m.body = JSON.stringify(m.body, v)), m.headers.has("accept") || (b === "json" ? m.headers.set("accept", "application/json") : b === "text" && m.headers.set("accept", "text/plain, text/html, */*")), E) {
+      const q = ~o.indexOf("?") ? "&" : "?", j = r ? r(E) : new URLSearchParams(wn(E));
+      o += q + j;
+    }
+    o = di(e, o);
+    const M = new Request(o, m);
+    g = {
+      request: new Request(o, m)
+    };
+    let k, D = !1, Q = u && setTimeout(() => {
+      D = !0, u.abort();
+    }, l);
+    try {
+      k = await n(M);
+    } catch (q) {
+      return {
+        error: {
+          status: D ? "TIMEOUT_ERROR" : "FETCH_ERROR",
+          error: String(q)
+        },
+        meta: g
+      };
+    } finally {
+      Q && clearTimeout(Q), u?.signal.removeEventListener("abort", u.abort);
+    }
+    const V = k.clone();
+    g.response = V;
+    let L, K = "";
+    try {
+      let q;
+      if (await Promise.all([
+        I(k, b).then((j) => L = j, (j) => q = j),
+        // see https://github.com/node-fetch/node-fetch/issues/665#issuecomment-538995182
+        // we *have* to "use up" both streams at the same time or they will stop running in node-fetch scenarios
+        V.text().then((j) => K = j, () => {
+        })
+      ]), q) throw q;
+    } catch (q) {
+      return {
+        error: {
+          status: "PARSING_ERROR",
+          originalStatus: k.status,
+          data: K,
+          error: String(q)
+        },
+        meta: g
+      };
+    }
+    return h(k, L) ? {
+      data: L,
+      meta: g
+    } : {
+      error: {
+        status: k.status,
+        data: L
+      },
+      meta: g
+    };
+  };
+  async function I(A, R) {
+    if (typeof R == "function")
+      return R(A);
+    if (R === "content-type" && (R = i(A.headers) ? "json" : "text"), R === "json") {
+      const d = await A.text();
+      return d.length ? JSON.parse(d) : null;
+    }
+    return A.text();
+  }
+}
+var Pn = class {
+  constructor(e, t = void 0) {
+    this.value = e, this.meta = t;
+  }
+}, _t = "__rtkq/", mi = "online", vi = "offline", nr = "focused", tn = /* @__PURE__ */ De(`${_t}${nr}`), rr = /* @__PURE__ */ De(`${_t}un${nr}`), nn = /* @__PURE__ */ De(`${_t}${mi}`), ir = /* @__PURE__ */ De(`${_t}${vi}`), et = "query", or = "mutation", sr = "infinitequery";
+function Et(e) {
+  return e.type === et;
+}
+function Si(e) {
+  return e.type === or;
+}
+function tt(e) {
+  return e.type === sr;
+}
+function vt(e) {
+  return Et(e) || tt(e);
+}
+function rn(e, t, n, r, i, a) {
+  const v = bi(e) ? e(t, n, r, i) : e;
+  return v ? Ut(v, en, (_) => a(cr(_))) : [];
+}
+function bi(e) {
+  return typeof e == "function";
+}
+function cr(e) {
+  return typeof e == "string" ? {
+    type: e
+  } : e;
+}
+function _i(e, t) {
+  return e.catch(t);
+}
+var Te = (e, t) => e.endpointDefinitions[t], Be = Symbol("forceQueryFn"), Lt = (e) => typeof e[Be] == "function";
+function Ei({
+  serializeQueryArgs: e,
+  queryThunk: t,
+  infiniteQueryThunk: n,
+  mutationThunk: r,
+  api: i,
+  context: a,
+  getInternalState: v
+}) {
+  const _ = (o) => v(o)?.runningQueries, C = (o) => v(o)?.runningMutations, {
+    unsubscribeQueryResult: P,
+    removeMutationResult: T,
+    updateSubscriptionOptions: I
+  } = i.internalActions;
+  return {
+    buildInitiateQuery: O,
+    buildInitiateInfiniteQuery: f,
+    buildInitiateMutation: g,
+    getRunningQueryThunk: A,
+    getRunningMutationThunk: R,
+    getRunningQueriesThunk: d,
+    getRunningMutationsThunk: S
+  };
+  function A(o, c) {
+    return (E) => {
+      const b = Te(a, o), h = e({
+        queryArgs: c,
+        endpointDefinition: b,
+        endpointName: o
+      });
+      return _(E)?.get(h);
+    };
+  }
+  function R(o, c) {
+    return (E) => C(E)?.get(c);
+  }
+  function d() {
+    return (o) => _n(_(o));
+  }
+  function S() {
+    return (o) => _n(C(o));
+  }
+  function p(o) {
+    if (process.env.NODE_ENV !== "production") {
+      if (p.triggered) return;
+      const c = o(i.internalActions.internal_getRTKQSubscriptions());
+      if (p.triggered = !0, typeof c != "object" || typeof c?.type == "string")
+        throw new Error(process.env.NODE_ENV === "production" ? ye(34) : `Warning: Middleware for RTK-Query API at reducerPath "${i.reducerPath}" has not been added to the store.
+You must add the middleware for RTK-Query to function correctly!`);
+    }
+  }
+  function w(o, c) {
+    const E = (b, {
+      subscribe: h = !0,
+      forceRefetch: l,
+      subscriptionOptions: s,
+      [Be]: u,
+      ...y
+    } = {}) => (m, N) => {
+      const M = e({
+        queryArgs: b,
+        endpointDefinition: c,
+        endpointName: o
+      });
+      let F;
+      const k = {
+        ...y,
+        type: et,
+        subscribe: h,
+        forceRefetch: l,
+        subscriptionOptions: s,
+        endpointName: o,
+        originalArgs: b,
+        queryCacheKey: M,
+        [Be]: u
+      };
+      if (Et(c))
+        F = t(k);
+      else {
+        const {
+          direction: $,
+          initialPageParam: z,
+          refetchCachedPages: x
+        } = y;
+        F = n({
+          ...k,
+          // Supply these even if undefined. This helps with a field existence
+          // check over in `buildSlice.ts`
+          direction: $,
+          initialPageParam: z,
+          refetchCachedPages: x
+        });
+      }
+      const D = i.endpoints[o].select(b), Q = m(F), V = D(N());
+      p(m);
+      const {
+        requestId: L,
+        abort: K
+      } = Q, q = V.requestId !== L, j = _(m)?.get(M), H = () => D(N()), U = Object.assign(u ? (
+        // a query has been forced (upsertQueryData)
+        // -> we want to resolve it once data has been written with the data that will be written
+        Q.then(H)
+      ) : q && !j ? (
+        // a query has been skipped due to a condition and we do not have any currently running query
+        // -> we want to resolve it immediately with the current data
+        Promise.resolve(V)
+      ) : (
+        // query just started or one is already in flight
+        // -> wait for the running query, then resolve with data from after that
+        Promise.all([j, Q]).then(H)
+      ), {
+        arg: b,
+        requestId: L,
+        subscriptionOptions: s,
+        queryCacheKey: M,
+        abort: K,
+        async unwrap() {
+          const $ = await U;
+          if ($.isError)
+            throw $.error;
+          return $.data;
+        },
+        refetch: ($) => m(E(b, {
+          subscribe: !1,
+          forceRefetch: !0,
+          ...$
+        })),
+        unsubscribe() {
+          h && m(P({
+            queryCacheKey: M,
+            requestId: L
+          }));
+        },
+        updateSubscriptionOptions($) {
+          U.subscriptionOptions = $, m(I({
+            endpointName: o,
+            requestId: L,
+            queryCacheKey: M,
+            options: $
+          }));
+        }
+      });
+      if (!j && !q && !u) {
+        const $ = _(m);
+        $.set(M, U), U.then(() => {
+          $.delete(M);
+        });
+      }
+      return U;
+    };
+    return E;
+  }
+  function O(o, c) {
+    return w(o, c);
+  }
+  function f(o, c) {
+    return w(o, c);
+  }
+  function g(o) {
+    return (c, {
+      track: E = !0,
+      fixedCacheKey: b
+    } = {}) => (h, l) => {
+      const s = r({
+        type: "mutation",
+        endpointName: o,
+        originalArgs: c,
+        track: E,
+        fixedCacheKey: b
+      }), u = h(s);
+      p(h);
+      const {
+        requestId: y,
+        abort: m,
+        unwrap: N
+      } = u, M = _i(u.unwrap().then((Q) => ({
+        data: Q
+      })), (Q) => ({
+        error: Q
+      })), F = () => {
+        h(T({
+          requestId: y,
+          fixedCacheKey: b
+        }));
+      }, k = Object.assign(M, {
+        arg: u.arg,
+        requestId: y,
+        abort: m,
+        unwrap: N,
+        reset: F
+      }), D = C(h);
+      return D.set(y, k), k.then(() => {
+        D.delete(y);
+      }), b && (D.set(b, k), k.then(() => {
+        D.get(b) === k && D.delete(b);
+      })), k;
+    };
+  }
+}
+var ar = class extends Wr {
+  constructor(e, t, n, r) {
+    super(e), this.value = t, this.schemaName = n, this._bqMeta = r;
+  }
+}, me = (e, t) => Array.isArray(e) ? e.includes(t) : !!e;
+async function ve(e, t, n, r) {
+  const i = await e["~standard"].validate(t);
+  if (i.issues)
+    throw new ar(i.issues, t, n, r);
+  return i.value;
+}
+function Rn(e) {
+  return e;
+}
+var Me = (e = {}) => ({
+  ...e,
+  [Un]: !0
+});
+function wi({
+  reducerPath: e,
+  baseQuery: t,
+  context: {
+    endpointDefinitions: n
+  },
+  serializeQueryArgs: r,
+  api: i,
+  assertTagType: a,
+  selectors: v,
+  onSchemaFailure: _,
+  catchSchemaFailure: C,
+  skipSchemaValidation: P
+}) {
+  const T = (s, u, y, m) => (N, M) => {
+    const F = n[s], k = r({
+      queryArgs: u,
+      endpointDefinition: F,
+      endpointName: s
+    });
+    if (N(i.internalActions.queryResultPatched({
+      queryCacheKey: k,
+      patches: y
+    })), !m)
+      return;
+    const D = i.endpoints[s].select(u)(
+      // Work around TS 4.1 mismatch
+      M()
+    ), Q = rn(F.providesTags, D.data, void 0, u, {}, a);
+    N(i.internalActions.updateProvidedBy([{
+      queryCacheKey: k,
+      providedTags: Q
+    }]));
+  };
+  function I(s, u, y = 0) {
+    const m = [u, ...s];
+    return y && m.length > y ? m.slice(0, -1) : m;
+  }
+  function A(s, u, y = 0) {
+    const m = [...s, u];
+    return y && m.length > y ? m.slice(1) : m;
+  }
+  const R = (s, u, y, m = !0) => (N, M) => {
+    const k = i.endpoints[s].select(u)(
+      // Work around TS 4.1 mismatch
+      M()
+    ), D = {
+      patches: [],
+      inversePatches: [],
+      undo: () => N(i.util.patchQueryData(s, u, D.inversePatches, m))
+    };
+    if (k.status === ae)
+      return D;
+    let Q;
+    if ("data" in k)
+      if (re(k.data)) {
+        const [V, L, K] = Zn(k.data, y);
+        D.patches.push(...L), D.inversePatches.push(...K), Q = V;
+      } else
+        Q = y(k.data), D.patches.push({
+          op: "replace",
+          path: [],
+          value: Q
+        }), D.inversePatches.push({
+          op: "replace",
+          path: [],
+          value: k.data
+        });
+    return D.patches.length === 0 || N(i.util.patchQueryData(s, u, D.patches, m)), D;
+  }, d = (s, u, y) => (m) => m(i.endpoints[s].initiate(u, {
+    subscribe: !1,
+    forceRefetch: !0,
+    [Be]: () => ({
+      data: y
+    })
+  })), S = (s, u) => s.query && s[u] ? s[u] : Rn, p = async (s, {
+    signal: u,
+    abort: y,
+    rejectWithValue: m,
+    fulfillWithValue: N,
+    dispatch: M,
+    getState: F,
+    extra: k
+  }) => {
+    const D = n[s.endpointName], {
+      metaSchema: Q,
+      skipSchemaValidation: V = P
+    } = D, L = s.type === et;
+    try {
+      let K = Rn;
+      const q = {
+        signal: u,
+        abort: y,
+        dispatch: M,
+        getState: F,
+        extra: k,
+        endpoint: s.endpointName,
+        type: s.type,
+        forced: L ? w(s, F()) : void 0,
+        queryCacheKey: L ? s.queryCacheKey : void 0
+      }, j = L ? s[Be] : void 0;
+      let H;
+      const U = async (z, x, ne, Y) => {
+        if (x == null && z.pages.length)
+          return Promise.resolve({
+            data: z
+          });
+        const Re = {
+          queryArg: s.originalArgs,
+          pageParam: x
+        }, ie = await $(Re), Oe = Y ? I : A;
+        return {
+          data: {
+            pages: Oe(z.pages, ie.data, ne),
+            pageParams: Oe(z.pageParams, x, ne)
+          },
+          meta: ie.meta
+        };
+      };
+      async function $(z) {
+        let x;
+        const {
+          extraOptions: ne,
+          argSchema: Y,
+          rawResponseSchema: Re,
+          responseSchema: ie
+        } = D;
+        if (Y && !me(V, "arg") && (z = await ve(
+          Y,
+          z,
+          "argSchema",
+          {}
+          // we don't have a meta yet, so we can't pass it
+        )), j ? x = j() : D.query ? (K = S(D, "transformResponse"), x = await t(D.query(z), q, ne)) : x = await D.queryFn(z, q, ne, (X) => t(X, q, ne)), typeof process < "u" && process.env.NODE_ENV === "development") {
+          const X = D.query ? "`baseQuery`" : "`queryFn`";
+          let ee;
+          if (!x)
+            ee = `${X} did not return anything.`;
+          else if (typeof x != "object")
+            ee = `${X} did not return an object.`;
+          else if (x.error && x.data)
+            ee = `${X} returned an object containing both \`error\` and \`result\`.`;
+          else if (x.error === void 0 && x.data === void 0)
+            ee = `${X} returned an object containing neither a valid \`error\` and \`result\`. At least one of them should not be \`undefined\``;
+          else
+            for (const le of Object.keys(x))
+              if (le !== "error" && le !== "data" && le !== "meta") {
+                ee = `The object returned by ${X} has the unknown property ${le}.`;
+                break;
+              }
+          ee && console.error(`Error encountered handling the endpoint ${s.endpointName}.
+                  ${ee}
+                  It needs to return an object with either the shape \`{ data: <value> }\` or \`{ error: <value> }\` that may contain an optional \`meta\` property.
+                  Object returned was:`, x);
+        }
+        if (x.error) throw new Pn(x.error, x.meta);
+        let {
+          data: Oe
+        } = x;
+        Re && !me(V, "rawResponse") && (Oe = await ve(Re, x.data, "rawResponseSchema", x.meta));
+        let ue = await K(Oe, x.meta, z);
+        return ie && !me(V, "response") && (ue = await ve(ie, ue, "responseSchema", x.meta)), {
+          ...x,
+          data: ue
+        };
+      }
+      if (L && "infiniteQueryOptions" in D) {
+        const {
+          infiniteQueryOptions: z
+        } = D, {
+          maxPages: x = 1 / 0
+        } = z, ne = s.refetchCachedPages ?? z.refetchCachedPages ?? !0;
+        let Y;
+        const Re = {
+          pages: [],
+          pageParams: []
+        }, ie = v.selectQueryEntry(F(), s.queryCacheKey)?.data, ue = /* arg.forceRefetch */ w(s, F()) && !s.direction || !ie ? Re : ie;
+        if ("direction" in s && s.direction && ue.pages.length) {
+          const X = s.direction === "backward", le = (X ? ur : jt)(z, ue, s.originalArgs);
+          Y = await U(ue, le, x, X);
+        } else {
+          const {
+            initialPageParam: X = z.initialPageParam
+          } = s, ee = ie?.pageParams ?? [], le = ee[0] ?? X, wr = ee.length;
+          if (Y = await U(ue, le, x), j && (Y = {
+            data: Y.data.pages[0]
+          }), ne)
+            for (let sn = 1; sn < wr; sn++) {
+              const Pr = jt(z, Y.data, s.originalArgs);
+              Y = await U(Y.data, Pr, x);
+            }
+        }
+        H = Y;
+      } else
+        H = await $(s.originalArgs);
+      return Q && !me(V, "meta") && H.meta && (H.meta = await ve(Q, H.meta, "metaSchema", H.meta)), N(H.data, Me({
+        fulfilledTimeStamp: Date.now(),
+        baseQueryMeta: H.meta
+      }));
+    } catch (K) {
+      let q = K;
+      if (q instanceof Pn) {
+        let j = S(D, "transformErrorResponse");
+        const {
+          rawErrorResponseSchema: H,
+          errorResponseSchema: U
+        } = D;
+        let {
+          value: $,
+          meta: z
+        } = q;
+        try {
+          H && !me(V, "rawErrorResponse") && ($ = await ve(H, $, "rawErrorResponseSchema", z)), Q && !me(V, "meta") && (z = await ve(Q, z, "metaSchema", z));
+          let x = await j($, z, s.originalArgs);
+          return U && !me(V, "errorResponse") && (x = await ve(U, x, "errorResponseSchema", z)), m(x, Me({
+            baseQueryMeta: z
+          }));
+        } catch (x) {
+          q = x;
+        }
+      }
+      try {
+        if (q instanceof ar) {
+          const j = {
+            endpoint: s.endpointName,
+            arg: s.originalArgs,
+            type: s.type,
+            queryCacheKey: L ? s.queryCacheKey : void 0
+          };
+          D.onSchemaFailure?.(q, j), _?.(q, j);
+          const {
+            catchSchemaFailure: H = C
+          } = D;
+          if (H)
+            return m(H(q, j), Me({
+              baseQueryMeta: q._bqMeta
+            }));
+        }
+      } catch (j) {
+        q = j;
+      }
+      throw typeof process < "u" && process.env.NODE_ENV !== "production" ? console.error(`An unhandled error occurred processing a request for the endpoint "${s.endpointName}".
+In the case of an unhandled error, no tags will be "provided" or "invalidated".`, q) : console.error(q), q;
+    }
+  };
+  function w(s, u) {
+    const y = v.selectQueryEntry(u, s.queryCacheKey), m = v.selectConfig(u).refetchOnMountOrArgChange, N = y?.fulfilledTimeStamp, M = s.forceRefetch ?? (s.subscribe && m);
+    return M ? M === !0 || (Number(/* @__PURE__ */ new Date()) - Number(N)) / 1e3 >= M : !1;
+  }
+  const O = () => cn(`${e}/executeQuery`, p, {
+    getPendingMeta({
+      arg: u
+    }) {
+      const y = n[u.endpointName];
+      return Me({
+        startedTimeStamp: Date.now(),
+        ...tt(y) ? {
+          direction: u.direction
+        } : {}
+      });
+    },
+    condition(u, {
+      getState: y
+    }) {
+      const m = y(), N = v.selectQueryEntry(m, u.queryCacheKey), M = N?.fulfilledTimeStamp, F = u.originalArgs, k = N?.originalArgs, D = n[u.endpointName], Q = u.direction;
+      return Lt(u) ? !0 : N?.status === "pending" ? !1 : w(u, m) || Et(D) && D?.forceRefetch?.({
+        currentArg: F,
+        previousArg: k,
+        endpointState: N,
+        state: m
+      }) ? !0 : !(M && !Q);
+    },
+    dispatchConditionRejection: !0
+  }), f = O(), g = O(), o = cn(`${e}/executeMutation`, p, {
+    getPendingMeta() {
+      return Me({
+        startedTimeStamp: Date.now()
+      });
+    }
+  }), c = (s) => "force" in s, E = (s) => "ifOlderThan" in s, b = (s, u, y = {}) => (m, N) => {
+    const M = c(y) && y.force, F = E(y) && y.ifOlderThan, k = (Q = !0) => {
+      const V = {
+        forceRefetch: Q,
+        subscribe: !1
+      };
+      return i.endpoints[s].initiate(u, V);
+    }, D = i.endpoints[s].select(u)(N());
+    if (M)
+      m(k());
+    else if (F) {
+      const Q = D?.fulfilledTimeStamp;
+      if (!Q) {
+        m(k());
+        return;
+      }
+      (Number(/* @__PURE__ */ new Date()) - Number(new Date(Q))) / 1e3 >= F && m(k());
+    } else
+      m(k(!1));
+  };
+  function h(s) {
+    return (u) => u?.meta?.arg?.endpointName === s;
+  }
+  function l(s, u) {
+    return {
+      matchPending: Pt($n(s), h(u)),
+      matchFulfilled: Pt(_e(s), h(u)),
+      matchRejected: Pt(Wt(s), h(u))
+    };
+  }
+  return {
+    queryThunk: f,
+    mutationThunk: o,
+    infiniteQueryThunk: g,
+    prefetch: b,
+    updateQueryData: R,
+    upsertQueryData: d,
+    patchQueryData: T,
+    buildMatchThunkActions: l
+  };
+}
+function jt(e, {
+  pages: t,
+  pageParams: n
+}, r) {
+  const i = t.length - 1;
+  return e.getNextPageParam(t[i], t, n[i], n, r);
+}
+function ur(e, {
+  pages: t,
+  pageParams: n
+}, r) {
+  return e.getPreviousPageParam?.(t[0], t, n[0], n, r);
+}
+function lr(e, t, n, r) {
+  return rn(n[e.meta.arg.endpointName][t], _e(e) ? e.payload : void 0, Ht(e) ? e.payload : void 0, e.meta.arg.originalArgs, "baseQueryMeta" in e.meta ? e.meta.baseQueryMeta : void 0, r);
+}
+function On(e) {
+  return Z(e) ? Jn(e) : e;
+}
+function ot(e, t, n) {
+  const r = e[t];
+  r && n(r);
+}
+function Ge(e) {
+  return ("arg" in e ? e.arg.fixedCacheKey : e.fixedCacheKey) ?? e.requestId;
+}
+function In(e, t, n) {
+  const r = e[Ge(t)];
+  r && n(r);
+}
+var st = {};
+function Pi({
+  reducerPath: e,
+  queryThunk: t,
+  mutationThunk: n,
+  serializeQueryArgs: r,
+  context: {
+    endpointDefinitions: i,
+    apiUid: a,
+    extractRehydrationInfo: v,
+    hasRehydrationInfo: _
+  },
+  assertTagType: C,
+  config: P
+}) {
+  const T = De(`${e}/resetApiState`);
+  function I(h, l, s, u) {
+    h[l.queryCacheKey] ??= {
+      status: ae,
+      endpointName: l.endpointName
+    }, ot(h, l.queryCacheKey, (y) => {
+      y.status = zt, y.requestId = s && y.requestId ? (
+        // for `upsertQuery` **updates**, keep the current `requestId`
+        y.requestId
+      ) : (
+        // for normal queries or `upsertQuery` **inserts** always update the `requestId`
+        u.requestId
+      ), l.originalArgs !== void 0 && (y.originalArgs = l.originalArgs), y.startedTimeStamp = u.startedTimeStamp;
+      const m = i[u.arg.endpointName];
+      tt(m) && "direction" in l && (y.direction = l.direction);
+    });
+  }
+  function A(h, l, s, u) {
+    ot(h, l.arg.queryCacheKey, (y) => {
+      if (y.requestId !== l.requestId && !u) return;
+      const {
+        merge: m
+      } = i[l.arg.endpointName];
+      if (y.status = qe, m)
+        if (y.data !== void 0) {
+          const {
+            fulfilledTimeStamp: N,
+            arg: M,
+            baseQueryMeta: F,
+            requestId: k
+          } = l;
+          let D = Kt(y.data, (Q) => m(Q, s, {
+            arg: M.originalArgs,
+            baseQueryMeta: F,
+            fulfilledTimeStamp: N,
+            requestId: k
+          }));
+          y.data = D;
+        } else
+          y.data = s;
+      else
+        y.data = i[l.arg.endpointName].structuralSharing ?? !0 ? Zt(Z(y.data) ? Dr(y.data) : y.data, s) : s;
+      delete y.error, y.fulfilledTimeStamp = l.fulfilledTimeStamp;
+    });
+  }
+  const R = Se({
+    name: `${e}/queries`,
+    initialState: st,
+    reducers: {
+      removeQueryResult: {
+        reducer(h, {
+          payload: {
+            queryCacheKey: l
+          }
+        }) {
+          delete h[l];
+        },
+        prepare: ke()
+      },
+      cacheEntriesUpserted: {
+        reducer(h, l) {
+          for (const s of l.payload) {
+            const {
+              queryDescription: u,
+              value: y
+            } = s;
+            I(h, u, !0, {
+              arg: u,
+              requestId: l.meta.requestId,
+              startedTimeStamp: l.meta.timestamp
+            }), A(
+              h,
+              {
+                arg: u,
+                requestId: l.meta.requestId,
+                fulfilledTimeStamp: l.meta.timestamp,
+                baseQueryMeta: {}
+              },
+              y,
+              // We know we're upserting here
+              !0
+            );
+          }
+        },
+        prepare: (h) => ({
+          payload: h.map((u) => {
+            const {
+              endpointName: y,
+              arg: m,
+              value: N
+            } = u, M = i[y];
+            return {
+              queryDescription: {
+                type: et,
+                endpointName: y,
+                originalArgs: u.arg,
+                queryCacheKey: r({
+                  queryArgs: m,
+                  endpointDefinition: M,
+                  endpointName: y
+                })
+              },
+              value: N
+            };
+          }),
+          meta: {
+            [Un]: !0,
+            requestId: zn(),
+            timestamp: Date.now()
+          }
+        })
+      },
+      queryResultPatched: {
+        reducer(h, {
+          payload: {
+            queryCacheKey: l,
+            patches: s
+          }
+        }) {
+          ot(h, l, (u) => {
+            u.data = yn(u.data, s.concat());
+          });
+        },
+        prepare: ke()
+      }
+    },
+    extraReducers(h) {
+      h.addCase(t.pending, (l, {
+        meta: s,
+        meta: {
+          arg: u
+        }
+      }) => {
+        const y = Lt(u);
+        I(l, u, y, s);
+      }).addCase(t.fulfilled, (l, {
+        meta: s,
+        payload: u
+      }) => {
+        const y = Lt(s.arg);
+        A(l, s, u, y);
+      }).addCase(t.rejected, (l, {
+        meta: {
+          condition: s,
+          arg: u,
+          requestId: y
+        },
+        error: m,
+        payload: N
+      }) => {
+        ot(l, u.queryCacheKey, (M) => {
+          if (!s) {
+            if (M.requestId !== y) return;
+            M.status = Fe, M.error = N ?? m;
+          }
+        });
+      }).addMatcher(_, (l, s) => {
+        const {
+          queries: u
+        } = v(s);
+        for (const [y, m] of Object.entries(u))
+          // do not rehydrate entries that were currently in flight.
+          (m?.status === qe || m?.status === Fe) && (l[y] = m);
+      });
+    }
+  }), d = Se({
+    name: `${e}/mutations`,
+    initialState: st,
+    reducers: {
+      removeMutationResult: {
+        reducer(h, {
+          payload: l
+        }) {
+          const s = Ge(l);
+          s in h && delete h[s];
+        },
+        prepare: ke()
+      }
+    },
+    extraReducers(h) {
+      h.addCase(n.pending, (l, {
+        meta: s,
+        meta: {
+          requestId: u,
+          arg: y,
+          startedTimeStamp: m
+        }
+      }) => {
+        y.track && (l[Ge(s)] = {
+          requestId: u,
+          status: zt,
+          endpointName: y.endpointName,
+          startedTimeStamp: m
+        });
+      }).addCase(n.fulfilled, (l, {
+        payload: s,
+        meta: u
+      }) => {
+        u.arg.track && In(l, u, (y) => {
+          y.requestId === u.requestId && (y.status = qe, y.data = s, y.fulfilledTimeStamp = u.fulfilledTimeStamp);
+        });
+      }).addCase(n.rejected, (l, {
+        payload: s,
+        error: u,
+        meta: y
+      }) => {
+        y.arg.track && In(l, y, (m) => {
+          m.requestId === y.requestId && (m.status = Fe, m.error = s ?? u);
+        });
+      }).addMatcher(_, (l, s) => {
+        const {
+          mutations: u
+        } = v(s);
+        for (const [y, m] of Object.entries(u))
+          // do not rehydrate entries that were currently in flight.
+          (m?.status === qe || m?.status === Fe) && // only rehydrate endpoints that were persisted using a `fixedCacheKey`
+          y !== m?.requestId && (l[y] = m);
+      });
+    }
+  }), S = {
+    tags: {},
+    keys: {}
+  }, p = Se({
+    name: `${e}/invalidation`,
+    initialState: S,
+    reducers: {
+      updateProvidedBy: {
+        reducer(h, l) {
+          for (const {
+            queryCacheKey: s,
+            providedTags: u
+          } of l.payload) {
+            w(h, s);
+            for (const {
+              type: y,
+              id: m
+            } of u) {
+              const N = (h.tags[y] ??= {})[m || "__internal_without_id"] ??= [];
+              N.includes(s) || N.push(s);
+            }
+            h.keys[s] = u;
+          }
+        },
+        prepare: ke()
+      }
+    },
+    extraReducers(h) {
+      h.addCase(R.actions.removeQueryResult, (l, {
+        payload: {
+          queryCacheKey: s
+        }
+      }) => {
+        w(l, s);
+      }).addMatcher(_, (l, s) => {
+        const {
+          provided: u
+        } = v(s);
+        for (const [y, m] of Object.entries(u.tags ?? {}))
+          for (const [N, M] of Object.entries(m)) {
+            const F = (l.tags[y] ??= {})[N || "__internal_without_id"] ??= [];
+            for (const k of M)
+              F.includes(k) || F.push(k), l.keys[k] = u.keys[k];
+          }
+      }).addMatcher($e(_e(t), Ht(t)), (l, s) => {
+        O(l, [s]);
+      }).addMatcher(R.actions.cacheEntriesUpserted.match, (l, s) => {
+        const u = s.payload.map(({
+          queryDescription: y,
+          value: m
+        }) => ({
+          type: "UNKNOWN",
+          payload: m,
+          meta: {
+            requestStatus: "fulfilled",
+            requestId: "UNKNOWN",
+            arg: y
+          }
+        }));
+        O(l, u);
+      });
+    }
+  });
+  function w(h, l) {
+    const s = On(h.keys[l] ?? []);
+    for (const u of s) {
+      const y = u.type, m = u.id ?? "__internal_without_id", N = h.tags[y]?.[m];
+      N && (h.tags[y][m] = On(N).filter((M) => M !== l));
+    }
+    delete h.keys[l];
+  }
+  function O(h, l) {
+    const s = l.map((u) => {
+      const y = lr(u, "providesTags", i, C), {
+        queryCacheKey: m
+      } = u.meta.arg;
+      return {
+        queryCacheKey: m,
+        providedTags: y
+      };
+    });
+    p.caseReducers.updateProvidedBy(h, p.actions.updateProvidedBy(s));
+  }
+  const f = Se({
+    name: `${e}/subscriptions`,
+    initialState: st,
+    reducers: {
+      updateSubscriptionOptions(h, l) {
+      },
+      unsubscribeQueryResult(h, l) {
+      },
+      internal_getRTKQSubscriptions() {
+      }
+    }
+  }), g = Se({
+    name: `${e}/internalSubscriptions`,
+    initialState: st,
+    reducers: {
+      subscriptionsUpdated: {
+        reducer(h, l) {
+          return yn(h, l.payload);
+        },
+        prepare: ke()
+      }
+    }
+  }), o = Se({
+    name: `${e}/config`,
+    initialState: {
+      online: ui(),
+      focused: ai(),
+      middlewareRegistered: !1,
+      ...P
+    },
+    reducers: {
+      middlewareRegistered(h, {
+        payload: l
+      }) {
+        h.middlewareRegistered = h.middlewareRegistered === "conflict" || a !== l ? "conflict" : !0;
+      }
+    },
+    extraReducers: (h) => {
+      h.addCase(nn, (l) => {
+        l.online = !0;
+      }).addCase(ir, (l) => {
+        l.online = !1;
+      }).addCase(tn, (l) => {
+        l.focused = !0;
+      }).addCase(rr, (l) => {
+        l.focused = !1;
+      }).addMatcher(_, (l) => ({
+        ...l
+      }));
+    }
+  }), c = Or({
+    queries: R.reducer,
+    mutations: d.reducer,
+    provided: p.reducer,
+    subscriptions: g.reducer,
+    config: o.reducer
+  }), E = (h, l) => c(T.match(l) ? void 0 : h, l), b = {
+    ...o.actions,
+    ...R.actions,
+    ...f.actions,
+    ...g.actions,
+    ...d.actions,
+    ...p.actions,
+    resetApiState: T
+  };
+  return {
+    reducer: E,
+    actions: b
+  };
+}
+var te = /* @__PURE__ */ Symbol.for("RTKQ/skipToken"), fr = {
+  status: ae
+}, An = /* @__PURE__ */ Kt(fr, () => {
+}), Cn = /* @__PURE__ */ Kt(fr, () => {
+});
+function Ri({
+  serializeQueryArgs: e,
+  reducerPath: t,
+  createSelector: n
+}) {
+  const r = (f) => An, i = (f) => Cn;
+  return {
+    buildQuerySelector: A,
+    buildInfiniteQuerySelector: R,
+    buildMutationSelector: d,
+    selectInvalidatedBy: S,
+    selectCachedArgsForQuery: p,
+    selectApiState: v,
+    selectQueries: _,
+    selectMutations: P,
+    selectQueryEntry: C,
+    selectConfig: T
+  };
+  function a(f) {
+    return {
+      ...f,
+      ...Sn(f.status)
+    };
+  }
+  function v(f) {
+    const g = f[t];
+    if (process.env.NODE_ENV !== "production" && !g) {
+      if (v.triggered) return g;
+      v.triggered = !0, console.error(`Error: No data found at \`state.${t}\`. Did you forget to add the reducer to the store?`);
+    }
+    return g;
+  }
+  function _(f) {
+    return v(f)?.queries;
+  }
+  function C(f, g) {
+    return _(f)?.[g];
+  }
+  function P(f) {
+    return v(f)?.mutations;
+  }
+  function T(f) {
+    return v(f)?.config;
+  }
+  function I(f, g, o) {
+    return (c) => {
+      if (c === te)
+        return n(r, o);
+      const E = e({
+        queryArgs: c,
+        endpointDefinition: g,
+        endpointName: f
+      });
+      return n((h) => C(h, E) ?? An, o);
+    };
+  }
+  function A(f, g) {
+    return I(f, g, a);
+  }
+  function R(f, g) {
+    const {
+      infiniteQueryOptions: o
+    } = g;
+    function c(E) {
+      const b = {
+        ...E,
+        ...Sn(E.status)
+      }, {
+        isLoading: h,
+        isError: l,
+        direction: s
+      } = b, u = s === "forward", y = s === "backward";
+      return {
+        ...b,
+        hasNextPage: w(o, b.data, b.originalArgs),
+        hasPreviousPage: O(o, b.data, b.originalArgs),
+        isFetchingNextPage: h && u,
+        isFetchingPreviousPage: h && y,
+        isFetchNextPageError: l && u,
+        isFetchPreviousPageError: l && y
+      };
+    }
+    return I(f, g, c);
+  }
+  function d() {
+    return (f) => {
+      let g;
+      return typeof f == "object" ? g = Ge(f) ?? te : g = f, n(g === te ? i : (E) => v(E)?.mutations?.[g] ?? Cn, a);
+    };
+  }
+  function S(f, g) {
+    const o = f[t], c = /* @__PURE__ */ new Set(), E = Ut(g, en, cr);
+    for (const b of E) {
+      const h = o.provided.tags[b.type];
+      if (!h)
+        continue;
+      let l = (b.id !== void 0 ? (
+        // id given: invalidate all queries that provide this type & id
+        h[b.id]
+      ) : (
+        // no id: invalidate all queries that provide this type
+        Object.values(h).flat()
+      )) ?? [];
+      for (const s of l)
+        c.add(s);
+    }
+    return Array.from(c.values()).flatMap((b) => {
+      const h = o.queries[b];
+      return h ? {
+        queryCacheKey: b,
+        endpointName: h.endpointName,
+        originalArgs: h.originalArgs
+      } : [];
+    });
+  }
+  function p(f, g) {
+    return Ut(Object.values(_(f)), (o) => o?.endpointName === g && o.status !== ae, (o) => o.originalArgs);
+  }
+  function w(f, g, o) {
+    return g ? jt(f, g, o) != null : !1;
+  }
+  function O(f, g, o) {
+    return !g || !f.getPreviousPageParam ? !1 : ur(f, g, o) != null;
+  }
+}
+var Tn = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0, Dn = ({
+  endpointName: e,
+  queryArgs: t
+}) => {
+  let n = "";
+  const r = Tn?.get(t);
+  if (typeof r == "string")
+    n = r;
+  else {
+    const i = JSON.stringify(t, (a, v) => (v = typeof v == "bigint" ? {
+      $bigint: v.toString()
+    } : v, v = Ue(v) ? Object.keys(v).sort().reduce((_, C) => (_[C] = v[C], _), {}) : v, v));
+    Ue(t) && Tn?.set(t, i), n = i;
+  }
+  return `${e}(${n})`;
+};
+function dr(...e) {
+  return function(n) {
+    const r = gt((P) => n.extractRehydrationInfo?.(P, {
+      reducerPath: n.reducerPath ?? "api"
+    })), i = {
+      reducerPath: "api",
+      keepUnusedDataFor: 60,
+      refetchOnMountOrArgChange: !1,
+      refetchOnFocus: !1,
+      refetchOnReconnect: !1,
+      invalidationBehavior: "delayed",
+      ...n,
+      extractRehydrationInfo: r,
+      serializeQueryArgs(P) {
+        let T = Dn;
+        if ("serializeQueryArgs" in P.endpointDefinition) {
+          const I = P.endpointDefinition.serializeQueryArgs;
+          T = (A) => {
+            const R = I(A);
+            return typeof R == "string" ? R : Dn({
+              ...A,
+              queryArgs: R
+            });
+          };
+        } else n.serializeQueryArgs && (T = n.serializeQueryArgs);
+        return T(P);
+      },
+      tagTypes: [...n.tagTypes || []]
+    }, a = {
+      endpointDefinitions: {},
+      batch(P) {
+        P();
+      },
+      apiUid: zn(),
+      extractRehydrationInfo: r,
+      hasRehydrationInfo: gt((P) => r(P) != null)
+    }, v = {
+      injectEndpoints: C,
+      enhanceEndpoints({
+        addTagTypes: P,
+        endpoints: T
+      }) {
+        if (P)
+          for (const I of P)
+            i.tagTypes.includes(I) || i.tagTypes.push(I);
+        if (T)
+          for (const [I, A] of Object.entries(T))
+            typeof A == "function" ? A(Te(a, I)) : Object.assign(Te(a, I) || {}, A);
+        return v;
+      }
+    }, _ = e.map((P) => P.init(v, i, a));
+    function C(P) {
+      const T = P.endpoints({
+        query: (I) => ({
+          ...I,
+          type: et
+        }),
+        mutation: (I) => ({
+          ...I,
+          type: or
+        }),
+        infiniteQuery: (I) => ({
+          ...I,
+          type: sr
+        })
+      });
+      for (const [I, A] of Object.entries(T)) {
+        if (P.overrideExisting !== !0 && I in a.endpointDefinitions) {
+          if (P.overrideExisting === "throw")
+            throw new Error(process.env.NODE_ENV === "production" ? ye(39) : `called \`injectEndpoints\` to override already-existing endpointName ${I} without specifying \`overrideExisting: true\``);
+          typeof process < "u" && process.env.NODE_ENV === "development" && console.error(`called \`injectEndpoints\` to override already-existing endpointName ${I} without specifying \`overrideExisting: true\``);
+          continue;
+        }
+        if (typeof process < "u" && process.env.NODE_ENV === "development" && tt(A)) {
+          const {
+            infiniteQueryOptions: R
+          } = A, {
+            maxPages: d,
+            getPreviousPageParam: S
+          } = R;
+          if (typeof d == "number") {
+            if (d < 1)
+              throw new Error(process.env.NODE_ENV === "production" ? ye(40) : `maxPages for endpoint '${I}' must be a number greater than 0`);
+            if (typeof S != "function")
+              throw new Error(process.env.NODE_ENV === "production" ? ye(41) : `getPreviousPageParam for endpoint '${I}' must be a function if maxPages is used`);
+          }
+        }
+        a.endpointDefinitions[I] = A;
+        for (const R of _)
+          R.injectEndpoint(I, A);
+      }
+      return v;
+    }
+    return v.injectEndpoints({
+      endpoints: n.endpoints
+    });
+  };
+}
+function oe(e, ...t) {
+  return Object.assign(e, ...t);
+}
+var Oi = ({
+  api: e,
+  queryThunk: t,
+  internalState: n,
+  mwApi: r
+}) => {
+  const i = `${e.reducerPath}/subscriptions`;
+  let a = null, v = null;
+  const {
+    updateSubscriptionOptions: _,
+    unsubscribeQueryResult: C
+  } = e.internalActions, P = (S, p) => {
+    if (_.match(p)) {
+      const {
+        queryCacheKey: O,
+        requestId: f,
+        options: g
+      } = p.payload, o = S.get(O);
+      return o?.has(f) && o.set(f, g), !0;
+    }
+    if (C.match(p)) {
+      const {
+        queryCacheKey: O,
+        requestId: f
+      } = p.payload, g = S.get(O);
+      return g && g.delete(f), !0;
+    }
+    if (e.internalActions.removeQueryResult.match(p))
+      return S.delete(p.payload.queryCacheKey), !0;
+    if (t.pending.match(p)) {
+      const {
+        meta: {
+          arg: O,
+          requestId: f
+        }
+      } = p, g = mt(S, O.queryCacheKey, $t);
+      return O.subscribe && g.set(f, O.subscriptionOptions ?? g.get(f) ?? {}), !0;
+    }
+    let w = !1;
+    if (t.rejected.match(p)) {
+      const {
+        meta: {
+          condition: O,
+          arg: f,
+          requestId: g
+        }
+      } = p;
+      if (O && f.subscribe) {
+        const o = mt(S, f.queryCacheKey, $t);
+        o.set(g, f.subscriptionOptions ?? o.get(g) ?? {}), w = !0;
+      }
+    }
+    return w;
+  }, T = () => n.currentSubscriptions, R = {
+    getSubscriptions: T,
+    getSubscriptionCount: (S) => T().get(S)?.size ?? 0,
+    isRequestSubscribed: (S, p) => !!T()?.get(S)?.get(p)
+  };
+  function d(S) {
+    return JSON.parse(JSON.stringify(Object.fromEntries([...S].map(([p, w]) => [p, Object.fromEntries(w)]))));
+  }
+  return (S, p) => {
+    if (a || (a = d(n.currentSubscriptions)), e.util.resetApiState.match(S))
+      return a = {}, n.currentSubscriptions.clear(), v = null, [!0, !1];
+    if (e.internalActions.internal_getRTKQSubscriptions.match(S))
+      return [!1, R];
+    const w = P(n.currentSubscriptions, S);
+    let O = !0;
+    if (process.env.NODE_ENV === "test" && typeof S.type == "string" && S.type === `${e.reducerPath}/getPolling`)
+      return [!1, n.currentPolls];
+    if (w) {
+      v || (v = setTimeout(() => {
+        const o = d(n.currentSubscriptions), [, c] = Zn(a, () => o);
+        p.next(e.internalActions.subscriptionsUpdated(c)), a = o, v = null;
+      }, 500));
+      const f = typeof S.type == "string" && !!S.type.startsWith(i), g = t.rejected.match(S) && S.meta.condition && !!S.meta.arg.subscribe;
+      O = !f && !g;
+    }
+    return [O, !1];
+  };
+}, Ii = 2147483647 / 1e3 - 1, Ai = ({
+  reducerPath: e,
+  api: t,
+  queryThunk: n,
+  context: r,
+  internalState: i,
+  selectors: {
+    selectQueryEntry: a,
+    selectConfig: v
+  },
+  getRunningQueryThunk: _,
+  mwApi: C
+}) => {
+  const {
+    removeQueryResult: P,
+    unsubscribeQueryResult: T,
+    cacheEntriesUpserted: I
+  } = t.internalActions, A = $e(T.match, n.fulfilled, n.rejected, I.match);
+  function R(f) {
+    const g = i.currentSubscriptions.get(f);
+    return g ? g.size > 0 : !1;
+  }
+  const d = {};
+  function S(f) {
+    for (const g of f.values())
+      g?.abort?.();
+  }
+  const p = (f, g) => {
+    const o = g.getState(), c = v(o);
+    if (A(f)) {
+      let E;
+      if (I.match(f))
+        E = f.payload.map((b) => b.queryDescription.queryCacheKey);
+      else {
+        const {
+          queryCacheKey: b
+        } = T.match(f) ? f.payload : f.meta.arg;
+        E = [b];
+      }
+      w(E, g, c);
+    }
+    if (t.util.resetApiState.match(f)) {
+      for (const [E, b] of Object.entries(d))
+        b && clearTimeout(b), delete d[E];
+      S(i.runningQueries), S(i.runningMutations);
+    }
+    if (r.hasRehydrationInfo(f)) {
+      const {
+        queries: E
+      } = r.extractRehydrationInfo(f);
+      w(Object.keys(E), g, c);
+    }
+  };
+  function w(f, g, o) {
+    const c = g.getState();
+    for (const E of f) {
+      const b = a(c, E);
+      b?.endpointName && O(E, b.endpointName, g, o);
+    }
+  }
+  function O(f, g, o, c) {
+    const b = Te(r, g)?.keepUnusedDataFor ?? c.keepUnusedDataFor;
+    if (b === 1 / 0)
+      return;
+    const h = Math.max(0, Math.min(b, Ii));
+    if (!R(f)) {
+      const l = d[f];
+      l && clearTimeout(l), d[f] = setTimeout(() => {
+        if (!R(f)) {
+          const s = a(o.getState(), f);
+          s?.endpointName && o.dispatch(_(s.endpointName, s.originalArgs))?.abort(), o.dispatch(P({
+            queryCacheKey: f
+          }));
+        }
+        delete d[f];
+      }, h * 1e3);
+    }
+  }
+  return p;
+}, Nn = new Error("Promise never resolved before cacheEntryRemoved."), Ci = ({
+  api: e,
+  reducerPath: t,
+  context: n,
+  queryThunk: r,
+  mutationThunk: i,
+  internalState: a,
+  selectors: {
+    selectQueryEntry: v,
+    selectApiState: _
+  }
+}) => {
+  const C = an(r), P = an(i), T = _e(r, i), I = {}, {
+    removeQueryResult: A,
+    removeMutationResult: R,
+    cacheEntriesUpserted: d
+  } = e.internalActions;
+  function S(o, c, E) {
+    const b = I[o];
+    b?.valueResolved && (b.valueResolved({
+      data: c,
+      meta: E
+    }), delete b.valueResolved);
+  }
+  function p(o) {
+    const c = I[o];
+    c && (delete I[o], c.cacheEntryRemoved());
+  }
+  function w(o) {
+    const {
+      arg: c,
+      requestId: E
+    } = o.meta, {
+      endpointName: b,
+      originalArgs: h
+    } = c;
+    return [b, h, E];
+  }
+  const O = (o, c, E) => {
+    const b = f(o);
+    function h(l, s, u, y) {
+      const m = v(E, s), N = v(c.getState(), s);
+      !m && N && g(l, y, s, c, u);
+    }
+    if (r.pending.match(o)) {
+      const [l, s, u] = w(o);
+      h(l, b, u, s);
+    } else if (d.match(o))
+      for (const {
+        queryDescription: l,
+        value: s
+      } of o.payload) {
+        const {
+          endpointName: u,
+          originalArgs: y,
+          queryCacheKey: m
+        } = l;
+        h(u, m, o.meta.requestId, y), S(m, s, {});
+      }
+    else if (i.pending.match(o)) {
+      if (c.getState()[t].mutations[b]) {
+        const [s, u, y] = w(o);
+        g(s, u, b, c, y);
+      }
+    } else if (T(o))
+      S(b, o.payload, o.meta.baseQueryMeta);
+    else if (A.match(o) || R.match(o))
+      p(b);
+    else if (e.util.resetApiState.match(o))
+      for (const l of Object.keys(I))
+        p(l);
+  };
+  function f(o) {
+    return C(o) ? o.meta.arg.queryCacheKey : P(o) ? o.meta.arg.fixedCacheKey ?? o.meta.requestId : A.match(o) ? o.payload.queryCacheKey : R.match(o) ? Ge(o.payload) : "";
+  }
+  function g(o, c, E, b, h) {
+    const l = Te(n, o), s = l?.onCacheEntryAdded;
+    if (!s) return;
+    const u = {}, y = new Promise((D) => {
+      u.cacheEntryRemoved = D;
+    }), m = Promise.race([new Promise((D) => {
+      u.valueResolved = D;
+    }), y.then(() => {
+      throw Nn;
+    })]);
+    m.catch(() => {
+    }), I[E] = u;
+    const N = e.endpoints[o].select(vt(l) ? c : E), M = b.dispatch((D, Q, V) => V), F = {
+      ...b,
+      getCacheEntry: () => N(b.getState()),
+      requestId: h,
+      extra: M,
+      updateCachedData: vt(l) ? (D) => b.dispatch(e.util.updateQueryData(o, c, D)) : void 0,
+      cacheDataLoaded: m,
+      cacheEntryRemoved: y
+    }, k = s(c, F);
+    Promise.resolve(k).catch((D) => {
+      if (D !== Nn)
+        throw D;
+    });
+  }
+  return O;
+}, Ti = ({
+  api: e,
+  context: {
+    apiUid: t
+  },
+  reducerPath: n
+}) => (r, i) => {
+  e.util.resetApiState.match(r) && i.dispatch(e.internalActions.middlewareRegistered(t)), typeof process < "u" && process.env.NODE_ENV === "development" && e.internalActions.middlewareRegistered.match(r) && r.payload === t && i.getState()[n]?.config?.middlewareRegistered === "conflict" && console.warn(`There is a mismatch between slice and middleware for the reducerPath "${n}".
+You can only have one api per reducer path, this will lead to crashes in various situations!${n === "api" ? `
+If you have multiple apis, you *have* to specify the reducerPath option when using createApi!` : ""}`);
+}, Di = ({
+  reducerPath: e,
+  context: t,
+  context: {
+    endpointDefinitions: n
+  },
+  mutationThunk: r,
+  queryThunk: i,
+  api: a,
+  assertTagType: v,
+  refetchQuery: _,
+  internalState: C
+}) => {
+  const {
+    removeQueryResult: P
+  } = a.internalActions, T = $e(_e(r), Ht(r)), I = $e(_e(i, r), Wt(i, r));
+  let A = [], R = 0;
+  const d = (w, O) => {
+    (i.pending.match(w) || r.pending.match(w)) && R++, I(w) && (R = Math.max(0, R - 1)), T(w) ? p(lr(w, "invalidatesTags", n, v), O) : I(w) ? p([], O) : a.util.invalidateTags.match(w) && p(rn(w.payload, void 0, void 0, void 0, void 0, v), O);
+  };
+  function S() {
+    return R > 0;
+  }
+  function p(w, O) {
+    const f = O.getState(), g = f[e];
+    if (A.push(...w), g.config.invalidationBehavior === "delayed" && S())
+      return;
+    const o = A;
+    if (A = [], o.length === 0) return;
+    const c = a.util.selectInvalidatedBy(f, o);
+    t.batch(() => {
+      const E = Array.from(c.values());
+      for (const {
+        queryCacheKey: b
+      } of E) {
+        const h = g.queries[b], l = mt(C.currentSubscriptions, b, $t);
+        h && (l.size === 0 ? O.dispatch(P({
+          queryCacheKey: b
+        })) : h.status !== ae && O.dispatch(_(h)));
+      }
+    });
+  }
+  return d;
+}, Ni = ({
+  reducerPath: e,
+  queryThunk: t,
+  api: n,
+  refetchQuery: r,
+  internalState: i
+}) => {
+  const {
+    currentPolls: a,
+    currentSubscriptions: v
+  } = i, _ = /* @__PURE__ */ new Set();
+  let C = null;
+  const P = (p, w) => {
+    (n.internalActions.updateSubscriptionOptions.match(p) || n.internalActions.unsubscribeQueryResult.match(p)) && T(p.payload.queryCacheKey, w), (t.pending.match(p) || t.rejected.match(p) && p.meta.condition) && T(p.meta.arg.queryCacheKey, w), (t.fulfilled.match(p) || t.rejected.match(p) && !p.meta.condition) && I(p.meta.arg, w), n.util.resetApiState.match(p) && (d(), C && (clearTimeout(C), C = null), _.clear());
+  };
+  function T(p, w) {
+    _.add(p), C || (C = setTimeout(() => {
+      for (const O of _)
+        A({
+          queryCacheKey: O
+        }, w);
+      _.clear(), C = null;
+    }, 0));
+  }
+  function I({
+    queryCacheKey: p
+  }, w) {
+    const O = w.getState()[e], f = O.queries[p], g = v.get(p);
+    if (!f || f.status === ae) return;
+    const {
+      lowestPollingInterval: o,
+      skipPollingIfUnfocused: c
+    } = S(g);
+    if (!Number.isFinite(o)) return;
+    const E = a.get(p);
+    E?.timeout && (clearTimeout(E.timeout), E.timeout = void 0);
+    const b = Date.now() + o;
+    a.set(p, {
+      nextPollTimestamp: b,
+      pollingInterval: o,
+      timeout: setTimeout(() => {
+        (O.config.focused || !c) && w.dispatch(r(f)), I({
+          queryCacheKey: p
+        }, w);
+      }, o)
+    });
+  }
+  function A({
+    queryCacheKey: p
+  }, w) {
+    const f = w.getState()[e].queries[p], g = v.get(p);
+    if (!f || f.status === ae)
+      return;
+    const {
+      lowestPollingInterval: o
+    } = S(g);
+    if (process.env.NODE_ENV === "test") {
+      const b = a.pollUpdateCounters ??= {};
+      b[p] ??= 0, b[p]++;
+    }
+    if (!Number.isFinite(o)) {
+      R(p);
+      return;
+    }
+    const c = a.get(p), E = Date.now() + o;
+    (!c || E < c.nextPollTimestamp) && I({
+      queryCacheKey: p
+    }, w);
+  }
+  function R(p) {
+    const w = a.get(p);
+    w?.timeout && clearTimeout(w.timeout), a.delete(p);
+  }
+  function d() {
+    for (const p of a.keys())
+      R(p);
+  }
+  function S(p = /* @__PURE__ */ new Map()) {
+    let w = !1, O = Number.POSITIVE_INFINITY;
+    for (const f of p.values())
+      f.pollingInterval && (O = Math.min(f.pollingInterval, O), w = f.skipPollingIfUnfocused || w);
+    return {
+      lowestPollingInterval: O,
+      skipPollingIfUnfocused: w
+    };
+  }
+  return P;
+}, ki = ({
+  api: e,
+  context: t,
+  queryThunk: n,
+  mutationThunk: r
+}) => {
+  const i = $n(n, r), a = Wt(n, r), v = _e(n, r), _ = {};
+  return (P, T) => {
+    if (i(P)) {
+      const {
+        requestId: I,
+        arg: {
+          endpointName: A,
+          originalArgs: R
+        }
+      } = P.meta, d = Te(t, A), S = d?.onQueryStarted;
+      if (S) {
+        const p = {}, w = new Promise((o, c) => {
+          p.resolve = o, p.reject = c;
+        });
+        w.catch(() => {
+        }), _[I] = p;
+        const O = e.endpoints[A].select(vt(d) ? R : I), f = T.dispatch((o, c, E) => E), g = {
+          ...T,
+          getCacheEntry: () => O(T.getState()),
+          requestId: I,
+          extra: f,
+          updateCachedData: vt(d) ? (o) => T.dispatch(e.util.updateQueryData(A, R, o)) : void 0,
+          queryFulfilled: w
+        };
+        S(R, g);
+      }
+    } else if (v(P)) {
+      const {
+        requestId: I,
+        baseQueryMeta: A
+      } = P.meta;
+      _[I]?.resolve({
+        data: P.payload,
+        meta: A
+      }), delete _[I];
+    } else if (a(P)) {
+      const {
+        requestId: I,
+        rejectedWithValue: A,
+        baseQueryMeta: R
+      } = P.meta;
+      _[I]?.reject({
+        error: P.payload ?? P.error,
+        isUnhandledError: !A,
+        meta: R
+      }), delete _[I];
+    }
+  };
+}, Mi = ({
+  reducerPath: e,
+  context: t,
+  api: n,
+  refetchQuery: r,
+  internalState: i
+}) => {
+  const {
+    removeQueryResult: a
+  } = n.internalActions, v = (C, P) => {
+    tn.match(C) && _(P, "refetchOnFocus"), nn.match(C) && _(P, "refetchOnReconnect");
+  };
+  function _(C, P) {
+    const T = C.getState()[e], I = T.queries, A = i.currentSubscriptions;
+    t.batch(() => {
+      for (const R of A.keys()) {
+        const d = I[R], S = A.get(R);
+        if (!S || !d) continue;
+        const p = [...S.values()];
+        (p.some((O) => O[P] === !0) || p.every((O) => O[P] === void 0) && T.config[P]) && (S.size === 0 ? C.dispatch(a({
+          queryCacheKey: R
+        })) : d.status !== ae && C.dispatch(r(d)));
+      }
+    });
+  }
+  return v;
+};
+function Qi(e) {
+  const {
+    reducerPath: t,
+    queryThunk: n,
+    api: r,
+    context: i,
+    getInternalState: a
+  } = e, {
+    apiUid: v
+  } = i, _ = {
+    invalidateTags: De(`${t}/invalidateTags`)
+  }, C = (A) => A.type.startsWith(`${t}/`), P = [Ti, Ai, Di, Ni, Ci, ki];
+  return {
+    middleware: (A) => {
+      let R = !1;
+      const d = a(A.dispatch), S = {
+        ...e,
+        internalState: d,
+        refetchQuery: I,
+        isThisApiSliceAction: C,
+        mwApi: A
+      }, p = P.map((f) => f(S)), w = Oi(S), O = Mi(S);
+      return (f) => (g) => {
+        if (!Ir(g))
+          return f(g);
+        R || (R = !0, A.dispatch(r.internalActions.middlewareRegistered(v)));
+        const o = {
+          ...A,
+          next: f
+        }, c = A.getState(), [E, b] = w(g, o, c);
+        let h;
+        if (E ? h = f(g) : h = b, A.getState()[t] && (O(g, o, c), C(g) || i.hasRehydrationInfo(g)))
+          for (const l of p)
+            l(g, o, c);
+        return h;
+      };
+    },
+    actions: _
+  };
+  function I(A) {
+    return e.api.endpoints[A.endpointName].initiate(A.originalArgs, {
+      subscribe: !1,
+      forceRefetch: !0
+    });
+  }
+}
+var kn = /* @__PURE__ */ Symbol(), pr = ({
+  createSelector: e = Rr
+} = {}) => ({
+  name: kn,
+  init(t, {
+    baseQuery: n,
+    tagTypes: r,
+    reducerPath: i,
+    serializeQueryArgs: a,
+    keepUnusedDataFor: v,
+    refetchOnMountOrArgChange: _,
+    refetchOnFocus: C,
+    refetchOnReconnect: P,
+    invalidationBehavior: T,
+    onSchemaFailure: I,
+    catchSchemaFailure: A,
+    skipSchemaValidation: R
+  }, d) {
+    Hr();
+    const S = (U) => (typeof process < "u" && process.env.NODE_ENV === "development" && (r.includes(U.type) || console.error(`Tag type '${U.type}' was used, but not specified in \`tagTypes\`!`)), U);
+    Object.assign(t, {
+      reducerPath: i,
+      endpoints: {},
+      internalActions: {
+        onOnline: nn,
+        onOffline: ir,
+        onFocus: tn,
+        onFocusLost: rr
+      },
+      util: {}
+    });
+    const p = Ri({
+      serializeQueryArgs: a,
+      reducerPath: i,
+      createSelector: e
+    }), {
+      selectInvalidatedBy: w,
+      selectCachedArgsForQuery: O,
+      buildQuerySelector: f,
+      buildInfiniteQuerySelector: g,
+      buildMutationSelector: o
+    } = p;
+    oe(t.util, {
+      selectInvalidatedBy: w,
+      selectCachedArgsForQuery: O
+    });
+    const {
+      queryThunk: c,
+      infiniteQueryThunk: E,
+      mutationThunk: b,
+      patchQueryData: h,
+      updateQueryData: l,
+      upsertQueryData: s,
+      prefetch: u,
+      buildMatchThunkActions: y
+    } = wi({
+      baseQuery: n,
+      reducerPath: i,
+      context: d,
+      api: t,
+      serializeQueryArgs: a,
+      assertTagType: S,
+      selectors: p,
+      onSchemaFailure: I,
+      catchSchemaFailure: A,
+      skipSchemaValidation: R
+    }), {
+      reducer: m,
+      actions: N
+    } = Pi({
+      context: d,
+      queryThunk: c,
+      mutationThunk: b,
+      serializeQueryArgs: a,
+      reducerPath: i,
+      assertTagType: S,
+      config: {
+        refetchOnFocus: C,
+        refetchOnReconnect: P,
+        refetchOnMountOrArgChange: _,
+        keepUnusedDataFor: v,
+        reducerPath: i,
+        invalidationBehavior: T
+      }
+    });
+    oe(t.util, {
+      patchQueryData: h,
+      updateQueryData: l,
+      upsertQueryData: s,
+      prefetch: u,
+      resetApiState: N.resetApiState,
+      upsertQueryEntries: N.cacheEntriesUpserted
+    }), oe(t.internalActions, N);
+    const M = /* @__PURE__ */ new WeakMap(), F = (U) => mt(M, U, () => ({
+      currentSubscriptions: /* @__PURE__ */ new Map(),
+      currentPolls: /* @__PURE__ */ new Map(),
+      runningQueries: /* @__PURE__ */ new Map(),
+      runningMutations: /* @__PURE__ */ new Map()
+    })), {
+      buildInitiateQuery: k,
+      buildInitiateInfiniteQuery: D,
+      buildInitiateMutation: Q,
+      getRunningMutationThunk: V,
+      getRunningMutationsThunk: L,
+      getRunningQueriesThunk: K,
+      getRunningQueryThunk: q
+    } = Ei({
+      queryThunk: c,
+      mutationThunk: b,
+      infiniteQueryThunk: E,
+      api: t,
+      serializeQueryArgs: a,
+      context: d,
+      getInternalState: F
+    });
+    oe(t.util, {
+      getRunningMutationThunk: V,
+      getRunningMutationsThunk: L,
+      getRunningQueryThunk: q,
+      getRunningQueriesThunk: K
+    });
+    const {
+      middleware: j,
+      actions: H
+    } = Qi({
+      reducerPath: i,
+      context: d,
+      queryThunk: c,
+      mutationThunk: b,
+      infiniteQueryThunk: E,
+      api: t,
+      assertTagType: S,
+      selectors: p,
+      getRunningQueryThunk: q,
+      getInternalState: F
+    });
+    return oe(t.util, H), oe(t, {
+      reducer: m,
+      middleware: j
+    }), {
+      name: kn,
+      injectEndpoint(U, $) {
+        const z = t, x = z.endpoints[U] ??= {};
+        Et($) && oe(x, {
+          name: U,
+          select: f(U, $),
+          initiate: k(U, $)
+        }, y(c, U)), Si($) && oe(x, {
+          name: U,
+          select: o(),
+          initiate: Q(U)
+        }, y(b, U)), tt($) && oe(x, {
+          name: U,
+          select: g(U, $),
+          initiate: D(U, $)
+        }, y(c, U));
+      }
+    };
+  }
+});
+pr();
+var ct = { exports: {} }, At = {};
+var Mn;
+function qi() {
+  if (Mn) return At;
+  Mn = 1;
+  var e = Ln;
+  function t(C, P) {
+    return C === P && (C !== 0 || 1 / C === 1 / P) || C !== C && P !== P;
+  }
+  var n = typeof Object.is == "function" ? Object.is : t, r = e.useSyncExternalStore, i = e.useRef, a = e.useEffect, v = e.useMemo, _ = e.useDebugValue;
+  return At.useSyncExternalStoreWithSelector = function(C, P, T, I, A) {
+    var R = i(null);
+    if (R.current === null) {
+      var d = { hasValue: !1, value: null };
+      R.current = d;
+    } else d = R.current;
+    R = v(
+      function() {
+        function p(o) {
+          if (!w) {
+            if (w = !0, O = o, o = I(o), A !== void 0 && d.hasValue) {
+              var c = d.value;
+              if (A(c, o))
+                return f = c;
+            }
+            return f = o;
+          }
+          if (c = f, n(O, o)) return c;
+          var E = I(o);
+          return A !== void 0 && A(c, E) ? (O = o, c) : (O = o, f = E);
+        }
+        var w = !1, O, f, g = T === void 0 ? null : T;
+        return [
+          function() {
+            return p(P());
+          },
+          g === null ? void 0 : function() {
+            return p(g());
+          }
+        ];
+      },
+      [P, T, I, A]
+    );
+    var S = r(C, R[0], R[1]);
+    return a(
+      function() {
+        d.hasValue = !0, d.value = S;
+      },
+      [S]
+    ), _(S), S;
+  }, At;
+}
+var Ct = {};
+var Qn;
+function Fi() {
+  return Qn || (Qn = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(C, P) {
+      return C === P && (C !== 0 || 1 / C === 1 / P) || C !== C && P !== P;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var t = Ln, n = typeof Object.is == "function" ? Object.is : e, r = t.useSyncExternalStore, i = t.useRef, a = t.useEffect, v = t.useMemo, _ = t.useDebugValue;
+    Ct.useSyncExternalStoreWithSelector = function(C, P, T, I, A) {
+      var R = i(null);
+      if (R.current === null) {
+        var d = { hasValue: !1, value: null };
+        R.current = d;
+      } else d = R.current;
+      R = v(
+        function() {
+          function p(o) {
+            if (!w) {
+              if (w = !0, O = o, o = I(o), A !== void 0 && d.hasValue) {
+                var c = d.value;
+                if (A(c, o))
+                  return f = c;
+              }
+              return f = o;
+            }
+            if (c = f, n(O, o))
+              return c;
+            var E = I(o);
+            return A !== void 0 && A(c, E) ? (O = o, c) : (O = o, f = E);
+          }
+          var w = !1, O, f, g = T === void 0 ? null : T;
+          return [
+            function() {
+              return p(P());
+            },
+            g === null ? void 0 : function() {
+              return p(g());
+            }
+          ];
+        },
+        [P, T, I, A]
+      );
+      var S = r(C, R[0], R[1]);
+      return a(
+        function() {
+          d.hasValue = !0, d.value = S;
+        },
+        [S]
+      ), _(S), S;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), Ct;
+}
+var qn;
+function xi() {
+  return qn || (qn = 1, process.env.NODE_ENV === "production" ? ct.exports = qi() : ct.exports = Fi()), ct.exports;
+}
+var Vi = xi();
+function zi(e) {
+  e();
+}
+function Fn(e, t) {
+  return e === t ? e !== 0 || t !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function ze(e, t) {
+  if (Fn(e, t)) return !0;
+  if (typeof e != "object" || e === null || typeof t != "object" || t === null)
+    return !1;
+  const n = Object.keys(e), r = Object.keys(t);
+  if (n.length !== r.length) return !1;
+  for (let i = 0; i < n.length; i++)
+    if (!Object.prototype.hasOwnProperty.call(t, n[i]) || !Fn(e[n[i]], t[n[i]]))
+      return !1;
+  return !0;
+}
+var Ui = /* @__PURE__ */ Symbol.for("react-redux-context"), $i = typeof globalThis < "u" ? globalThis : (
+  /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
+  {}
+);
+function Li() {
+  if (!he.createContext) return {};
+  const e = $i[Ui] ??= /* @__PURE__ */ new Map();
+  let t = e.get(he.createContext);
+  return t || (t = he.createContext(
+    null
+  ), process.env.NODE_ENV !== "production" && (t.displayName = "ReactRedux"), e.set(he.createContext, t)), t;
+}
+var Pe = /* @__PURE__ */ Li();
+function on(e = Pe) {
+  return function() {
+    const n = he.useContext(e);
+    if (process.env.NODE_ENV !== "production" && !n)
+      throw new Error(
+        "could not find react-redux context value; please ensure the component is wrapped in a <Provider>"
+      );
+    return n;
+  };
+}
+var hr = /* @__PURE__ */ on();
+function yr(e = Pe) {
+  const t = e === Pe ? hr : (
+    // @ts-ignore
+    on(e)
+  ), n = () => {
+    const { store: r } = t();
+    return r;
+  };
+  return Object.assign(n, {
+    withTypes: () => n
+  }), n;
+}
+var gr = /* @__PURE__ */ yr();
+function ji(e = Pe) {
+  const t = e === Pe ? gr : yr(e), n = () => t().dispatch;
+  return Object.assign(n, {
+    withTypes: () => n
+  }), n;
+}
+var Ki = /* @__PURE__ */ ji(), Hi = (e, t) => e === t;
+function Wi(e = Pe) {
+  const t = e === Pe ? hr : on(e), n = (r, i = {}) => {
+    const { equalityFn: a = Hi } = typeof i == "function" ? { equalityFn: i } : i;
+    if (process.env.NODE_ENV !== "production") {
+      if (!r)
+        throw new Error("You must pass a selector to useSelector");
+      if (typeof r != "function")
+        throw new Error("You must pass a function as a selector to useSelector");
+      if (typeof a != "function")
+        throw new Error(
+          "You must pass a function as an equality function to useSelector"
+        );
+    }
+    const v = t(), { store: _, subscription: C, getServerState: P } = v, T = he.useRef(!0), I = he.useCallback(
+      {
+        [r.name](R) {
+          const d = r(R);
+          if (process.env.NODE_ENV !== "production") {
+            const { devModeChecks: S = {} } = typeof i == "function" ? {} : i, { identityFunctionCheck: p, stabilityCheck: w } = v, {
+              identityFunctionCheck: O,
+              stabilityCheck: f
+            } = {
+              stabilityCheck: w,
+              identityFunctionCheck: p,
+              ...S
+            };
+            if (f === "always" || f === "once" && T.current) {
+              const g = r(R);
+              if (!a(d, g)) {
+                let o;
+                try {
+                  throw new Error();
+                } catch (c) {
+                  ({ stack: o } = c);
+                }
+                console.warn(
+                  "Selector " + (r.name || "unknown") + ` returned a different result when called with the same parameters. This can lead to unnecessary rerenders.
+Selectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization`,
+                  {
+                    state: R,
+                    selected: d,
+                    selected2: g,
+                    stack: o
+                  }
+                );
+              }
+            }
+            if ((O === "always" || O === "once" && T.current) && d === R) {
+              let g;
+              try {
+                throw new Error();
+              } catch (o) {
+                ({ stack: g } = o);
+              }
+              console.warn(
+                "Selector " + (r.name || "unknown") + ` returned the root state when called. This can lead to unnecessary rerenders.
+Selectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.`,
+                { stack: g }
+              );
+            }
+            T.current && (T.current = !1);
+          }
+          return d;
+        }
+      }[r.name],
+      [r]
+    ), A = Vi.useSyncExternalStoreWithSelector(
+      C.addNestedSub,
+      _.getState,
+      P || _.getState,
+      I,
+      a
+    );
+    return he.useDebugValue(A), A;
+  };
+  return Object.assign(n, {
+    withTypes: () => n
+  }), n;
+}
+var Bi = /* @__PURE__ */ Wi(), Gi = zi;
+function at(e) {
+  return e.replace(e[0], e[0].toUpperCase());
+}
+function Yi(e) {
+  let t = 0;
+  for (const n in e)
+    t++;
+  return t;
+}
+var Ji = "query", Xi = "mutation", Zi = "infinitequery";
+function eo(e) {
+  return e.type === Ji;
+}
+function to(e) {
+  return e.type === Xi;
+}
+function mr(e) {
+  return e.type === Zi;
+}
+function Qe(e, ...t) {
+  return Object.assign(e, ...t);
+}
+var Tt = Symbol();
+function Dt(e) {
+  const t = fe(e), n = G(() => Zt(t.current, e), [e]);
+  return de(() => {
+    t.current !== n && (t.current = n);
+  }, [n]), n;
+}
+function Ie(e) {
+  const t = fe(e);
+  return de(() => {
+    ze(t.current, e) || (t.current = e);
+  }, [e]), ze(t.current, e) ? t.current : e;
+}
+var no = () => typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u", ro = /* @__PURE__ */ no(), io = () => typeof navigator < "u" && navigator.product === "ReactNative", oo = /* @__PURE__ */ io(), so = () => ro || oo ? Cr : de, co = /* @__PURE__ */ so(), xn = (e) => e.isUninitialized ? {
+  ...e,
+  isUninitialized: !1,
+  isFetching: !0,
+  isLoading: e.data === void 0,
+  // This is the one place where we still have to use `QueryStatus` as an enum,
+  // since it's the only reference in the React package and not in the core.
+  status: tr.pending
+} : e;
+function Nt(e, ...t) {
+  const n = {};
+  return t.forEach((r) => {
+    n[r] = e[r];
+  }), n;
+}
+var kt = ["data", "status", "isLoading", "isSuccess", "isError", "error"];
+function ao({
+  api: e,
+  moduleOptions: {
+    batch: t,
+    hooks: {
+      useDispatch: n,
+      useSelector: r,
+      useStore: i
+    },
+    unstable__sideEffectsInRender: a,
+    createSelector: v
+  },
+  serializeQueryArgs: _,
+  context: C
+}) {
+  const P = a ? (c) => c() : de, T = (c) => c.current?.unsubscribe?.(), I = C.endpointDefinitions;
+  return {
+    buildQueryHooks: f,
+    buildInfiniteQueryHooks: g,
+    buildMutationHook: o,
+    usePrefetch: d
+  };
+  function A(c, E, b) {
+    if (E?.endpointName && c.isUninitialized) {
+      const {
+        endpointName: m
+      } = E, N = I[m];
+      b !== te && _({
+        queryArgs: E.originalArgs,
+        endpointDefinition: N,
+        endpointName: m
+      }) === _({
+        queryArgs: b,
+        endpointDefinition: N,
+        endpointName: m
+      }) && (E = void 0);
+    }
+    let h = c.isSuccess ? c.data : E?.data;
+    h === void 0 && (h = c.data);
+    const l = h !== void 0, s = c.isLoading, u = (!E || E.isLoading || E.isUninitialized) && !l && s, y = c.isSuccess || l && (s && !E?.isError || c.isUninitialized);
+    return {
+      ...c,
+      data: h,
+      currentData: c.data,
+      isFetching: s,
+      isLoading: u,
+      isSuccess: y
+    };
+  }
+  function R(c, E, b) {
+    if (E?.endpointName && c.isUninitialized) {
+      const {
+        endpointName: m
+      } = E, N = I[m];
+      b !== te && _({
+        queryArgs: E.originalArgs,
+        endpointDefinition: N,
+        endpointName: m
+      }) === _({
+        queryArgs: b,
+        endpointDefinition: N,
+        endpointName: m
+      }) && (E = void 0);
+    }
+    let h = c.isSuccess ? c.data : E?.data;
+    h === void 0 && (h = c.data);
+    const l = h !== void 0, s = c.isLoading, u = (!E || E.isLoading || E.isUninitialized) && !l && s, y = c.isSuccess || s && l;
+    return {
+      ...c,
+      data: h,
+      currentData: c.data,
+      isFetching: s,
+      isLoading: u,
+      isSuccess: y
+    };
+  }
+  function d(c, E) {
+    const b = n(), h = Ie(E);
+    return ge((l, s) => b(e.util.prefetch(c, l, {
+      ...h,
+      ...s
+    })), [c, b, h]);
+  }
+  function S(c, E, {
+    refetchOnReconnect: b,
+    refetchOnFocus: h,
+    refetchOnMountOrArgChange: l,
+    skip: s = !1,
+    pollingInterval: u = 0,
+    skipPollingIfUnfocused: y = !1,
+    ...m
+  } = {}) {
+    const {
+      initiate: N
+    } = e.endpoints[c], M = n(), F = fe(void 0);
+    if (!F.current) {
+      const z = M(e.internalActions.internal_getRTKQSubscriptions());
+      if (process.env.NODE_ENV !== "production" && (typeof z != "object" || typeof z?.type == "string"))
+        throw new Error(process.env.NODE_ENV === "production" ? ye(37) : `Warning: Middleware for RTK-Query API at reducerPath "${e.reducerPath}" has not been added to the store.
+    You must add the middleware for RTK-Query to function correctly!`);
+      F.current = z;
+    }
+    const k = Dt(s ? te : E), D = Ie({
+      refetchOnReconnect: b,
+      refetchOnFocus: h,
+      pollingInterval: u,
+      skipPollingIfUnfocused: y
+    }), Q = m.initialPageParam, V = Ie(Q), L = m.refetchCachedPages, K = Ie(L), q = fe(void 0);
+    let {
+      queryCacheKey: j,
+      requestId: H
+    } = q.current || {}, U = !1;
+    j && H && (U = F.current.isRequestSubscribed(j, H));
+    const $ = !U && q.current !== void 0;
+    return P(() => {
+      $ && (q.current = void 0);
+    }, [$]), P(() => {
+      const z = q.current;
+      if (typeof process < "u" && process.env.NODE_ENV === "removeMeOnCompilation" && console.log($), k === te) {
+        z?.unsubscribe(), q.current = void 0;
+        return;
+      }
+      const x = q.current?.subscriptionOptions;
+      if (!z || z.arg !== k) {
+        z?.unsubscribe();
+        const ne = M(N(k, {
+          subscriptionOptions: D,
+          forceRefetch: l,
+          ...mr(I[c]) ? {
+            initialPageParam: V,
+            refetchCachedPages: K
+          } : {}
+        }));
+        q.current = ne;
+      } else D !== x && z.updateSubscriptionOptions(D);
+    }, [M, N, l, k, D, $, V, K, c]), [q, M, N, D];
+  }
+  function p(c, E) {
+    return (h, {
+      skip: l = !1,
+      selectFromResult: s
+    } = {}) => {
+      const {
+        select: u
+      } = e.endpoints[c], y = Dt(l ? te : h), m = fe(void 0), N = G(() => (
+        // Normally ts-ignores are bad and should be avoided, but we're
+        // already casting this selector to be `Selector<any>` anyway,
+        // so the inconsistencies don't matter here
+        // @ts-ignore
+        v([
+          // @ts-ignore
+          u(y),
+          (Q, V) => V,
+          (Q) => y
+        ], E, {
+          memoizeOptions: {
+            resultEqualityCheck: ze
+          }
+        })
+      ), [u, y]), M = G(() => s ? v([N], s, {
+        devModeChecks: {
+          identityFunctionCheck: "never"
+        }
+      }) : N, [N, s]), F = r((Q) => M(Q, m.current), ze), k = i(), D = N(k.getState(), m.current);
+      return co(() => {
+        m.current = D;
+      }, [D]), F;
+    };
+  }
+  function w(c) {
+    de(() => () => {
+      T(c), c.current = void 0;
+    }, [c]);
+  }
+  function O(c) {
+    if (!c.current) throw new Error(process.env.NODE_ENV === "production" ? ye(38) : "Cannot refetch a query that has not been started yet.");
+    return c.current.refetch();
+  }
+  function f(c) {
+    const E = (l, s = {}) => {
+      const [u] = S(c, l, s);
+      return w(u), G(() => ({
+        /**
+         * A method to manually refetch data for the query
+         */
+        refetch: () => O(u)
+      }), [u]);
+    }, b = ({
+      refetchOnReconnect: l,
+      refetchOnFocus: s,
+      pollingInterval: u = 0,
+      skipPollingIfUnfocused: y = !1
+    } = {}) => {
+      const {
+        initiate: m
+      } = e.endpoints[c], N = n(), [M, F] = un(Tt), k = fe(void 0), D = Ie({
+        refetchOnReconnect: l,
+        refetchOnFocus: s,
+        pollingInterval: u,
+        skipPollingIfUnfocused: y
+      });
+      P(() => {
+        const K = k.current?.subscriptionOptions;
+        D !== K && k.current?.updateSubscriptionOptions(D);
+      }, [D]);
+      const Q = fe(D);
+      P(() => {
+        Q.current = D;
+      }, [D]);
+      const V = ge(function(K, q = !1) {
+        let j;
+        return t(() => {
+          T(k), k.current = j = N(m(K, {
+            subscriptionOptions: Q.current,
+            forceRefetch: !q
+          })), F(K);
+        }), j;
+      }, [N, m]), L = ge(() => {
+        k.current?.queryCacheKey && N(e.internalActions.removeQueryResult({
+          queryCacheKey: k.current?.queryCacheKey
+        }));
+      }, [N]);
+      return de(() => () => {
+        T(k);
+      }, []), de(() => {
+        M !== Tt && !k.current && V(M, !0);
+      }, [M, V]), G(() => [V, M, {
+        reset: L
+      }], [V, M, L]);
+    }, h = p(c, A);
+    return {
+      useQueryState: h,
+      useQuerySubscription: E,
+      useLazyQuerySubscription: b,
+      useLazyQuery(l) {
+        const [s, u, {
+          reset: y
+        }] = b(l), m = h(u, {
+          ...l,
+          skip: u === Tt
+        }), N = G(() => ({
+          lastArg: u
+        }), [u]);
+        return G(() => [s, {
+          ...m,
+          reset: y
+        }, N], [s, m, y, N]);
+      },
+      useQuery(l, s) {
+        const u = E(l, s), y = h(l, {
+          selectFromResult: l === te || s?.skip ? void 0 : xn,
+          ...s
+        }), m = Nt(y, ...kt);
+        return Rt(m), G(() => ({
+          ...y,
+          ...u
+        }), [y, u]);
+      }
+    };
+  }
+  function g(c) {
+    const E = (h, l = {}) => {
+      const [s, u, y, m] = S(c, h, l), N = fe(m);
+      P(() => {
+        N.current = m;
+      }, [m]);
+      const M = l.refetchCachedPages, F = Ie(M), k = ge(function(V, L) {
+        let K;
+        return t(() => {
+          T(s), s.current = K = u(y(V, {
+            subscriptionOptions: N.current,
+            direction: L
+          }));
+        }), K;
+      }, [s, u, y]);
+      w(s);
+      const D = Dt(l.skip ? te : h), Q = ge((V) => {
+        if (!s.current) throw new Error(process.env.NODE_ENV === "production" ? ye(38) : "Cannot refetch a query that has not been started yet.");
+        const L = {
+          refetchCachedPages: V?.refetchCachedPages ?? F
+        };
+        return s.current.refetch(L);
+      }, [s, F]);
+      return G(() => ({
+        trigger: k,
+        /**
+         * A method to manually refetch data for the query
+         */
+        refetch: Q,
+        fetchNextPage: () => k(D, "forward"),
+        fetchPreviousPage: () => k(D, "backward")
+      }), [Q, k, D]);
+    }, b = p(c, R);
+    return {
+      useInfiniteQueryState: b,
+      useInfiniteQuerySubscription: E,
+      useInfiniteQuery(h, l) {
+        const {
+          refetch: s,
+          fetchNextPage: u,
+          fetchPreviousPage: y
+        } = E(h, l), m = b(h, {
+          selectFromResult: h === te || l?.skip ? void 0 : xn,
+          ...l
+        }), N = Nt(m, ...kt, "hasNextPage", "hasPreviousPage");
+        return Rt(N), G(() => ({
+          ...m,
+          fetchNextPage: u,
+          fetchPreviousPage: y,
+          refetch: s
+        }), [m, u, y, s]);
+      }
+    };
+  }
+  function o(c) {
+    return ({
+      selectFromResult: E,
+      fixedCacheKey: b
+    } = {}) => {
+      const {
+        select: h,
+        initiate: l
+      } = e.endpoints[c], s = n(), [u, y] = un();
+      de(() => () => {
+        u?.arg.fixedCacheKey || u?.reset();
+      }, [u]);
+      const m = ge(function(K) {
+        const q = s(l(K, {
+          fixedCacheKey: b
+        }));
+        return y(q), q;
+      }, [s, l, b]), {
+        requestId: N
+      } = u || {}, M = G(() => h({
+        fixedCacheKey: b,
+        requestId: u?.requestId
+      }), [b, u, h]), F = G(() => E ? v([M], E) : M, [E, M]), k = r(F, ze), D = b == null ? u?.arg.originalArgs : void 0, Q = ge(() => {
+        t(() => {
+          u && y(void 0), b && s(e.internalActions.removeMutationResult({
+            requestId: N,
+            fixedCacheKey: b
+          }));
+        });
+      }, [s, b, u, N]), V = Nt(k, ...kt, "endpointName");
+      Rt(V);
+      const L = G(() => ({
+        ...k,
+        originalArgs: D,
+        reset: Q
+      }), [k, D, Q]);
+      return G(() => [m, L], [m, L]);
+    };
+  }
+}
+var uo = /* @__PURE__ */ Symbol(), lo = ({
+  batch: e = Gi,
+  hooks: t = {
+    useDispatch: Ki,
+    useSelector: Bi,
+    useStore: gr
+  },
+  createSelector: n = er,
+  unstable__sideEffectsInRender: r = !1,
+  ...i
+} = {}) => {
+  if (process.env.NODE_ENV !== "production") {
+    const a = ["useDispatch", "useSelector", "useStore"];
+    let v = !1;
+    for (const _ of a)
+      if (Yi(i) > 0 && (i[_] && (v || (console.warn("As of RTK 2.0, the hooks now need to be specified as one object, provided under a `hooks` key:\n`reactHooksModule({ hooks: { useDispatch, useSelector, useStore } })`"), v = !0)), t[_] = i[_]), typeof t[_] != "function")
+        throw new Error(process.env.NODE_ENV === "production" ? ye(36) : `When using custom hooks for context, all ${a.length} hooks need to be provided: ${a.join(", ")}.
+Hook ${_} was either not provided or not a function.`);
+  }
+  return {
+    name: uo,
+    init(a, {
+      serializeQueryArgs: v
+    }, _) {
+      const C = a, {
+        buildQueryHooks: P,
+        buildInfiniteQueryHooks: T,
+        buildMutationHook: I,
+        usePrefetch: A
+      } = ao({
+        api: a,
+        moduleOptions: {
+          batch: e,
+          hooks: t,
+          unstable__sideEffectsInRender: r,
+          createSelector: n
+        },
+        serializeQueryArgs: v,
+        context: _
+      });
+      return Qe(C, {
+        usePrefetch: A
+      }), Qe(_, {
+        batch: e
+      }), {
+        injectEndpoint(R, d) {
+          if (eo(d)) {
+            const {
+              useQuery: S,
+              useLazyQuery: p,
+              useLazyQuerySubscription: w,
+              useQueryState: O,
+              useQuerySubscription: f
+            } = P(R);
+            Qe(C.endpoints[R], {
+              useQuery: S,
+              useLazyQuery: p,
+              useLazyQuerySubscription: w,
+              useQueryState: O,
+              useQuerySubscription: f
+            }), a[`use${at(R)}Query`] = S, a[`useLazy${at(R)}Query`] = p;
+          }
+          if (to(d)) {
+            const S = I(R);
+            Qe(C.endpoints[R], {
+              useMutation: S
+            }), a[`use${at(R)}Mutation`] = S;
+          } else if (mr(d)) {
+            const {
+              useInfiniteQuery: S,
+              useInfiniteQuerySubscription: p,
+              useInfiniteQueryState: w
+            } = T(R);
+            Qe(C.endpoints[R], {
+              useInfiniteQuery: S,
+              useInfiniteQuerySubscription: p,
+              useInfiniteQueryState: w
+            }), a[`use${at(R)}InfiniteQuery`] = S;
+          }
+        }
+      };
+    }
+  };
+}, fo = /* @__PURE__ */ dr(pr(), lo());
+const nt = "auth";
+let vr = null;
+function po() {
+  return vr;
+}
+function _o(e) {
+  vr = e;
+}
+const ho = {
+  token: null
+}, Sr = Se({
+  name: nt,
+  initialState: ho,
+  reducers: {
+    setToken: (e, t) => {
+      e.token = t.payload;
+    },
+    logout: (e) => {
+      e.token = null;
+    }
+  }
+}), { setToken: br, logout: Vn } = Sr.actions, Eo = Sr.reducer, wo = (e) => e[nt].token, Po = (e) => !!e[nt].token, yo = "api", wt = fo({
+  reducerPath: yo,
+  baseQuery: gi({
+    baseUrl: process.env.VITE_API_BASE_URL || "",
+    prepareHeaders: (e, { getState: t }) => {
+      const r = t()[nt], i = r ? r.token : void 0, a = po();
+      return i && (a ? a.prepareHeaders(e, i) : e.set("Authorization", `Bearer ${i}`)), e;
+    }
+  }),
+  endpoints: () => ({})
+}), Ro = wt.reducer, Oo = wt.middleware, _r = ["App", "Authentication"], Er = wt.enhanceEndpoints({
+  addTagTypes: _r
+}).injectEndpoints({
+  endpoints: (e) => ({
+    appControllerGetData: e.query({
+      query: () => ({ url: "/api" }),
+      providesTags: ["App"]
+    }),
+    authControllerLogin: e.mutation({
+      query: (t) => ({
+        url: "/api/auth/login",
+        method: "POST",
+        body: t.loginDto
+      }),
+      invalidatesTags: ["Authentication"]
+    }),
+    authControllerGetProfile: e.query({
+      query: () => ({ url: "/api/profile" }),
+      providesTags: ["Authentication"]
+    })
+  }),
+  overrideExisting: !1
+}), {
+  useAppControllerGetDataQuery: go,
+  useAuthControllerLoginMutation: mo,
+  useAuthControllerGetProfileQuery: vo
+} = Er, Io = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addTagTypes: _r,
+  api: Er,
+  useAppControllerGetDataQuery: go,
+  useAuthControllerGetProfileQuery: vo,
+  useAuthControllerLoginMutation: mo
+}, Symbol.toStringTag, { value: "Module" }));
+function Ao(e) {
+  return {
+    prepareHeaders(t, n) {
+      const r = e.formatValue ? e.formatValue(n) : n;
+      t.set(e.headerName, r);
+    }
+  };
+}
+let be = {};
+function Co(e) {
+  be = e;
+}
+function To() {
+  const e = Ar();
+  return e.startListening({
+    actionCreator: Vn,
+    effect: (t, n) => {
+      n.dispatch(wt.util.resetApiState()), be.onLogout && be.onLogout();
+    }
+  }), e.startListening({
+    matcher: $e(br, Vn),
+    effect: (t, n) => {
+      if (!be.persistence) return;
+      const r = n.getState();
+      be.persistence.setToken(r[nt].token);
+    }
+  }), e.middleware;
+}
+function Do() {
+  let e = !1;
+  return (t) => (n) => (r) => {
+    if (!e && be.persistence) {
+      e = !0;
+      const i = be.persistence.getToken();
+      i && t.dispatch(br(i));
+    }
+    return n(r);
+  };
+}
+function No(e, t = "token") {
+  return {
+    getToken: () => {
+      try {
+        return e.getItem(t);
+      } catch {
+        return null;
+      }
+    },
+    setToken: (n) => {
+      try {
+        n ? e.setItem(t, n) : e.removeItem(t);
+      } catch {
+      }
+    }
+  };
+}
+export {
+  yo as ApiKey,
+  nt as AuthKey,
+  _r as addTagTypes,
+  Er as api,
+  Oo as apiMiddleware,
+  Ro as apiReducer,
+  Eo as authReducer,
+  Sr as authSlice,
+  wt as baseApi,
+  Co as configureAuth,
+  Do as createAuthHydrationMiddleware,
+  To as createAuthListenerMiddleware,
+  Ao as createCustomHeaderAdapter,
+  Io as demoScaffoldBackend,
+  po as getAuthAdapter,
+  Vn as logout,
+  Po as selectIsAuthenticated,
+  wo as selectToken,
+  _o as setAuthAdapter,
+  br as setToken,
+  No as storagePersistence,
+  go as useAppControllerGetDataQuery,
+  vo as useAuthControllerGetProfileQuery,
+  mo as useAuthControllerLoginMutation
+};