@leancodepl/react-query-cqrs-client 9.7.2 → 9.7.4

package/dist/index.js

@@ -0,0 +1,2470 @@
+import * as R from "react";
+import "react/jsx-runtime";
+var ne = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(e) {
+    return this.listeners.add(e), this.onSubscribe(), () => {
+      this.listeners.delete(e), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+}, Et = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (e, t) => setTimeout(e, t),
+  clearTimeout: (e) => clearTimeout(e),
+  setInterval: (e, t) => setInterval(e, t),
+  clearInterval: (e) => clearInterval(e)
+}, St = class {
+  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+  // type at app boot; and if we leave that type, then any new timer provider
+  // would need to support ReturnType<typeof setTimeout>, which is infeasible.
+  //
+  // We settle for type safety for the TimeoutProvider type, and accept that
+  // this class is unsafe internally to allow for extension.
+  #t = Et;
+  #e = !1;
+  setTimeoutProvider(e) {
+    process.env.NODE_ENV !== "production" && this.#e && e !== this.#t && console.error(
+      "[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.",
+      { previous: this.#t, provider: e }
+    ), this.#t = e, process.env.NODE_ENV !== "production" && (this.#e = !1);
+  }
+  setTimeout(e, t) {
+    return process.env.NODE_ENV !== "production" && (this.#e = !0), this.#t.setTimeout(e, t);
+  }
+  clearTimeout(e) {
+    this.#t.clearTimeout(e);
+  }
+  setInterval(e, t) {
+    return process.env.NODE_ENV !== "production" && (this.#e = !0), this.#t.setInterval(e, t);
+  }
+  clearInterval(e) {
+    this.#t.clearInterval(e);
+  }
+}, X = new St();
+function Ot(e) {
+  setTimeout(e, 0);
+}
+var V = typeof window > "u" || "Deno" in globalThis;
+function Y() {
+}
+function ke(e) {
+  return typeof e == "number" && e >= 0 && e !== 1 / 0;
+}
+function Pt(e, t) {
+  return Math.max(e + (t || 0) - Date.now(), 0);
+}
+function B(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function F(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Ce(e) {
+  return JSON.stringify(
+    e,
+    (t, r) => fe(r) ? Object.keys(r).sort().reduce((n, i) => (n[i] = r[i], n), {}) : r
+  );
+}
+var Rt = Object.prototype.hasOwnProperty;
+function le(e, t) {
+  if (e === t)
+    return e;
+  const r = je(e) && je(t);
+  if (!r && !(fe(e) && fe(t))) return t;
+  const i = (r ? e : Object.keys(e)).length, s = r ? t : Object.keys(t), a = s.length, l = r ? new Array(a) : {};
+  let o = 0;
+  for (let c = 0; c < a; c++) {
+    const u = r ? c : s[c], f = e[u], h = t[u];
+    if (f === h) {
+      l[u] = f, (r ? c < i : Rt.call(e, u)) && o++;
+      continue;
+    }
+    if (f === null || h === null || typeof f != "object" || typeof h != "object") {
+      l[u] = h;
+      continue;
+    }
+    const d = le(f, h);
+    l[u] = d, d === f && o++;
+  }
+  return i === a && o === i ? e : l;
+}
+function Z(e, t) {
+  if (!t || Object.keys(e).length !== Object.keys(t).length)
+    return !1;
+  for (const r in e)
+    if (e[r] !== t[r])
+      return !1;
+  return !0;
+}
+function je(e) {
+  return Array.isArray(e) && e.length === Object.keys(e).length;
+}
+function fe(e) {
+  if (!Le(e))
+    return !1;
+  const t = e.constructor;
+  if (t === void 0)
+    return !0;
+  const r = t.prototype;
+  return !(!Le(r) || !r.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+}
+function Le(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function Me(e, t, r) {
+  if (typeof r.structuralSharing == "function")
+    return r.structuralSharing(e, t);
+  if (r.structuralSharing !== !1) {
+    if (process.env.NODE_ENV !== "production")
+      try {
+        return le(e, t);
+      } catch (n) {
+        throw console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${r.queryHash}]: ${n}`
+        ), n;
+      }
+    return le(e, t);
+  }
+  return t;
+}
+function Tt(e, t, r = 0) {
+  const n = [...e, t];
+  return r && n.length > r ? n.slice(1) : n;
+}
+function xt(e, t, r = 0) {
+  const n = [t, ...e];
+  return r && n.length > r ? n.slice(0, -1) : n;
+}
+var Qe = /* @__PURE__ */ Symbol();
+function It(e, t) {
+  return process.env.NODE_ENV !== "production" && e.queryFn === Qe && console.error(
+    `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${e.queryHash}'`
+  ), !e.queryFn && t?.initialPromise ? () => t.initialPromise : !e.queryFn || e.queryFn === Qe ? () => Promise.reject(new Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
+}
+function Xe(e, t) {
+  return typeof e == "function" ? e(...t) : !!e;
+}
+var At = class extends ne {
+  #t;
+  #e;
+  #r;
+  constructor() {
+    super(), this.#r = (e) => {
+      if (!V && window.addEventListener) {
+        const t = () => e();
+        return window.addEventListener("visibilitychange", t, !1), () => {
+          window.removeEventListener("visibilitychange", t);
+        };
+      }
+    };
+  }
+  onSubscribe() {
+    this.#e || this.setEventListener(this.#r);
+  }
+  onUnsubscribe() {
+    this.hasListeners() || (this.#e?.(), this.#e = void 0);
+  }
+  setEventListener(e) {
+    this.#r = e, this.#e?.(), this.#e = e((t) => {
+      typeof t == "boolean" ? this.setFocused(t) : this.onFocus();
+    });
+  }
+  setFocused(e) {
+    this.#t !== e && (this.#t = e, this.onFocus());
+  }
+  onFocus() {
+    const e = this.isFocused();
+    this.listeners.forEach((t) => {
+      t(e);
+    });
+  }
+  isFocused() {
+    return typeof this.#t == "boolean" ? this.#t : globalThis.document?.visibilityState !== "hidden";
+  }
+}, Ft = new At();
+function De() {
+  let e, t;
+  const r = new Promise((i, s) => {
+    e = i, t = s;
+  });
+  r.status = "pending", r.catch(() => {
+  });
+  function n(i) {
+    Object.assign(r, i), delete r.resolve, delete r.reject;
+  }
+  return r.resolve = (i) => {
+    n({
+      status: "fulfilled",
+      value: i
+    }), e(i);
+  }, r.reject = (i) => {
+    n({
+      status: "rejected",
+      reason: i
+    }), t(i);
+  }, r;
+}
+var kt = Ot;
+function Ct() {
+  let e = [], t = 0, r = (l) => {
+    l();
+  }, n = (l) => {
+    l();
+  }, i = kt;
+  const s = (l) => {
+    t ? e.push(l) : i(() => {
+      r(l);
+    });
+  }, a = () => {
+    const l = e;
+    e = [], l.length && i(() => {
+      n(() => {
+        l.forEach((o) => {
+          r(o);
+        });
+      });
+    });
+  };
+  return {
+    batch: (l) => {
+      let o;
+      t++;
+      try {
+        o = l();
+      } finally {
+        t--, t || a();
+      }
+      return o;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (l) => (...o) => {
+      s(() => {
+        l(...o);
+      });
+    },
+    schedule: s,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: (l) => {
+      r = l;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: (l) => {
+      n = l;
+    },
+    setScheduler: (l) => {
+      i = l;
+    }
+  };
+}
+var ie = Ct(), jt = class extends ne {
+  #t = !0;
+  #e;
+  #r;
+  constructor() {
+    super(), this.#r = (e) => {
+      if (!V && window.addEventListener) {
+        const t = () => e(!0), r = () => e(!1);
+        return window.addEventListener("online", t, !1), window.addEventListener("offline", r, !1), () => {
+          window.removeEventListener("online", t), window.removeEventListener("offline", r);
+        };
+      }
+    };
+  }
+  onSubscribe() {
+    this.#e || this.setEventListener(this.#r);
+  }
+  onUnsubscribe() {
+    this.hasListeners() || (this.#e?.(), this.#e = void 0);
+  }
+  setEventListener(e) {
+    this.#r = e, this.#e?.(), this.#e = e(this.setOnline.bind(this));
+  }
+  setOnline(e) {
+    this.#t !== e && (this.#t = e, this.listeners.forEach((r) => {
+      r(e);
+    }));
+  }
+  isOnline() {
+    return this.#t;
+  }
+}, Lt = new jt();
+function Mt(e) {
+  return (e ?? "online") === "online" ? Lt.isOnline() : !0;
+}
+function Qt(e, t) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: Mt(t.networkMode) ? "fetching" : "paused",
+    ...e === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+var We = class extends ne {
+  constructor(e, t) {
+    super(), this.options = t, this.#t = e, this.#a = null, this.#o = De(), this.bindMethods(), this.setOptions(t);
+  }
+  #t;
+  #e = void 0;
+  #r = void 0;
+  #n = void 0;
+  #i;
+  #s;
+  #o;
+  #a;
+  #v;
+  #h;
+  // This property keeps track of the last query with defined data.
+  // It will be used to pass the previous data and query to the placeholder function between renders.
+  #d;
+  #c;
+  #l;
+  #u;
+  #p = /* @__PURE__ */ new Set();
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (this.#e.addObserver(this), Ne(this.#e, this.options) ? this.#f() : this.updateResult(), this.#g());
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return he(
+      this.#e,
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return he(
+      this.#e,
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), this.#w(), this.#E(), this.#e.removeObserver(this);
+  }
+  setOptions(e) {
+    const t = this.options, r = this.#e;
+    if (this.options = this.#t.defaultQueryOptions(e), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof F(this.options.enabled, this.#e) != "boolean")
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    this.#S(), this.#e.setOptions(this.options), t._defaulted && !Z(this.options, t) && this.#t.getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: this.#e,
+      observer: this
+    });
+    const n = this.hasListeners();
+    n && Ue(
+      this.#e,
+      r,
+      this.options,
+      t
+    ) && this.#f(), this.updateResult(), n && (this.#e !== r || F(this.options.enabled, this.#e) !== F(t.enabled, this.#e) || B(this.options.staleTime, this.#e) !== B(t.staleTime, this.#e)) && this.#y();
+    const i = this.#m();
+    n && (this.#e !== r || F(this.options.enabled, this.#e) !== F(t.enabled, this.#e) || i !== this.#u) && this.#b(i);
+  }
+  getOptimisticResult(e) {
+    const t = this.#t.getQueryCache().build(this.#t, e), r = this.createResult(t, e);
+    return Nt(this, r) && (this.#n = r, this.#s = this.options, this.#i = this.#e.state), r;
+  }
+  getCurrentResult() {
+    return this.#n;
+  }
+  trackResult(e, t) {
+    return new Proxy(e, {
+      get: (r, n) => (this.trackProp(n), t?.(n), n === "promise" && !this.options.experimental_prefetchInRender && this.#o.status === "pending" && this.#o.reject(
+        new Error(
+          "experimental_prefetchInRender feature flag is not enabled"
+        )
+      ), Reflect.get(r, n))
+    });
+  }
+  trackProp(e) {
+    this.#p.add(e);
+  }
+  getCurrentQuery() {
+    return this.#e;
+  }
+  refetch({ ...e } = {}) {
+    return this.fetch({
+      ...e
+    });
+  }
+  fetchOptimistic(e) {
+    const t = this.#t.defaultQueryOptions(e), r = this.#t.getQueryCache().build(this.#t, t);
+    return r.fetch().then(() => this.createResult(r, t));
+  }
+  fetch(e) {
+    return this.#f({
+      ...e,
+      cancelRefetch: e.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), this.#n));
+  }
+  #f(e) {
+    this.#S();
+    let t = this.#e.fetch(
+      this.options,
+      e
+    );
+    return e?.throwOnError || (t = t.catch(Y)), t;
+  }
+  #y() {
+    this.#w();
+    const e = B(
+      this.options.staleTime,
+      this.#e
+    );
+    if (V || this.#n.isStale || !ke(e))
+      return;
+    const r = Pt(this.#n.dataUpdatedAt, e) + 1;
+    this.#c = X.setTimeout(() => {
+      this.#n.isStale || this.updateResult();
+    }, r);
+  }
+  #m() {
+    return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(this.#e) : this.options.refetchInterval) ?? !1;
+  }
+  #b(e) {
+    this.#E(), this.#u = e, !(V || F(this.options.enabled, this.#e) === !1 || !ke(this.#u) || this.#u === 0) && (this.#l = X.setInterval(() => {
+      (this.options.refetchIntervalInBackground || Ft.isFocused()) && this.#f();
+    }, this.#u));
+  }
+  #g() {
+    this.#y(), this.#b(this.#m());
+  }
+  #w() {
+    this.#c && (X.clearTimeout(this.#c), this.#c = void 0);
+  }
+  #E() {
+    this.#l && (X.clearInterval(this.#l), this.#l = void 0);
+  }
+  createResult(e, t) {
+    const r = this.#e, n = this.options, i = this.#n, s = this.#i, a = this.#s, o = e !== r ? e.state : this.#r, { state: c } = e;
+    let u = { ...c }, f = !1, h;
+    if (t._optimisticResults) {
+      const T = this.hasListeners(), _ = !T && Ne(e, t), k = T && Ue(e, r, t, n);
+      (_ || k) && (u = {
+        ...u,
+        ...Qt(c.data, e.options)
+      }), t._optimisticResults === "isRestoring" && (u.fetchStatus = "idle");
+    }
+    let { error: d, errorUpdatedAt: v, status: p } = u;
+    h = u.data;
+    let S = !1;
+    if (t.placeholderData !== void 0 && h === void 0 && p === "pending") {
+      let T;
+      i?.isPlaceholderData && t.placeholderData === a?.placeholderData ? (T = i.data, S = !0) : T = typeof t.placeholderData == "function" ? t.placeholderData(
+        this.#d?.state.data,
+        this.#d
+      ) : t.placeholderData, T !== void 0 && (p = "success", h = Me(
+        i?.data,
+        T,
+        t
+      ), f = !0);
+    }
+    if (t.select && h !== void 0 && !S)
+      if (i && h === s?.data && t.select === this.#v)
+        h = this.#h;
+      else
+        try {
+          this.#v = t.select, h = t.select(h), h = Me(i?.data, h, t), this.#h = h, this.#a = null;
+        } catch (T) {
+          this.#a = T;
+        }
+    this.#a && (d = this.#a, h = this.#h, v = Date.now(), p = "error");
+    const g = u.fetchStatus === "fetching", P = p === "pending", w = p === "error", y = P && g, m = h !== void 0, A = {
+      status: p,
+      fetchStatus: u.fetchStatus,
+      isPending: P,
+      isSuccess: p === "success",
+      isError: w,
+      isInitialLoading: y,
+      isLoading: y,
+      data: h,
+      dataUpdatedAt: u.dataUpdatedAt,
+      error: d,
+      errorUpdatedAt: v,
+      failureCount: u.fetchFailureCount,
+      failureReason: u.fetchFailureReason,
+      errorUpdateCount: u.errorUpdateCount,
+      isFetched: u.dataUpdateCount > 0 || u.errorUpdateCount > 0,
+      isFetchedAfterMount: u.dataUpdateCount > o.dataUpdateCount || u.errorUpdateCount > o.errorUpdateCount,
+      isFetching: g,
+      isRefetching: g && !P,
+      isLoadingError: w && !m,
+      isPaused: u.fetchStatus === "paused",
+      isPlaceholderData: f,
+      isRefetchError: w && m,
+      isStale: me(e, t),
+      refetch: this.refetch,
+      promise: this.#o,
+      isEnabled: F(t.enabled, e) !== !1
+    };
+    if (this.options.experimental_prefetchInRender) {
+      const T = (L) => {
+        A.status === "error" ? L.reject(A.error) : A.data !== void 0 && L.resolve(A.data);
+      }, _ = () => {
+        const L = this.#o = A.promise = De();
+        T(L);
+      }, k = this.#o;
+      switch (k.status) {
+        case "pending":
+          e.queryHash === r.queryHash && T(k);
+          break;
+        case "fulfilled":
+          (A.status === "error" || A.data !== k.value) && _();
+          break;
+        case "rejected":
+          (A.status !== "error" || A.error !== k.reason) && _();
+          break;
+      }
+    }
+    return A;
+  }
+  updateResult() {
+    const e = this.#n, t = this.createResult(this.#e, this.options);
+    if (this.#i = this.#e.state, this.#s = this.options, this.#i.data !== void 0 && (this.#d = this.#e), Z(t, e))
+      return;
+    this.#n = t;
+    const r = () => {
+      if (!e)
+        return !0;
+      const { notifyOnChangeProps: n } = this.options, i = typeof n == "function" ? n() : n;
+      if (i === "all" || !i && !this.#p.size)
+        return !0;
+      const s = new Set(
+        i ?? this.#p
+      );
+      return this.options.throwOnError && s.add("error"), Object.keys(this.#n).some((a) => {
+        const l = a;
+        return this.#n[l] !== e[l] && s.has(l);
+      });
+    };
+    this.#O({ listeners: r() });
+  }
+  #S() {
+    const e = this.#t.getQueryCache().build(this.#t, this.options);
+    if (e === this.#e)
+      return;
+    const t = this.#e;
+    this.#e = e, this.#r = e.state, this.hasListeners() && (t?.removeObserver(this), e.addObserver(this));
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && this.#g();
+  }
+  #O(e) {
+    ie.batch(() => {
+      e.listeners && this.listeners.forEach((t) => {
+        t(this.#n);
+      }), this.#t.getQueryCache().notify({
+        query: this.#e,
+        type: "observerResultsUpdated"
+      });
+    });
+  }
+};
+function Dt(e, t) {
+  return F(t.enabled, e) !== !1 && e.state.data === void 0 && !(e.state.status === "error" && t.retryOnMount === !1);
+}
+function Ne(e, t) {
+  return Dt(e, t) || e.state.data !== void 0 && he(e, t, t.refetchOnMount);
+}
+function he(e, t, r) {
+  if (F(t.enabled, e) !== !1 && B(t.staleTime, e) !== "static") {
+    const n = typeof r == "function" ? r(e) : r;
+    return n === "always" || n !== !1 && me(e, t);
+  }
+  return !1;
+}
+function Ue(e, t, r, n) {
+  return (e !== t || F(n.enabled, e) === !1) && (!r.suspense || e.state.status !== "error") && me(e, r);
+}
+function me(e, t) {
+  return F(t.enabled, e) !== !1 && e.isStaleByTime(B(t.staleTime, e));
+}
+function Nt(e, t) {
+  return !Z(e.getCurrentResult(), t);
+}
+function _e(e) {
+  return {
+    onFetch: (t, r) => {
+      const n = t.options, i = t.fetchOptions?.meta?.fetchMore?.direction, s = t.state.data?.pages || [], a = t.state.data?.pageParams || [];
+      let l = { pages: [], pageParams: [] }, o = 0;
+      const c = async () => {
+        let u = !1;
+        const f = (v) => {
+          Object.defineProperty(v, "signal", {
+            enumerable: !0,
+            get: () => (t.signal.aborted ? u = !0 : t.signal.addEventListener("abort", () => {
+              u = !0;
+            }), t.signal)
+          });
+        }, h = It(t.options, t.fetchOptions), d = async (v, p, S) => {
+          if (u)
+            return Promise.reject();
+          if (p == null && v.pages.length)
+            return Promise.resolve(v);
+          const P = (() => {
+            const j = {
+              client: t.client,
+              queryKey: t.queryKey,
+              pageParam: p,
+              direction: S ? "backward" : "forward",
+              meta: t.options.meta
+            };
+            return f(j), j;
+          })(), w = await h(P), { maxPages: y } = t.options, m = S ? xt : Tt;
+          return {
+            pages: m(v.pages, w, y),
+            pageParams: m(v.pageParams, p, y)
+          };
+        };
+        if (i && s.length) {
+          const v = i === "backward", p = v ? Ye : de, S = {
+            pages: s,
+            pageParams: a
+          }, g = p(n, S);
+          l = await d(S, g, v);
+        } else {
+          const v = s.length;
+          do {
+            const p = o === 0 ? a[0] ?? n.initialPageParam : de(n, l);
+            if (o > 0 && p == null)
+              break;
+            l = await d(l, p), o++;
+          } while (o < v);
+        }
+        return l;
+      };
+      t.options.persister ? t.fetchFn = () => t.options.persister?.(
+        c,
+        {
+          client: t.client,
+          queryKey: t.queryKey,
+          meta: t.options.meta,
+          signal: t.signal
+        },
+        r
+      ) : t.fetchFn = c;
+    }
+  };
+}
+function de(e, { pages: t, pageParams: r }) {
+  const n = t.length - 1;
+  return t.length > 0 ? e.getNextPageParam(
+    t[n],
+    t,
+    r[n],
+    r
+  ) : void 0;
+}
+function Ye(e, { pages: t, pageParams: r }) {
+  return t.length > 0 ? e.getPreviousPageParam?.(t[0], t, r[0], r) : void 0;
+}
+function Ut(e, t) {
+  return t ? de(e, t) != null : !1;
+}
+function _t(e, t) {
+  return !t || !e.getPreviousPageParam ? !1 : Ye(e, t) != null;
+}
+var qt = class extends We {
+  constructor(e, t) {
+    super(e, t);
+  }
+  bindMethods() {
+    super.bindMethods(), this.fetchNextPage = this.fetchNextPage.bind(this), this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
+  }
+  setOptions(e) {
+    super.setOptions({
+      ...e,
+      behavior: _e()
+    });
+  }
+  getOptimisticResult(e) {
+    return e.behavior = _e(), super.getOptimisticResult(e);
+  }
+  fetchNextPage(e) {
+    return this.fetch({
+      ...e,
+      meta: {
+        fetchMore: { direction: "forward" }
+      }
+    });
+  }
+  fetchPreviousPage(e) {
+    return this.fetch({
+      ...e,
+      meta: {
+        fetchMore: { direction: "backward" }
+      }
+    });
+  }
+  createResult(e, t) {
+    const { state: r } = e, n = super.createResult(e, t), { isFetching: i, isRefetching: s, isError: a, isRefetchError: l } = n, o = r.fetchMeta?.fetchMore?.direction, c = a && o === "forward", u = i && o === "forward", f = a && o === "backward", h = i && o === "backward";
+    return {
+      ...n,
+      fetchNextPage: this.fetchNextPage,
+      fetchPreviousPage: this.fetchPreviousPage,
+      hasNextPage: Ut(t, r.data),
+      hasPreviousPage: _t(t, r.data),
+      isFetchNextPageError: c,
+      isFetchingNextPage: u,
+      isFetchPreviousPageError: f,
+      isFetchingPreviousPage: h,
+      isRefetchError: l && !c && !f,
+      isRefetching: s && !u && !h
+    };
+  }
+};
+function Ht() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+var Bt = class extends ne {
+  #t;
+  #e = void 0;
+  #r;
+  #n;
+  constructor(e, t) {
+    super(), this.#t = e, this.setOptions(t), this.bindMethods(), this.#i();
+  }
+  bindMethods() {
+    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
+  }
+  setOptions(e) {
+    const t = this.options;
+    this.options = this.#t.defaultMutationOptions(e), Z(this.options, t) || this.#t.getMutationCache().notify({
+      type: "observerOptionsUpdated",
+      mutation: this.#r,
+      observer: this
+    }), t?.mutationKey && this.options.mutationKey && Ce(t.mutationKey) !== Ce(this.options.mutationKey) ? this.reset() : this.#r?.state.status === "pending" && this.#r.setOptions(this.options);
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.#r?.removeObserver(this);
+  }
+  onMutationUpdate(e) {
+    this.#i(), this.#s(e);
+  }
+  getCurrentResult() {
+    return this.#e;
+  }
+  reset() {
+    this.#r?.removeObserver(this), this.#r = void 0, this.#i(), this.#s();
+  }
+  mutate(e, t) {
+    return this.#n = t, this.#r?.removeObserver(this), this.#r = this.#t.getMutationCache().build(this.#t, this.options), this.#r.addObserver(this), this.#r.execute(e);
+  }
+  #i() {
+    const e = this.#r?.state ?? Ht();
+    this.#e = {
+      ...e,
+      isPending: e.status === "pending",
+      isSuccess: e.status === "success",
+      isError: e.status === "error",
+      isIdle: e.status === "idle",
+      mutate: this.mutate,
+      reset: this.reset
+    };
+  }
+  #s(e) {
+    ie.batch(() => {
+      if (this.#n && this.hasListeners()) {
+        const t = this.#e.variables, r = this.#e.context, n = {
+          client: this.#t,
+          meta: this.options.meta,
+          mutationKey: this.options.mutationKey
+        };
+        e?.type === "success" ? (this.#n.onSuccess?.(
+          e.data,
+          t,
+          r,
+          n
+        ), this.#n.onSettled?.(
+          e.data,
+          null,
+          t,
+          r,
+          n
+        )) : e?.type === "error" && (this.#n.onError?.(
+          e.error,
+          t,
+          r,
+          n
+        ), this.#n.onSettled?.(
+          void 0,
+          e.error,
+          t,
+          r,
+          n
+        ));
+      }
+      this.listeners.forEach((t) => {
+        t(this.#e);
+      });
+    });
+  }
+}, Kt = R.createContext(
+  void 0
+), Ze = (e) => {
+  const t = R.useContext(Kt);
+  if (e)
+    return e;
+  if (!t)
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  return t;
+}, et = R.createContext(!1), Vt = () => R.useContext(et);
+et.Provider;
+function $t() {
+  let e = !1;
+  return {
+    clearReset: () => {
+      e = !1;
+    },
+    reset: () => {
+      e = !0;
+    },
+    isReset: () => e
+  };
+}
+var zt = R.createContext($t()), Gt = () => R.useContext(zt), Jt = (e, t) => {
+  (e.suspense || e.throwOnError || e.experimental_prefetchInRender) && (t.isReset() || (e.retryOnMount = !1));
+}, Xt = (e) => {
+  R.useEffect(() => {
+    e.clearReset();
+  }, [e]);
+}, Wt = ({
+  result: e,
+  errorResetBoundary: t,
+  throwOnError: r,
+  query: n,
+  suspense: i
+}) => e.isError && !t.isReset() && !e.isFetching && n && (i && e.data === void 0 || Xe(r, [e.error, n])), Yt = (e) => {
+  if (e.suspense) {
+    const r = (i) => i === "static" ? i : Math.max(i ?? 1e3, 1e3), n = e.staleTime;
+    e.staleTime = typeof n == "function" ? (...i) => r(n(...i)) : r(n), typeof e.gcTime == "number" && (e.gcTime = Math.max(
+      e.gcTime,
+      1e3
+    ));
+  }
+}, Zt = (e, t) => e.isLoading && e.isFetching && !t, er = (e, t) => e?.suspense && t.isPending, qe = (e, t, r) => t.fetchOptimistic(e).catch(() => {
+  r.clearReset();
+});
+function tt(e, t, r) {
+  if (process.env.NODE_ENV !== "production" && (typeof e != "object" || Array.isArray(e)))
+    throw new Error(
+      'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+    );
+  const n = Vt(), i = Gt(), s = Ze(r), a = s.defaultQueryOptions(e);
+  s.getDefaultOptions().queries?._experimental_beforeQuery?.(
+    a
+  ), process.env.NODE_ENV !== "production" && (a.queryFn || console.error(
+    `[${a.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
+  )), a._optimisticResults = n ? "isRestoring" : "optimistic", Yt(a), Jt(a, i), Xt(i);
+  const l = !s.getQueryCache().get(a.queryHash), [o] = R.useState(
+    () => new t(
+      s,
+      a
+    )
+  ), c = o.getOptimisticResult(a), u = !n && e.subscribed !== !1;
+  if (R.useSyncExternalStore(
+    R.useCallback(
+      (f) => {
+        const h = u ? o.subscribe(ie.batchCalls(f)) : Y;
+        return o.updateResult(), h;
+      },
+      [o, u]
+    ),
+    () => o.getCurrentResult(),
+    () => o.getCurrentResult()
+  ), R.useEffect(() => {
+    o.setOptions(a);
+  }, [a, o]), er(a, c))
+    throw qe(a, o, i);
+  if (Wt({
+    result: c,
+    errorResetBoundary: i,
+    throwOnError: a.throwOnError,
+    query: s.getQueryCache().get(a.queryHash),
+    suspense: a.suspense
+  }))
+    throw c.error;
+  return s.getDefaultOptions().queries?._experimental_afterQuery?.(
+    a,
+    c
+  ), a.experimental_prefetchInRender && !V && Zt(c, n) && (l ? (
+    // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+    qe(a, o, i)
+  ) : (
+    // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+    s.getQueryCache().get(a.queryHash)?.promise
+  ))?.catch(Y).finally(() => {
+    o.updateResult();
+  }), a.notifyOnChangeProps ? c : o.trackResult(c);
+}
+function tr(e, t) {
+  return tt(e, We, t);
+}
+function oe(e, t) {
+  const r = Ze(t), [n] = R.useState(
+    () => new Bt(
+      r,
+      e
+    )
+  );
+  R.useEffect(() => {
+    n.setOptions(e);
+  }, [n, e]);
+  const i = R.useSyncExternalStore(
+    R.useCallback(
+      (a) => n.subscribe(ie.batchCalls(a)),
+      [n]
+    ),
+    () => n.getCurrentResult(),
+    () => n.getCurrentResult()
+  ), s = R.useCallback(
+    (a, l) => {
+      n.mutate(a, l).catch(Y);
+    },
+    [n]
+  );
+  if (i.error && Xe(n.options.throwOnError, [i.error]))
+    throw i.error;
+  return { ...i, mutate: s, mutateAsync: i.mutate };
+}
+function rr(e, t) {
+  return tt(
+    e,
+    qt,
+    t
+  );
+}
+var pe = function(e, t) {
+  return pe = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+    r.__proto__ = n;
+  } || function(r, n) {
+    for (var i in n) Object.prototype.hasOwnProperty.call(n, i) && (r[i] = n[i]);
+  }, pe(e, t);
+};
+function be(e, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+  pe(e, t);
+  function r() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+}
+var K = function() {
+  return K = Object.assign || function(t) {
+    for (var r, n = 1, i = arguments.length; n < i; n++) {
+      r = arguments[n];
+      for (var s in r) Object.prototype.hasOwnProperty.call(r, s) && (t[s] = r[s]);
+    }
+    return t;
+  }, K.apply(this, arguments);
+};
+function nr(e, t, r, n) {
+  function i(s) {
+    return s instanceof r ? s : new r(function(a) {
+      a(s);
+    });
+  }
+  return new (r || (r = Promise))(function(s, a) {
+    function l(u) {
+      try {
+        c(n.next(u));
+      } catch (f) {
+        a(f);
+      }
+    }
+    function o(u) {
+      try {
+        c(n.throw(u));
+      } catch (f) {
+        a(f);
+      }
+    }
+    function c(u) {
+      u.done ? s(u.value) : i(u.value).then(l, o);
+    }
+    c((n = n.apply(e, t || [])).next());
+  });
+}
+function rt(e, t) {
+  var r = { label: 0, sent: function() {
+    if (s[0] & 1) throw s[1];
+    return s[1];
+  }, trys: [], ops: [] }, n, i, s, a = Object.create((typeof Iterator == "function" ? Iterator : Object).prototype);
+  return a.next = l(0), a.throw = l(1), a.return = l(2), typeof Symbol == "function" && (a[Symbol.iterator] = function() {
+    return this;
+  }), a;
+  function l(c) {
+    return function(u) {
+      return o([c, u]);
+    };
+  }
+  function o(c) {
+    if (n) throw new TypeError("Generator is already executing.");
+    for (; a && (a = 0, c[0] && (r = 0)), r; ) try {
+      if (n = 1, i && (s = c[0] & 2 ? i.return : c[0] ? i.throw || ((s = i.return) && s.call(i), 0) : i.next) && !(s = s.call(i, c[1])).done) return s;
+      switch (i = 0, s && (c = [c[0] & 2, s.value]), c[0]) {
+        case 0:
+        case 1:
+          s = c;
+          break;
+        case 4:
+          return r.label++, { value: c[1], done: !1 };
+        case 5:
+          r.label++, i = c[1], c = [0];
+          continue;
+        case 7:
+          c = r.ops.pop(), r.trys.pop();
+          continue;
+        default:
+          if (s = r.trys, !(s = s.length > 0 && s[s.length - 1]) && (c[0] === 6 || c[0] === 2)) {
+            r = 0;
+            continue;
+          }
+          if (c[0] === 3 && (!s || c[1] > s[0] && c[1] < s[3])) {
+            r.label = c[1];
+            break;
+          }
+          if (c[0] === 6 && r.label < s[1]) {
+            r.label = s[1], s = c;
+            break;
+          }
+          if (s && r.label < s[2]) {
+            r.label = s[2], r.ops.push(c);
+            break;
+          }
+          s[2] && r.ops.pop(), r.trys.pop();
+          continue;
+      }
+      c = t.call(e, r);
+    } catch (u) {
+      c = [6, u], i = 0;
+    } finally {
+      n = s = 0;
+    }
+    if (c[0] & 5) throw c[1];
+    return { value: c[0] ? c[1] : void 0, done: !0 };
+  }
+}
+function $(e) {
+  var t = typeof Symbol == "function" && Symbol.iterator, r = t && e[t], n = 0;
+  if (r) return r.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && n >= e.length && (e = void 0), { value: e && e[n++], done: !e };
+    }
+  };
+  throw new TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function z(e, t) {
+  var r = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!r) return e;
+  var n = r.call(e), i, s = [], a;
+  try {
+    for (; (t === void 0 || t-- > 0) && !(i = n.next()).done; ) s.push(i.value);
+  } catch (l) {
+    a = { error: l };
+  } finally {
+    try {
+      i && !i.done && (r = n.return) && r.call(n);
+    } finally {
+      if (a) throw a.error;
+    }
+  }
+  return s;
+}
+function ee(e, t, r) {
+  if (r || arguments.length === 2) for (var n = 0, i = t.length, s; n < i; n++)
+    (s || !(n in t)) && (s || (s = Array.prototype.slice.call(t, 0, n)), s[n] = t[n]);
+  return e.concat(s || Array.prototype.slice.call(t));
+}
+function q(e) {
+  return this instanceof q ? (this.v = e, this) : new q(e);
+}
+function ir(e, t, r) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var n = r.apply(e, t || []), i, s = [];
+  return i = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), l("next"), l("throw"), l("return", a), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function a(d) {
+    return function(v) {
+      return Promise.resolve(v).then(d, f);
+    };
+  }
+  function l(d, v) {
+    n[d] && (i[d] = function(p) {
+      return new Promise(function(S, g) {
+        s.push([d, p, S, g]) > 1 || o(d, p);
+      });
+    }, v && (i[d] = v(i[d])));
+  }
+  function o(d, v) {
+    try {
+      c(n[d](v));
+    } catch (p) {
+      h(s[0][3], p);
+    }
+  }
+  function c(d) {
+    d.value instanceof q ? Promise.resolve(d.value.v).then(u, f) : h(s[0][2], d);
+  }
+  function u(d) {
+    o("next", d);
+  }
+  function f(d) {
+    o("throw", d);
+  }
+  function h(d, v) {
+    d(v), s.shift(), s.length && o(s[0][0], s[0][1]);
+  }
+}
+function sr(e) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var t = e[Symbol.asyncIterator], r;
+  return t ? t.call(e) : (e = typeof $ == "function" ? $(e) : e[Symbol.iterator](), r = {}, n("next"), n("throw"), n("return"), r[Symbol.asyncIterator] = function() {
+    return this;
+  }, r);
+  function n(s) {
+    r[s] = e[s] && function(a) {
+      return new Promise(function(l, o) {
+        a = e[s](a), i(l, o, a.done, a.value);
+      });
+    };
+  }
+  function i(s, a, l, o) {
+    Promise.resolve(o).then(function(c) {
+      s({ value: c, done: l });
+    }, a);
+  }
+}
+function b(e) {
+  return typeof e == "function";
+}
+function ge(e) {
+  var t = function(n) {
+    Error.call(n), n.stack = new Error().stack;
+  }, r = e(t);
+  return r.prototype = Object.create(Error.prototype), r.prototype.constructor = r, r;
+}
+var ae = ge(function(e) {
+  return function(r) {
+    e(this), this.message = r ? r.length + ` errors occurred during unsubscription:
+` + r.map(function(n, i) {
+      return i + 1 + ") " + n.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = r;
+  };
+});
+function He(e, t) {
+  if (e) {
+    var r = e.indexOf(t);
+    0 <= r && e.splice(r, 1);
+  }
+}
+var we = (function() {
+  function e(t) {
+    this.initialTeardown = t, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var t, r, n, i, s;
+    if (!this.closed) {
+      this.closed = !0;
+      var a = this._parentage;
+      if (a)
+        if (this._parentage = null, Array.isArray(a))
+          try {
+            for (var l = $(a), o = l.next(); !o.done; o = l.next()) {
+              var c = o.value;
+              c.remove(this);
+            }
+          } catch (p) {
+            t = { error: p };
+          } finally {
+            try {
+              o && !o.done && (r = l.return) && r.call(l);
+            } finally {
+              if (t) throw t.error;
+            }
+          }
+        else
+          a.remove(this);
+      var u = this.initialTeardown;
+      if (b(u))
+        try {
+          u();
+        } catch (p) {
+          s = p instanceof ae ? p.errors : [p];
+        }
+      var f = this._finalizers;
+      if (f) {
+        this._finalizers = null;
+        try {
+          for (var h = $(f), d = h.next(); !d.done; d = h.next()) {
+            var v = d.value;
+            try {
+              Be(v);
+            } catch (p) {
+              s = s ?? [], p instanceof ae ? s = ee(ee([], z(s)), z(p.errors)) : s.push(p);
+            }
+          }
+        } catch (p) {
+          n = { error: p };
+        } finally {
+          try {
+            d && !d.done && (i = h.return) && i.call(h);
+          } finally {
+            if (n) throw n.error;
+          }
+        }
+      }
+      if (s)
+        throw new ae(s);
+    }
+  }, e.prototype.add = function(t) {
+    var r;
+    if (t && t !== this)
+      if (this.closed)
+        Be(t);
+      else {
+        if (t instanceof e) {
+          if (t.closed || t._hasParent(this))
+            return;
+          t._addParent(this);
+        }
+        (this._finalizers = (r = this._finalizers) !== null && r !== void 0 ? r : []).push(t);
+      }
+  }, e.prototype._hasParent = function(t) {
+    var r = this._parentage;
+    return r === t || Array.isArray(r) && r.includes(t);
+  }, e.prototype._addParent = function(t) {
+    var r = this._parentage;
+    this._parentage = Array.isArray(r) ? (r.push(t), r) : r ? [r, t] : t;
+  }, e.prototype._removeParent = function(t) {
+    var r = this._parentage;
+    r === t ? this._parentage = null : Array.isArray(r) && He(r, t);
+  }, e.prototype.remove = function(t) {
+    var r = this._finalizers;
+    r && He(r, t), t instanceof e && t._removeParent(this);
+  }, e.EMPTY = (function() {
+    var t = new e();
+    return t.closed = !0, t;
+  })(), e;
+})();
+we.EMPTY;
+function nt(e) {
+  return e instanceof we || e && "closed" in e && b(e.remove) && b(e.add) && b(e.unsubscribe);
+}
+function Be(e) {
+  b(e) ? e() : e.unsubscribe();
+}
+var or = {
+  Promise: void 0
+}, ar = {
+  setTimeout: function(e, t) {
+    for (var r = [], n = 2; n < arguments.length; n++)
+      r[n - 2] = arguments[n];
+    return setTimeout.apply(void 0, ee([e, t], z(r)));
+  },
+  clearTimeout: function(e) {
+    return clearTimeout(e);
+  },
+  delegate: void 0
+};
+function it(e) {
+  ar.setTimeout(function() {
+    throw e;
+  });
+}
+function Ke() {
+}
+function ur(e) {
+  e();
+}
+var Ee = (function(e) {
+  be(t, e);
+  function t(r) {
+    var n = e.call(this) || this;
+    return n.isStopped = !1, r ? (n.destination = r, nt(r) && r.add(n)) : n.destination = fr, n;
+  }
+  return t.create = function(r, n, i) {
+    return new te(r, n, i);
+  }, t.prototype.next = function(r) {
+    this.isStopped || this._next(r);
+  }, t.prototype.error = function(r) {
+    this.isStopped || (this.isStopped = !0, this._error(r));
+  }, t.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, t.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, t.prototype._next = function(r) {
+    this.destination.next(r);
+  }, t.prototype._error = function(r) {
+    try {
+      this.destination.error(r);
+    } finally {
+      this.unsubscribe();
+    }
+  }, t.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, t;
+})(we), cr = (function() {
+  function e(t) {
+    this.partialObserver = t;
+  }
+  return e.prototype.next = function(t) {
+    var r = this.partialObserver;
+    if (r.next)
+      try {
+        r.next(t);
+      } catch (n) {
+        W(n);
+      }
+  }, e.prototype.error = function(t) {
+    var r = this.partialObserver;
+    if (r.error)
+      try {
+        r.error(t);
+      } catch (n) {
+        W(n);
+      }
+    else
+      W(t);
+  }, e.prototype.complete = function() {
+    var t = this.partialObserver;
+    if (t.complete)
+      try {
+        t.complete();
+      } catch (r) {
+        W(r);
+      }
+  }, e;
+})(), te = (function(e) {
+  be(t, e);
+  function t(r, n, i) {
+    var s = e.call(this) || this, a;
+    return b(r) || !r ? a = {
+      next: r ?? void 0,
+      error: n ?? void 0,
+      complete: i ?? void 0
+    } : a = r, s.destination = new cr(a), s;
+  }
+  return t;
+})(Ee);
+function W(e) {
+  it(e);
+}
+function lr(e) {
+  throw e;
+}
+var fr = {
+  closed: !0,
+  next: Ke,
+  error: lr,
+  complete: Ke
+}, Se = (function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+})();
+function hr(e) {
+  return e;
+}
+function dr(e) {
+  return e.length === 0 ? hr : e.length === 1 ? e[0] : function(r) {
+    return e.reduce(function(n, i) {
+      return i(n);
+    }, r);
+  };
+}
+var I = (function() {
+  function e(t) {
+    t && (this._subscribe = t);
+  }
+  return e.prototype.lift = function(t) {
+    var r = new e();
+    return r.source = this, r.operator = t, r;
+  }, e.prototype.subscribe = function(t, r, n) {
+    var i = this, s = vr(t) ? t : new te(t, r, n);
+    return ur(function() {
+      var a = i, l = a.operator, o = a.source;
+      s.add(l ? l.call(s, o) : o ? i._subscribe(s) : i._trySubscribe(s));
+    }), s;
+  }, e.prototype._trySubscribe = function(t) {
+    try {
+      return this._subscribe(t);
+    } catch (r) {
+      t.error(r);
+    }
+  }, e.prototype.forEach = function(t, r) {
+    var n = this;
+    return r = Ve(r), new r(function(i, s) {
+      var a = new te({
+        next: function(l) {
+          try {
+            t(l);
+          } catch (o) {
+            s(o), a.unsubscribe();
+          }
+        },
+        error: s,
+        complete: i
+      });
+      n.subscribe(a);
+    });
+  }, e.prototype._subscribe = function(t) {
+    var r;
+    return (r = this.source) === null || r === void 0 ? void 0 : r.subscribe(t);
+  }, e.prototype[Se] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var t = [], r = 0; r < arguments.length; r++)
+      t[r] = arguments[r];
+    return dr(t)(this);
+  }, e.prototype.toPromise = function(t) {
+    var r = this;
+    return t = Ve(t), new t(function(n, i) {
+      var s;
+      r.subscribe(function(a) {
+        return s = a;
+      }, function(a) {
+        return i(a);
+      }, function() {
+        return n(s);
+      });
+    });
+  }, e.create = function(t) {
+    return new e(t);
+  }, e;
+})();
+function Ve(e) {
+  var t;
+  return (t = e ?? or.Promise) !== null && t !== void 0 ? t : Promise;
+}
+function pr(e) {
+  return e && b(e.next) && b(e.error) && b(e.complete);
+}
+function vr(e) {
+  return e && e instanceof Ee || pr(e) && nt(e);
+}
+function yr(e) {
+  return b(e?.lift);
+}
+function J(e) {
+  return function(t) {
+    if (yr(t))
+      return t.lift(function(r) {
+        try {
+          return e(r, this);
+        } catch (n) {
+          this.error(n);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function H(e, t, r, n, i) {
+  return new mr(e, t, r, n, i);
+}
+var mr = (function(e) {
+  be(t, e);
+  function t(r, n, i, s, a, l) {
+    var o = e.call(this, r) || this;
+    return o.onFinalize = a, o.shouldUnsubscribe = l, o._next = n ? function(c) {
+      try {
+        n(c);
+      } catch (u) {
+        r.error(u);
+      }
+    } : e.prototype._next, o._error = s ? function(c) {
+      try {
+        s(c);
+      } catch (u) {
+        r.error(u);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._error, o._complete = i ? function() {
+      try {
+        i();
+      } catch (c) {
+        r.error(c);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._complete, o;
+  }
+  return t.prototype.unsubscribe = function() {
+    var r;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var n = this.closed;
+      e.prototype.unsubscribe.call(this), !n && ((r = this.onFinalize) === null || r === void 0 || r.call(this));
+    }
+  }, t;
+})(Ee);
+function br(e) {
+  return e && b(e.schedule);
+}
+function gr(e) {
+  return e[e.length - 1];
+}
+function wr(e) {
+  return br(gr(e)) ? e.pop() : void 0;
+}
+var Oe = (function(e) {
+  return e && typeof e.length == "number" && typeof e != "function";
+});
+function st(e) {
+  return b(e?.then);
+}
+function ot(e) {
+  return b(e[Se]);
+}
+function at(e) {
+  return Symbol.asyncIterator && b(e?.[Symbol.asyncIterator]);
+}
+function ut(e) {
+  return new TypeError("You provided " + (e !== null && typeof e == "object" ? "an invalid object" : "'" + e + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function Er() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var ct = Er();
+function lt(e) {
+  return b(e?.[ct]);
+}
+function ft(e) {
+  return ir(this, arguments, function() {
+    var r, n, i, s;
+    return rt(this, function(a) {
+      switch (a.label) {
+        case 0:
+          r = e.getReader(), a.label = 1;
+        case 1:
+          a.trys.push([1, , 9, 10]), a.label = 2;
+        case 2:
+          return [4, q(r.read())];
+        case 3:
+          return n = a.sent(), i = n.value, s = n.done, s ? [4, q(void 0)] : [3, 5];
+        case 4:
+          return [2, a.sent()];
+        case 5:
+          return [4, q(i)];
+        case 6:
+          return [4, a.sent()];
+        case 7:
+          return a.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return r.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function ht(e) {
+  return b(e?.getReader);
+}
+function C(e) {
+  if (e instanceof I)
+    return e;
+  if (e != null) {
+    if (ot(e))
+      return Sr(e);
+    if (Oe(e))
+      return Or(e);
+    if (st(e))
+      return Pr(e);
+    if (at(e))
+      return dt(e);
+    if (lt(e))
+      return Rr(e);
+    if (ht(e))
+      return Tr(e);
+  }
+  throw ut(e);
+}
+function Sr(e) {
+  return new I(function(t) {
+    var r = e[Se]();
+    if (b(r.subscribe))
+      return r.subscribe(t);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function Or(e) {
+  return new I(function(t) {
+    for (var r = 0; r < e.length && !t.closed; r++)
+      t.next(e[r]);
+    t.complete();
+  });
+}
+function Pr(e) {
+  return new I(function(t) {
+    e.then(function(r) {
+      t.closed || (t.next(r), t.complete());
+    }, function(r) {
+      return t.error(r);
+    }).then(null, it);
+  });
+}
+function Rr(e) {
+  return new I(function(t) {
+    var r, n;
+    try {
+      for (var i = $(e), s = i.next(); !s.done; s = i.next()) {
+        var a = s.value;
+        if (t.next(a), t.closed)
+          return;
+      }
+    } catch (l) {
+      r = { error: l };
+    } finally {
+      try {
+        s && !s.done && (n = i.return) && n.call(i);
+      } finally {
+        if (r) throw r.error;
+      }
+    }
+    t.complete();
+  });
+}
+function dt(e) {
+  return new I(function(t) {
+    xr(e, t).catch(function(r) {
+      return t.error(r);
+    });
+  });
+}
+function Tr(e) {
+  return dt(ft(e));
+}
+function xr(e, t) {
+  var r, n, i, s;
+  return nr(this, void 0, void 0, function() {
+    var a, l;
+    return rt(this, function(o) {
+      switch (o.label) {
+        case 0:
+          o.trys.push([0, 5, 6, 11]), r = sr(e), o.label = 1;
+        case 1:
+          return [4, r.next()];
+        case 2:
+          if (n = o.sent(), !!n.done) return [3, 4];
+          if (a = n.value, t.next(a), t.closed)
+            return [2];
+          o.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return l = o.sent(), i = { error: l }, [3, 11];
+        case 6:
+          return o.trys.push([6, , 9, 10]), n && !n.done && (s = r.return) ? [4, s.call(r)] : [3, 8];
+        case 7:
+          o.sent(), o.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (i) throw i.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return t.complete(), [2];
+      }
+    });
+  });
+}
+function D(e, t, r, n, i) {
+  n === void 0 && (n = 0), i === void 0 && (i = !1);
+  var s = t.schedule(function() {
+    r(), i ? e.add(this.schedule(null, n)) : this.unsubscribe();
+  }, n);
+  if (e.add(s), !i)
+    return s;
+}
+function pt(e, t) {
+  return t === void 0 && (t = 0), J(function(r, n) {
+    r.subscribe(H(n, function(i) {
+      return D(n, e, function() {
+        return n.next(i);
+      }, t);
+    }, function() {
+      return D(n, e, function() {
+        return n.complete();
+      }, t);
+    }, function(i) {
+      return D(n, e, function() {
+        return n.error(i);
+      }, t);
+    }));
+  });
+}
+function vt(e, t) {
+  return t === void 0 && (t = 0), J(function(r, n) {
+    n.add(e.schedule(function() {
+      return r.subscribe(n);
+    }, t));
+  });
+}
+function Ir(e, t) {
+  return C(e).pipe(vt(t), pt(t));
+}
+function Ar(e, t) {
+  return C(e).pipe(vt(t), pt(t));
+}
+function Fr(e, t) {
+  return new I(function(r) {
+    var n = 0;
+    return t.schedule(function() {
+      n === e.length ? r.complete() : (r.next(e[n++]), r.closed || this.schedule());
+    });
+  });
+}
+function kr(e, t) {
+  return new I(function(r) {
+    var n;
+    return D(r, t, function() {
+      n = e[ct](), D(r, t, function() {
+        var i, s, a;
+        try {
+          i = n.next(), s = i.value, a = i.done;
+        } catch (l) {
+          r.error(l);
+          return;
+        }
+        a ? r.complete() : r.next(s);
+      }, 0, !0);
+    }), function() {
+      return b(n?.return) && n.return();
+    };
+  });
+}
+function yt(e, t) {
+  if (!e)
+    throw new Error("Iterable cannot be null");
+  return new I(function(r) {
+    D(r, t, function() {
+      var n = e[Symbol.asyncIterator]();
+      D(r, t, function() {
+        n.next().then(function(i) {
+          i.done ? r.complete() : r.next(i.value);
+        });
+      }, 0, !0);
+    });
+  });
+}
+function Cr(e, t) {
+  return yt(ft(e), t);
+}
+function jr(e, t) {
+  if (e != null) {
+    if (ot(e))
+      return Ir(e, t);
+    if (Oe(e))
+      return Fr(e, t);
+    if (st(e))
+      return Ar(e, t);
+    if (at(e))
+      return yt(e, t);
+    if (lt(e))
+      return kr(e, t);
+    if (ht(e))
+      return Cr(e, t);
+  }
+  throw ut(e);
+}
+function mt(e, t) {
+  return t ? jr(e, t) : C(e);
+}
+function Lr() {
+  for (var e = [], t = 0; t < arguments.length; t++)
+    e[t] = arguments[t];
+  var r = wr(e);
+  return mt(e, r);
+}
+function bt(e, t) {
+  var r = b(e) ? e : function() {
+    return e;
+  }, n = function(i) {
+    return i.error(r());
+  };
+  return new I(n);
+}
+var Mr = ge(function(e) {
+  return function() {
+    e(this), this.name = "EmptyError", this.message = "no elements in sequence";
+  };
+});
+function Q(e, t) {
+  return new Promise(function(r, n) {
+    var i = new te({
+      next: function(s) {
+        r(s), i.unsubscribe();
+      },
+      error: n,
+      complete: function() {
+        n(new Mr());
+      }
+    });
+    e.subscribe(i);
+  });
+}
+function N(e, t) {
+  return J(function(r, n) {
+    var i = 0;
+    r.subscribe(H(n, function(s) {
+      n.next(e.call(t, s, i++));
+    }));
+  });
+}
+var Qr = Array.isArray;
+function Dr(e, t) {
+  return Qr(t) ? e.apply(void 0, ee([], z(t))) : e(t);
+}
+function Nr(e) {
+  return N(function(t) {
+    return Dr(e, t);
+  });
+}
+function Ur(e, t, r, n, i, s, a, l) {
+  var o = [], c = 0, u = 0, f = !1, h = function() {
+    f && !o.length && !c && t.complete();
+  }, d = function(p) {
+    return c < n ? v(p) : o.push(p);
+  }, v = function(p) {
+    c++;
+    var S = !1;
+    C(r(p, u++)).subscribe(H(t, function(g) {
+      t.next(g);
+    }, function() {
+      S = !0;
+    }, void 0, function() {
+      if (S)
+        try {
+          c--;
+          for (var g = function() {
+            var P = o.shift();
+            a || v(P);
+          }; o.length && c < n; )
+            g();
+          h();
+        } catch (P) {
+          t.error(P);
+        }
+    }));
+  };
+  return e.subscribe(H(t, d, function() {
+    f = !0, h();
+  })), function() {
+  };
+}
+function re(e, t, r) {
+  return r === void 0 && (r = 1 / 0), b(t) ? re(function(n, i) {
+    return N(function(s, a) {
+      return t(n, s, i, a);
+    })(C(e(n, i)));
+  }, r) : (typeof t == "number" && (r = t), J(function(n, i) {
+    return Ur(n, i, e, r);
+  }));
+}
+var _r = ["addListener", "removeListener"], qr = ["addEventListener", "removeEventListener"], Hr = ["on", "off"];
+function ve(e, t, r, n) {
+  if (b(r) && (n = r, r = void 0), n)
+    return ve(e, t, r).pipe(Nr(n));
+  var i = z(Vr(e) ? qr.map(function(l) {
+    return function(o) {
+      return e[l](t, o, r);
+    };
+  }) : Br(e) ? _r.map($e(e, t)) : Kr(e) ? Hr.map($e(e, t)) : [], 2), s = i[0], a = i[1];
+  if (!s && Oe(e))
+    return re(function(l) {
+      return ve(l, t, r);
+    })(C(e));
+  if (!s)
+    throw new TypeError("Invalid event target");
+  return new I(function(l) {
+    var o = function() {
+      for (var c = [], u = 0; u < arguments.length; u++)
+        c[u] = arguments[u];
+      return l.next(1 < c.length ? c : c[0]);
+    };
+    return s(o), function() {
+      return a(o);
+    };
+  });
+}
+function $e(e, t) {
+  return function(r) {
+    return function(n) {
+      return e[r](t, n);
+    };
+  };
+}
+function Br(e) {
+  return b(e.addListener) && b(e.removeListener);
+}
+function Kr(e) {
+  return b(e.on) && b(e.off);
+}
+function Vr(e) {
+  return b(e.addEventListener) && b(e.removeEventListener);
+}
+var $r = Array.isArray;
+function zr(e) {
+  return e.length === 1 && $r(e[0]) ? e[0] : e;
+}
+function Gr() {
+  for (var e = [], t = 0; t < arguments.length; t++)
+    e[t] = arguments[t];
+  return e = zr(e), e.length === 1 ? C(e[0]) : new I(Jr(e));
+}
+function Jr(e) {
+  return function(t) {
+    for (var r = [], n = function(s) {
+      r.push(C(e[s]).subscribe(H(t, function(a) {
+        if (r) {
+          for (var l = 0; l < r.length; l++)
+            l !== s && r[l].unsubscribe();
+          r = null;
+        }
+        t.next(a);
+      })));
+    }, i = 0; r && !t.closed && i < e.length; i++)
+      n(i);
+  };
+}
+function Pe(e) {
+  return J(function(t, r) {
+    var n = null, i = !1, s;
+    n = t.subscribe(H(r, void 0, void 0, function(a) {
+      s = C(e(a, Pe(e)(t))), n ? (n.unsubscribe(), n = null, s.subscribe(r)) : i = !0;
+    })), i && (n.unsubscribe(), n = null, s.subscribe(r));
+  });
+}
+function gt(e) {
+  switch (e.responseType) {
+    case "json": {
+      if ("response" in e)
+        return e.response;
+      var t = e;
+      return JSON.parse(t.responseText);
+    }
+    case "document":
+      return e.responseXML;
+    default: {
+      if ("response" in e)
+        return e.response;
+      var t = e;
+      return t.responseText;
+    }
+  }
+}
+var Xr = /* @__PURE__ */ (function() {
+  function e(t, r, n, i) {
+    i === void 0 && (i = "download_load"), this.originalEvent = t, this.xhr = r, this.request = n, this.type = i;
+    var s = r.status, a = r.responseType;
+    this.status = s ?? 0, this.responseType = a ?? "";
+    var l = r.getAllResponseHeaders();
+    this.responseHeaders = l ? l.split(`
+`).reduce(function(u, f) {
+      var h = f.indexOf(": ");
+      return u[f.slice(0, h)] = f.slice(h + 2), u;
+    }, {}) : {}, this.response = gt(r);
+    var o = t.loaded, c = t.total;
+    this.loaded = o, this.total = c;
+  }
+  return e;
+})(), G = ge(function(e) {
+  return function(r, n, i) {
+    this.message = r, this.name = "AjaxError", this.xhr = n, this.request = i, this.status = n.status, this.responseType = n.responseType;
+    var s;
+    try {
+      s = gt(n);
+    } catch {
+      s = n.responseText;
+    }
+    this.response = s;
+  };
+}), Wr = (function() {
+  function e(t, r) {
+    return G.call(this, "ajax timeout", t, r), this.name = "AjaxTimeoutError", this;
+  }
+  return e.prototype = Object.create(G.prototype), e;
+})();
+function Yr(e, t) {
+  return U({ method: "GET", url: e, headers: t });
+}
+function Zr(e, t, r) {
+  return U({ method: "POST", url: e, body: t, headers: r });
+}
+function en(e, t) {
+  return U({ method: "DELETE", url: e, headers: t });
+}
+function tn(e, t, r) {
+  return U({ method: "PUT", url: e, body: t, headers: r });
+}
+function rn(e, t, r) {
+  return U({ method: "PATCH", url: e, body: t, headers: r });
+}
+var nn = N(function(e) {
+  return e.response;
+});
+function sn(e, t) {
+  return nn(U({
+    method: "GET",
+    url: e,
+    headers: t
+  }));
+}
+var U = (function() {
+  var e = function(t) {
+    var r = typeof t == "string" ? {
+      url: t
+    } : t;
+    return an(r);
+  };
+  return e.get = Yr, e.post = Zr, e.delete = en, e.put = tn, e.patch = rn, e.getJSON = sn, e;
+})(), on = "upload", ze = "download", ue = "loadstart", ce = "progress", Ge = "load";
+function an(e) {
+  return new I(function(t) {
+    var r, n, i = K({ async: !0, crossDomain: !1, withCredentials: !1, method: "GET", timeout: 0, responseType: "json" }, e), s = i.queryParams, a = i.body, l = i.headers, o = i.url;
+    if (!o)
+      throw new TypeError("url is required");
+    if (s) {
+      var c;
+      if (o.includes("?")) {
+        var u = o.split("?");
+        if (2 < u.length)
+          throw new TypeError("invalid url");
+        c = new URLSearchParams(u[1]), new URLSearchParams(s).forEach(function(E, O) {
+          return c.set(O, E);
+        }), o = u[0] + "?" + c;
+      } else
+        c = new URLSearchParams(s), o = o + "?" + c;
+    }
+    var f = {};
+    if (l)
+      for (var h in l)
+        l.hasOwnProperty(h) && (f[h.toLowerCase()] = l[h]);
+    var d = i.crossDomain;
+    !d && !("x-requested-with" in f) && (f["x-requested-with"] = "XMLHttpRequest");
+    var v = i.withCredentials, p = i.xsrfCookieName, S = i.xsrfHeaderName;
+    if ((v || !d) && p && S) {
+      var g = (n = (r = document?.cookie.match(new RegExp("(^|;\\s*)(" + p + ")=([^;]*)"))) === null || r === void 0 ? void 0 : r.pop()) !== null && n !== void 0 ? n : "";
+      g && (f[S] = g);
+    }
+    var P = un(a, f), w = K(K({}, i), {
+      url: o,
+      headers: f,
+      body: P
+    }), y;
+    y = e.createXHR ? e.createXHR() : new XMLHttpRequest();
+    {
+      var m = e.progressSubscriber, j = e.includeDownloadProgress, A = j === void 0 ? !1 : j, T = e.includeUploadProgress, _ = T === void 0 ? !1 : T, k = function(E, O) {
+        y.addEventListener(E, function() {
+          var x, M = O();
+          (x = m?.error) === null || x === void 0 || x.call(m, M), t.error(M);
+        });
+      };
+      k("timeout", function() {
+        return new Wr(y, w);
+      }), k("abort", function() {
+        return new G("aborted", y, w);
+      });
+      var L = function(E, O) {
+        return new Xr(O, y, w, E + "_" + O.type);
+      }, Te = function(E, O, x) {
+        E.addEventListener(O, function(M) {
+          t.next(L(x, M));
+        });
+      };
+      _ && [ue, ce, Ge].forEach(function(E) {
+        return Te(y.upload, E, on);
+      }), m && [ue, ce].forEach(function(E) {
+        return y.upload.addEventListener(E, function(O) {
+          var x;
+          return (x = m?.next) === null || x === void 0 ? void 0 : x.call(m, O);
+        });
+      }), A && [ue, ce].forEach(function(E) {
+        return Te(y, E, ze);
+      });
+      var xe = function(E) {
+        var O = "ajax error" + (E ? " " + E : "");
+        t.error(new G(O, y, w));
+      };
+      y.addEventListener("error", function(E) {
+        var O;
+        (O = m?.error) === null || O === void 0 || O.call(m, E), xe();
+      }), y.addEventListener(Ge, function(E) {
+        var O, x, M = y.status;
+        if (M < 400) {
+          (O = m?.complete) === null || O === void 0 || O.call(m);
+          var Fe = void 0;
+          try {
+            Fe = L(ze, E);
+          } catch (wt) {
+            t.error(wt);
+            return;
+          }
+          t.next(Fe), t.complete();
+        } else
+          (x = m?.error) === null || x === void 0 || x.call(m, E), xe(M);
+      });
+    }
+    var Ie = w.user, Ae = w.method, se = w.async;
+    Ie ? y.open(Ae, o, se, Ie, w.password) : y.open(Ae, o, se), se && (y.timeout = w.timeout, y.responseType = w.responseType), "withCredentials" in y && (y.withCredentials = w.withCredentials);
+    for (var h in f)
+      f.hasOwnProperty(h) && y.setRequestHeader(h, f[h]);
+    return P ? y.send(P) : y.send(), function() {
+      y && y.readyState !== 4 && y.abort();
+    };
+  });
+}
+function un(e, t) {
+  var r;
+  if (!e || typeof e == "string" || pn(e) || vn(e) || ln(e) || fn(e) || hn(e) || yn(e))
+    return e;
+  if (dn(e))
+    return e.buffer;
+  if (typeof e == "object")
+    return t["content-type"] = (r = t["content-type"]) !== null && r !== void 0 ? r : "application/json;charset=utf-8", JSON.stringify(e);
+  throw new TypeError("Unknown body type");
+}
+var cn = Object.prototype.toString;
+function Re(e, t) {
+  return cn.call(e) === "[object " + t + "]";
+}
+function ln(e) {
+  return Re(e, "ArrayBuffer");
+}
+function fn(e) {
+  return Re(e, "File");
+}
+function hn(e) {
+  return Re(e, "Blob");
+}
+function dn(e) {
+  return typeof ArrayBuffer < "u" && ArrayBuffer.isView(e);
+}
+function pn(e) {
+  return typeof FormData < "u" && e instanceof FormData;
+}
+function vn(e) {
+  return typeof URLSearchParams < "u" && e instanceof URLSearchParams;
+}
+function yn(e) {
+  return typeof ReadableStream < "u" && e instanceof ReadableStream;
+}
+function ye(e, t, r = []) {
+  return {
+    handle: (n, i) => {
+      let s;
+      for (const l of Array.isArray(n) ? n : [n]) {
+        const o = e.find(
+          (c) => c.ErrorCode === t[l]
+        );
+        if (o) {
+          s = i(l, o);
+          break;
+        }
+      }
+      let a = r;
+      return s !== void 0 && (a = [...a, s]), ye(
+        e,
+        t,
+        a
+      );
+    },
+    handleAll: (n, i) => {
+      let s;
+      const a = (Array.isArray(n) ? n : [n]).reduce(
+        (o, c) => {
+          const u = e.filter(
+            (f) => f.ErrorCode === t[c]
+          );
+          return u.length === 0 ? o : [
+            ...o,
+            {
+              errorName: c,
+              errors: u
+            }
+          ];
+        },
+        []
+      );
+      a.length > 0 && (s = i(a));
+      let l = r;
+      return s !== void 0 && (l = [...l, s]), ye(
+        e,
+        t,
+        l
+      );
+    },
+    check: ((n) => {
+      if (n)
+        return r.reduce(n.reducer, n.initialValue);
+    })
+  };
+}
+function mn(e, t) {
+  const r = {
+    ...t,
+    success: -1,
+    failure: -2
+  }, n = e.isSuccess ? e.result.WasSuccessful ? [
+    {
+      ErrorMessage: "",
+      PropertyName: "",
+      ErrorCode: -1
+    }
+  ] : e.result.ValidationErrors : [
+    {
+      ErrorMessage: "",
+      PropertyName: "",
+      ErrorCode: -2
+    }
+  ];
+  return ye(n, r);
+}
+function bn(e) {
+  return e?.invalidateToken ? (t) => t.pipe(
+    Pe((r) => (r.status === 401 && e.invalidateToken?.(), bt(() => r)))
+  ) : (t) => t;
+}
+process.env.NODE_ENV;
+function gn(e, t) {
+  return e.length === 0 ? "" : t(e[0]) + e.slice(1);
+}
+function wn(e) {
+  return gn(e, (t) => t.toLowerCase());
+}
+function En(e) {
+  return JSON.parse(e, (t, r) => {
+    if (!(r === null && t !== ""))
+      return !r || Array.isArray(r) || typeof r != "object" ? r : Object.fromEntries(Object.entries(r).map(([n, i]) => [wn(n), i]));
+  });
+}
+function Je() {
+  return (e) => e.pipe(N(En));
+}
+function On({
+  cqrsEndpoint: e,
+  queryClient: t,
+  tokenProvider: r,
+  ajaxOptions: n,
+  tokenHeader: i = "Authorization"
+}) {
+  function s(a, l = {}) {
+    const o = (f, h) => U({
+      ...n,
+      ...l,
+      headers: {
+        [i]: h,
+        "Content-Type": "application/json"
+      },
+      url: `${e}/${a}`,
+      method: "POST",
+      body: f,
+      withCredentials: n?.withCredentials ?? !0
+    }), c = r?.getToken, u = (f, h) => o(f, h).pipe(
+      bn(r),
+      N((d) => d.response)
+    );
+    return c ? (f) => mt(c()).pipe(re((h) => u(f, h))) : (f) => u(f);
+  }
+  return {
+    createQuery(a) {
+      const l = s(`query/${a}`, { responseType: "text" });
+      function o(u, f) {
+        return tr(
+          {
+            queryKey: o.key(u),
+            queryFn: (h) => Q(o.fetcher(u, h)),
+            ...f
+          },
+          t
+        );
+      }
+      o.type = a, o.fetcher = (u, f) => Gr([
+        l(u).pipe(Je()),
+        ...f?.signal ? [
+          ve(f.signal, "abort").pipe(
+            re(() => bt(() => new Error("Query aborted")))
+          )
+        ] : []
+      ]), o.fetch = (u, f) => t.fetchQuery({
+        queryKey: o.key(u),
+        queryFn: (h) => Q(o.fetcher(u, h)),
+        ...f
+      }), o.lazy = function(u = {}) {
+        return oe(
+          {
+            mutationKey: [a],
+            mutationFn: (f) => Q(o.fetcher(f)),
+            ...u
+          },
+          t
+        );
+      }, o.infinite = function(u, f) {
+        return rr(
+          {
+            queryKey: [a],
+            queryFn: (h) => Q(o.fetcher(h.pageParam, h)),
+            initialPageParam: u,
+            ...f
+          },
+          t
+        );
+      }, o.key = (u) => [a, u];
+      function c(u, f) {
+        const h = Array.isArray(u) ? u : o.key(u);
+        return t.setQueryData(h, f);
+      }
+      return o.setQueryData = c, o.setQueriesData = (u, f) => t.setQueriesData({ queryKey: o.key(u) }, f), o.getQueryData = (u) => t.getQueryData(o.key(u)), o.getQueriesData = (u) => t.getQueriesData({
+        queryKey: o.key(u)
+      }), o.prefetch = (u, f) => t.prefetchQuery({
+        queryKey: o.key(u),
+        queryFn: (h) => Q(o.fetcher(u, h)),
+        ...f
+      }), o.invalidate = (u) => t.invalidateQueries({ queryKey: o.key(u) }), o.cancel = (u) => t.cancelQueries({ queryKey: o.key(u) }), o.optimisticUpdate = async (u, f = {}) => {
+        await o.cancel(f);
+        const h = o.getQueriesData(f);
+        return o.setQueriesData(f, u), () => h.forEach(([d, v]) => t.setQueryData(d, v));
+      }, o;
+    },
+    createOperation(a) {
+      const l = s(`operation/${a}`, { responseType: "text" });
+      function o({
+        onSuccess: c,
+        invalidateQueries: u,
+        ...f
+      } = {}) {
+        return oe(
+          {
+            mutationKey: o.key,
+            mutationFn: (h) => Q(o.fetcher(h)),
+            ...f,
+            async onSuccess(h, d, v, p) {
+              const S = await c?.(h, d, v, p);
+              return u && await Promise.allSettled(u.map((g) => t.invalidateQueries({ queryKey: g }))), S;
+            }
+          },
+          t
+        );
+      }
+      return o.type = a, o.key = [o.type], o.fetcher = (c) => l(c).pipe(Je()), o;
+    },
+    createCommand(a, l) {
+      const o = s(`command/${a}`);
+      function c({
+        invalidateQueries: u,
+        handler: f,
+        optimisticUpdate: h,
+        onMutate: d,
+        onError: v,
+        onSettled: p,
+        ...S
+      } = {}) {
+        return oe(
+          {
+            ...S,
+            mutationKey: c.key,
+            mutationFn: (g) => Q(c.call(g, f)),
+            async onMutate(g, P) {
+              const w = await d?.(g, P), y = await Promise.all(h?.(g) ?? []);
+              return {
+                ...w,
+                revertOptimisticUpdate: () => y.forEach((m) => m())
+              };
+            },
+            async onError(g, P, w, y) {
+              await v?.(g, P, w, y), w?.revertOptimisticUpdate();
+            },
+            // eslint-disable-next-line max-params
+            async onSettled(g, P, w, y, m) {
+              return u && await Promise.allSettled(u.map((j) => t.invalidateQueries({ queryKey: j }))), await p?.(g, P, w, y, m);
+            }
+          },
+          t
+        );
+      }
+      return c.type = a, c.key = [c.type], c.fetcher = o, c.call = (u, f) => c.fetcher(u).pipe(
+        N(
+          (d) => ({
+            isSuccess: !0,
+            result: d
+          })
+        ),
+        Pe((d) => Lr(c.mapError(d))),
+        N((d) => {
+          const v = f ? c.handleResponse(f, u)(d) : d;
+          if (!d.isSuccess || !d.result.WasSuccessful)
+            throw v;
+          return v;
+        })
+      ), c.mapError = (u) => u instanceof G && u.status === 422 ? {
+        isSuccess: !0,
+        result: u.response
+      } : {
+        isSuccess: !1,
+        error: u
+      }, c.handleResponse = (u, f) => (h) => u(mn(h, l), f), c;
+    }
+  };
+}
+export {
+  On as mkCqrsClient
+};