reactjrx 1.65.0 → 1.67.4

package/dist/index.js

@@ -1,655 +1,667 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
+var ze = Object.defineProperty;
+var Je = (t, e, r) => e in t ? ze(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var y = (t, e, r) => (Je(t, typeof e != "symbol" ? e + "" : e, r), r), We = (t, e, r) => {
+  if (!e.has(t))
+    throw TypeError("Cannot " + r);
 };
-import { useRef, useMemo, useCallback, useSyncExternalStore, useEffect, createContext, memo, useContext } from "react";
-import { distinctUntilChanged, tap, finalize, catchError, EMPTY, Subject, identity, BehaviorSubject, map, of, zip, merge, throttleTime, asyncScheduler, switchMap, from, defer, iif, timer, throwError, fromEvent, filter, skip, withLatestFrom, scan, retry, shareReplay, endWith, delay, take, takeUntil, share, startWith, pairwise, mergeMap, NEVER, combineLatest, concatMap as concatMap$1, last, Observable, concat, toArray, takeWhile } from "rxjs";
-import { retryWhen, concatMap, tap as tap$1 } from "rxjs/operators";
-import { jsxs, jsx } from "react/jsx-runtime";
-const useLiveRef = (value) => {
-  const ref = useRef(value);
-  useMemo(() => {
-    ref.current = value;
-  }, [value]);
-  return ref;
+var k = (t, e, r) => (We(t, e, "read from private field"), r ? r.call(t) : e.get(t)), de = (t, e, r) => {
+  if (e.has(t))
+    throw TypeError("Cannot add the same private member more than once");
+  e instanceof WeakSet ? e.add(t) : e.set(t, r);
 };
-function primitiveEqual(objA, objB) {
-  if (typeof objA === "string" && objA === objB)
-    return true;
-  if (typeof objA === "number" && objA === objB)
-    return true;
-  if (typeof objA === "boolean" && objA === objB)
-    return true;
-  if (typeof objA === "symbol" && objA === objB)
-    return true;
-  if (typeof objA === "bigint" && objA === objB)
-    return true;
-  if (typeof objA === "undefined" && objA === objB)
-    return true;
-  if (objA === null && objA === objB)
-    return true;
-  return false;
+import { useRef as H, useMemo as ye, useCallback as Y, useSyncExternalStore as Ye, useEffect as K, createContext as Ge, memo as He, useContext as De, useState as Xe } from "react";
+import { distinctUntilChanged as R, tap as x, finalize as ae, catchError as A, EMPTY as M, Subject as F, identity as le, BehaviorSubject as I, map as p, of as S, zip as Ze, merge as O, throttleTime as Ve, asyncScheduler as qe, switchMap as w, from as ne, defer as se, throwError as Re, iif as Te, timer as ie, Observable as Me, filter as $, mergeMap as _, takeUntil as P, skip as B, last as ge, scan as pe, shareReplay as $e, concatMap as Be, fromEvent as me, withLatestFrom as D, retry as et, endWith as tt, delay as rt, take as be, share as J, startWith as Ie, pairwise as oe, NEVER as Qe, combineLatest as Fe, takeWhile as ve, concat as ue, toArray as ce, lastValueFrom as nt } from "rxjs";
+import { catchError as Ce, retryWhen as st, concatMap as it, tap as ut } from "rxjs/operators";
+import { jsxs as ct, jsx as ot } from "react/jsx-runtime";
+const U = (t) => {
+  const e = H(t);
+  return ye(() => {
+    e.current = t;
+  }, [t]), e;
+};
+function at(t, e) {
+  return typeof t == "string" && t === e || typeof t == "number" && t === e || typeof t == "boolean" && t === e || typeof t == "symbol" && t === e || typeof t == "bigint" && t === e || typeof t > "u" && t === e || t === null && t === e;
 }
-function useObserve(source$, unsafeOptions, unsafeDeps) {
-  const options = unsafeOptions != null && !Array.isArray(unsafeOptions) ? unsafeOptions : {
+function fe(t, e, r) {
+  const n = e != null && !Array.isArray(e) ? e : {
     defaultValue: void 0,
     key: "",
-    unsubscribeOnUnmount: true
-  };
-  const deps = unsafeDeps == null && Array.isArray(unsafeOptions) ? unsafeOptions : typeof source$ === "function" ? unsafeDeps ?? [] : [source$];
-  const valueRef = useRef(
-    "getValue" in source$ && typeof source$.getValue === "function" ? source$.getValue() : options.defaultValue
-  );
-  const sourceRef = useLiveRef(source$);
-  const optionsRef = useLiveRef(options);
-  const subscribe = useCallback(
-    (next) => {
-      const source = sourceRef.current;
-      const makeObservable = typeof source === "function" ? source : () => source;
-      const sub = makeObservable().pipe(
+    unsubscribeOnUnmount: !0
+  }, s = r == null && Array.isArray(e) ? e : typeof t == "function" ? r ?? [] : [t], i = H(
+    "getValue" in t && typeof t.getValue == "function" ? t.getValue() : n.defaultValue
+  ), u = U(t), l = U(n), f = Y(
+    (g) => {
+      const a = u.current, o = (typeof a == "function" ? a : () => a)().pipe(
         /**
          * @important
          * We only check primitives because underlying subscription might
          * be using objects and keeping same reference but pushing new
          * properties values
          */
-        distinctUntilChanged(primitiveEqual),
-        tap((value) => {
-          valueRef.current = value;
+        R(at),
+        x((m) => {
+          i.current = m;
         }),
-        finalize(next),
-        catchError((error) => {
-          console.error(error);
-          valueRef.current = void 0;
-          return EMPTY;
-        })
-      ).subscribe(next);
+        ae(g),
+        A((m) => (console.error(m), i.current = void 0, M))
+      ).subscribe(g);
       return () => {
-        if (optionsRef.current.unsubscribeOnUnmount === false)
-          return;
-        sub.unsubscribe();
+        l.current.unsubscribeOnUnmount !== !1 && o.unsubscribe();
       };
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [...deps]
-  );
-  const getSnapshot = useCallback(() => {
-    return valueRef.current;
-  }, []);
-  const result = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return result;
+    [...s]
+  ), d = Y(() => i.current, []);
+  return Ye(f, d, d);
 }
-function useSubscribe(source, deps = []) {
-  const sourceRef = useLiveRef(source);
-  const sourceAsObservable = typeof source === "function" ? void 0 : source;
-  useEffect(() => {
-    const source2 = sourceRef.current;
-    const makeObservable = typeof source2 === "function" ? source2 : () => source2;
-    const sub = makeObservable().pipe(
-      catchError((error) => {
-        console.error(
-          "Uncaught error at useSubscribe. Please consider adding a catchError or other handling."
-        );
-        console.error(error);
-        return EMPTY;
-      })
+function Se(t, e = []) {
+  const r = U(t), n = typeof t == "function" ? void 0 : t;
+  K(() => {
+    const s = r.current, u = (typeof s == "function" ? s : () => s)().pipe(
+      A((l) => (console.error(
+        "Uncaught error at useSubscribe. Please consider adding a catchError or other handling."
+      ), console.error(l), M))
     ).subscribe();
     return () => {
-      sub.unsubscribe();
+      u.unsubscribe();
     };
   }, [
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    ...deps,
-    sourceAsObservable,
-    sourceRef
+    ...e,
+    n,
+    r
   ]);
 }
-const useConstant = (fn) => {
-  const ref = useRef();
-  if (!ref.current) {
-    ref.current = fn();
-  }
-  useEffect(() => {
-    if (process.env.NODE_ENV === "development")
-      ;
-  }, []);
-  return ref;
-};
-const useSubject = ({
-  onBeforeComplete,
-  completeOnUnmount = true
+const we = (t) => {
+  const e = H();
+  return e.current || (e.current = t()), K(() => {
+    process.env.NODE_ENV;
+  }, []), e;
+}, Oe = ({
+  onBeforeComplete: t,
+  completeOnUnmount: e = !0
 } = {}) => {
-  const subject = useConstant(() => new Subject());
-  const completed = useRef(false);
-  const onBeforeCompleteRef = useLiveRef(onBeforeComplete);
-  const completeOnUnmountRef = useLiveRef(completeOnUnmount);
-  useEffect(() => {
-    if (completed.current) {
-      subject.current = new Subject();
-      completed.current = false;
+  const r = we(() => new F()), n = H(!1), s = U(t), i = U(e);
+  return K(() => (n.current && (r.current = new F(), n.current = !1), () => {
+    if (!i.current) {
+      n.current = !0;
+      return;
     }
-    return () => {
-      if (!completeOnUnmountRef.current) {
-        completed.current = true;
-        return;
-      }
-      if (!completed.current) {
-        if (onBeforeCompleteRef.current != null)
-          onBeforeCompleteRef.current();
-        subject.current.complete();
-        completed.current = true;
-      }
-    };
-  }, [completeOnUnmountRef, onBeforeCompleteRef, subject]);
-  return subject;
+    n.current || (s.current != null && s.current(), r.current.complete(), n.current = !0);
+  }), [i, s, r]), r;
+}, ar = (t, e) => {
+  const r = Oe();
+  return Se(() => t(r.current), [r, ...e]), [Y((s) => {
+    r.current.next(s);
+  }, [r]), r];
 };
-const useObserveCallback = (callback, deps) => {
-  const trigger$ = useSubject();
-  useSubscribe(() => callback(trigger$.current), [trigger$, ...deps]);
-  const trigger2 = useCallback((arg) => {
-    trigger$.current.next(arg);
-  }, [trigger$]);
-  return [trigger2, trigger$];
-};
-function trigger(mapper = identity) {
-  const subject = new Subject();
+function lr(t = le) {
+  const e = new F();
   return [
-    subject.asObservable(),
-    (...args) => {
-      subject.next(mapper(...args));
+    e.asObservable(),
+    (...r) => {
+      e.next(t(...r));
     }
   ];
 }
-const useBehaviorSubject = (state) => {
-  const subject = useConstant(() => new BehaviorSubject(state));
-  const completed = useRef(false);
-  const stateRef = useRef(state);
-  useEffect(() => {
-    if (completed.current) {
-      subject.current = new BehaviorSubject(stateRef.current);
-      completed.current = false;
-    }
-    return () => {
-      if (!completed.current) {
-        subject.current.complete();
-        completed.current = true;
+const lt = (t) => {
+  const e = we(() => new I(t)), r = H(!1), n = H(t);
+  return K(() => (r.current && (e.current = new I(n.current), r.current = !1), () => {
+    r.current || (e.current.complete(), r.current = !0);
+  }), [e]), e;
+}, pt = Symbol("SIGNAL_RESET");
+function pr(t) {
+  const { default: e } = t ?? {}, r = new I(e);
+  return {
+    setValue: (i) => {
+      if (typeof i == "function") {
+        const u = i(r.getValue());
+        if (u === r.getValue())
+          return;
+        r.next(u);
+        return;
       }
-    };
-  }, [subject]);
-  return subject;
-};
-const SIGNAL_RESET = Symbol("SIGNAL_RESET");
-function signal(config) {
-  const { default: defaultValue2 } = config ?? {};
-  const subject = new BehaviorSubject(defaultValue2);
-  const setValue = (arg) => {
-    if (typeof arg === "function") {
-      const change = arg(subject.getValue());
-      if (change === subject.getValue())
+      if (i === pt) {
+        r.next(e ?? void 0);
         return;
-      subject.next(change);
-      return;
-    }
-    if (arg === SIGNAL_RESET) {
-      subject.next(defaultValue2 ?? void 0);
-      return;
-    }
-    subject.next(arg);
-  };
-  const getValue = () => subject.getValue();
-  return {
-    setValue,
-    getValue,
-    config,
-    subject
+      }
+      r.next(i);
+    },
+    getValue: () => r.getValue(),
+    config: t,
+    subject: r
   };
 }
-function useSignalValue(signal2, selector) {
-  const selectorOrDefault = selector ?? ((v) => v);
-  return useObserve(
-    () => signal2.subject.pipe(
-      map((value) => selectorOrDefault(value)),
-      distinctUntilChanged()
+function fr(t, e) {
+  const r = e ?? ((n) => n);
+  return fe(
+    () => t.subject.pipe(
+      p((n) => r(n)),
+      R()
     ),
     {
-      defaultValue: selectorOrDefault(signal2.getValue())
+      defaultValue: r(t.getValue())
     },
     []
   );
 }
-const normalizeStore = (store) => {
-  if (!store || typeof store !== "object") {
-    return void 0;
-  }
-  return store;
-};
-const createSharedStoreAdapter = ({
-  adapter,
-  key
+const xe = (t) => {
+  if (!(!t || typeof t != "object"))
+    return t;
+}, dr = ({
+  adapter: t,
+  key: e
 }) => ({
-  getItem: async (itemKey) => {
-    const unsafeStore = await adapter.getItem(key);
-    const store = normalizeStore(unsafeStore) ?? {};
-    if (itemKey in store) {
-      return store[itemKey];
-    }
-    return void 0;
+  getItem: async (r) => {
+    const n = await t.getItem(e), s = xe(n) ?? {};
+    if (r in s)
+      return s[r];
   },
-  setItem: async (itemKey, value) => {
-    const unsafeStore = await adapter.getItem(key);
-    const store = normalizeStore(unsafeStore) ?? {};
-    await adapter.setItem(key, { ...store, [itemKey]: value });
+  setItem: async (r, n) => {
+    const s = await t.getItem(e), i = xe(s) ?? {};
+    await t.setItem(e, { ...i, [r]: n });
   }
-});
-const createLocalforageAdapter = (forage) => ({
-  getItem: async (key) => {
-    const serializedValue = await forage.getItem(key);
-    if (!serializedValue)
-      return void 0;
-    return JSON.parse(serializedValue);
+}), hr = (t) => ({
+  getItem: async (e) => {
+    const r = await t.getItem(e);
+    if (r)
+      return JSON.parse(r);
   },
-  setItem: async (key, value) => {
-    await forage.setItem(key, JSON.stringify(value));
+  setItem: async (e, r) => {
+    await t.setItem(e, JSON.stringify(r));
   }
-});
-const createLocalStorageAdapter = (forage) => ({
-  getItem: async (key) => {
-    const serializedValue = forage.getItem(key);
-    if (!serializedValue)
-      return void 0;
-    return JSON.parse(serializedValue);
+}), ft = (t) => ({
+  getItem: async (e) => {
+    const r = t.getItem(e);
+    if (r)
+      return JSON.parse(r);
   },
-  setItem: async (key, value) => {
-    forage.setItem(key, JSON.stringify(value));
-  }
-});
-const IDENTIFIER_PERSISTANCE_KEY = "__reactjrx";
-const getNormalizedPersistanceValue = (unknownValue) => {
-  if (typeof unknownValue === "object" && unknownValue !== null && IDENTIFIER_PERSISTANCE_KEY in unknownValue && unknownValue[IDENTIFIER_PERSISTANCE_KEY] === IDENTIFIER_PERSISTANCE_KEY) {
-    return unknownValue;
+  setItem: async (e, r) => {
+    t.setItem(e, JSON.stringify(r));
   }
-  return void 0;
-};
-const persistValue = async ({
-  adapter,
-  signal: signal2,
-  version
+}), Z = "__reactjrx", dt = (t) => {
+  if (typeof t == "object" && t !== null && Z in t && t[Z] === Z)
+    return t;
+}, ht = async ({
+  adapter: t,
+  signal: e,
+  version: r
 }) => {
-  const state = signal2.getValue();
-  const value = {
-    value: state,
-    [IDENTIFIER_PERSISTANCE_KEY]: IDENTIFIER_PERSISTANCE_KEY,
-    migrationVersion: version
+  const s = {
+    value: e.getValue(),
+    [Z]: Z,
+    migrationVersion: r
   };
-  await adapter.setItem(signal2.config.key, value);
-};
-const hydrateValueToSignal = ({
-  adapter,
-  version,
-  signal: signal2
-}) => {
-  return from(adapter.getItem(signal2.config.key)).pipe(
-    switchMap((value) => {
-      const normalizedValue = getNormalizedPersistanceValue(value);
-      if (!normalizedValue)
-        return of(value);
-      if (normalizedValue.migrationVersion !== void 0 && version > normalizedValue.migrationVersion) {
-        return of(value);
-      }
-      signal2.setValue(value.value);
-      return of(value);
-    })
-  );
-};
-const usePersistSignals = ({
-  entries = [],
-  onReady,
-  adapter = createLocalStorageAdapter(localStorage)
+  await t.setItem(e.config.key, s);
+}, gt = ({
+  adapter: t,
+  version: e,
+  signal: r
+}) => ne(t.getItem(r.config.key)).pipe(
+  w((n) => {
+    const s = dt(n);
+    return s ? s.migrationVersion !== void 0 && e > s.migrationVersion ? S(n) : (r.setValue(n.value), S(n)) : S(n);
+  })
+), gr = ({
+  entries: t = [],
+  onReady: e,
+  adapter: r = ft(localStorage)
 }) => {
-  const entriesRef = useLiveRef(entries);
-  const onReadyRef = useLiveRef(onReady);
-  const adapterRef = useLiveRef(adapter);
-  const isHydrated = useObserve(
+  const n = U(t), s = U(e), i = U(r), u = fe(
     () => {
-      const entries2 = entriesRef.current;
-      const stream = entries2.length === 0 ? of(true) : zip(
-        ...entries2.map(
-          ({ signal: signal2, version }) => hydrateValueToSignal({
-            adapter: adapterRef.current,
-            signal: signal2,
-            version
+      const l = n.current;
+      return (l.length === 0 ? S(!0) : Ze(
+        ...l.map(
+          ({ signal: d, version: h }) => gt({
+            adapter: i.current,
+            signal: d,
+            version: h
           })
         )
-      ).pipe(map(() => true));
-      return stream.pipe(
-        tap(() => {
-          if (onReadyRef.current != null)
-            onReadyRef.current();
+      ).pipe(p(() => !0))).pipe(
+        x(() => {
+          s.current != null && s.current();
         }),
-        catchError((error) => {
-          console.error("Unable to hydrate", error);
-          return EMPTY;
-        })
+        A((d) => (console.error("Unable to hydrate", d), M))
       );
     },
-    { defaultValue: false },
+    { defaultValue: !1 },
     []
   );
-  useSubscribe(() => {
-    return !isHydrated ? EMPTY : merge(
-      ...entriesRef.current.map(
-        ({ signal: signal2, version }) => signal2.subject.pipe(
-          throttleTime(500, asyncScheduler, {
-            trailing: true
-          }),
-          switchMap(
-            () => from(
-              persistValue({ adapter: adapterRef.current, signal: signal2, version })
-            )
+  return Se(() => u ? O(
+    ...n.current.map(
+      ({ signal: l, version: f }) => l.subject.pipe(
+        Ve(500, qe, {
+          trailing: !0
+        }),
+        w(
+          () => ne(
+            ht({ adapter: i.current, signal: l, version: f })
           )
         )
       )
-    );
-  }, [isHydrated, adapterRef]);
-  return { isHydrated };
-};
-const useUnmountObservable = () => {
-  const subject = useSubject({
+    )
+  ) : M, [u, i]), { isHydrated: u };
+}, mr = () => {
+  const t = Oe({
     onBeforeComplete: () => {
-      subject.current.next();
+      t.current.next();
     }
   });
-  return subject;
+  return t;
 };
-function getDelay(backoffDelay, maxInterval) {
-  return Math.min(backoffDelay, maxInterval);
+function mt(t, e) {
+  return Math.min(t, e);
 }
-function exponentialBackoffDelay(iteration, initialInterval) {
-  return Math.pow(2, iteration) * initialInterval;
+function bt(t, e) {
+  return Math.pow(2, t) * e;
 }
-function retryBackoff(config) {
+function yt(t) {
   const {
-    initialInterval,
-    maxRetries = Infinity,
-    maxInterval = Infinity,
-    shouldRetry = () => true,
-    resetOnSuccess = false,
-    backoffDelay = exponentialBackoffDelay
-  } = typeof config === "number" ? { initialInterval: config } : config;
-  return (source) => defer(() => {
-    let index = 0;
-    return source.pipe(
-      retryWhen((errors) => {
-        return errors.pipe(
-          concatMap((error) => {
-            const attempt = index++;
-            return iif(
-              () => attempt < maxRetries && shouldRetry(attempt, error),
-              timer(
-                getDelay(backoffDelay(attempt, initialInterval), maxInterval)
-              ),
-              throwError(error)
-            );
-          })
+    initialInterval: e,
+    maxRetries: r = 1 / 0,
+    maxInterval: n = 1 / 0,
+    shouldRetry: s = () => !0,
+    resetOnSuccess: i = !1,
+    backoffDelay: u = bt
+  } = t;
+  return (l) => se(() => {
+    let f = 0;
+    const d = (h, g) => h < r && s(h, g);
+    return l.pipe(
+      Ce((h) => {
+        var a;
+        if (f++, !d(f - 1, h))
+          throw h;
+        const g = (a = t.caughtError) == null ? void 0 : a.call(t, f, h);
+        if (!g)
+          throw h;
+        return O(
+          g,
+          Re(() => h)
         );
       }),
-      tap$1(() => {
-        if (resetOnSuccess) {
-          index = 0;
-        }
+      st((h) => h.pipe(
+        it((g) => {
+          const a = f - 1;
+          return Te(
+            () => d(a, g),
+            ie(
+              mt(u(a, e), n)
+            ),
+            Re(() => g)
+          );
+        })
+      )),
+      Ce((h) => {
+        if (t.catchError)
+          return t.catchError(f, h);
+        throw h;
+      }),
+      ut(() => {
+        i && (f = 0);
       })
     );
   });
 }
-const Context = createContext({
+const _e = Ge({
   client: null
-});
-const ClientEffect = ({ client }) => {
-  useEffect(() => {
-    const stop = client.mount();
-    return () => {
-      stop();
-    };
-  }, [client]);
-  return null;
-};
-const QueryClientProvider = memo(
-  ({ children, client }) => {
-    const value = useMemo(() => ({ client }), [client]);
-    return /* @__PURE__ */ jsxs(Context.Provider, { value, children: [
-      /* @__PURE__ */ jsx(ClientEffect, { client: value.client }),
-      children
+}), $t = ({ client: t }) => (K(() => {
+  const e = t.mount();
+  return () => {
+    e();
+  };
+}, [t]), null), br = He(
+  ({ children: t, client: e }) => {
+    const r = ye(() => ({ client: e }), [e]);
+    return /* @__PURE__ */ ct(_e.Provider, { value: r, children: [
+      /* @__PURE__ */ ot($t, { client: r.client }),
+      t
     ] });
   }
-);
-const useQueryClient = ({
-  unsafe = false
+), Pe = ({
+  unsafe: t = !1
 } = {}) => {
-  const context = useContext(Context);
-  if (!unsafe && context.client === null) {
+  const e = De(_e);
+  if (!t && e.client === null)
     throw new Error("You forgot to register the provider");
+  return e.client;
+}, ee = (t) => Array.isArray(t) ? t.reduce((e, r, n) => n === t.length - 1 ? `${e}${ee(r)}]` : `${e}${ee(r)},`, "[") : t === void 0 ? "" : JSON.stringify(t, Object.keys(t).sort()), N = (t) => t.length === 0 ? "[]" : ee(t), Ne = (t = 21) => crypto.getRandomValues(new Uint8Array(t)).reduce((e, r) => (r &= 63, r < 36 ? e += r.toString(36) : r < 62 ? e += (r - 26).toString(36).toUpperCase() : r > 62 ? e += "-" : e += "_", e), ""), W = () => ({
+  context: void 0,
+  data: void 0,
+  error: null,
+  status: "idle",
+  submittedAt: 0,
+  variables: void 0,
+  failureCount: 0,
+  failureReason: null,
+  isPaused: !1
+});
+function G(t) {
+  return t != null;
+}
+function T(t, e) {
+  if (t == null || e === void 0 || typeof t != "object" || typeof e != "object")
+    return t === e;
+  if (t.constructor !== (e == null ? void 0 : e.constructor))
+    return !1;
+  const r = Object.keys(t), n = Object.keys(e);
+  if (r.length !== n.length)
+    return !1;
+  for (const s of r)
+    if (!e.hasOwnProperty(s) || t[s] !== e[s])
+      return !1;
+  return !0;
+}
+function ke(t) {
+  let e = 0;
+  return function(n) {
+    return new Me((s) => {
+      e++, t(e);
+      const i = n.subscribe(s);
+      return () => {
+        e--, t(e), i.unsubscribe();
+      };
+    });
+  };
+}
+class vt {
+  constructor({
+    __queryFinalizeHook: e
+  } = {}) {
+    y(this, "trigger$", new F());
+    y(this, "mapOperator$", new I("merge"));
+    y(this, "state$");
+    const r = new I(0), n = r.pipe(
+      $((i) => i === 0)
+    ), s = this.mapOperator$.pipe(
+      $(G),
+      R()
+    );
+    this.state$ = s.pipe(
+      _((i) => {
+        const u = i === "concat" ? Be : i === "switch" ? w : _, l = this.trigger$.pipe(
+          $(() => i === "merge")
+        );
+        return this.trigger$.pipe(
+          P(s.pipe(B(1))),
+          u(({ args: f, mutation: d }) => {
+            const h = se(() => (d.execute(f), M)), g = d.observeTillFinished().pipe(
+              ge(),
+              _(() => d.state$),
+              P(this.trigger$)
+            ), a = d.observeTillFinished().pipe(B(1));
+            return O(a, g, h).pipe(
+              e ?? le,
+              P(O(n, l))
+            );
+          }),
+          pe((f, d) => ({
+            ...f,
+            ...d,
+            ...d.status === "pending" && {
+              data: d.data ?? f.data
+            },
+            ...d.status === "pending" && {
+              error: d.error ?? f.error
+            }
+          }), W()),
+          R(
+            ({ data: f, ...d }, { data: h, ...g }) => T(d, g) && T(f, h)
+          )
+        );
+      }),
+      $e({
+        refCount: !0,
+        bufferSize: 1
+      }),
+      ke((i) => {
+        r.next(i);
+      })
+    );
   }
-  return context.client;
-};
-const serializeObject = (object) => {
-  if (Array.isArray(object)) {
-    return object.reduce((acc, value, index) => {
-      if (index === object.length - 1)
-        return `${acc}${serializeObject(value)}]`;
-      return `${acc}${serializeObject(value)},`;
-    }, "[");
-  }
-  if (object === void 0)
-    return "";
-  return JSON.stringify(object, Object.keys(object).sort());
-};
-const serializeKey = (key) => {
-  if (key.length === 0)
-    return "[]";
-  return serializeObject(key);
-};
-const nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
-  byte &= 63;
-  if (byte < 36) {
-    id += byte.toString(36);
-  } else if (byte < 62) {
-    id += (byte - 26).toString(36).toUpperCase();
-  } else if (byte > 62) {
-    id += "-";
-  } else {
-    id += "_";
+  trigger({ args: e, options: r, mutation: n }) {
+    r.mapOperator && this.mapOperator$.next(r.mapOperator), this.trigger$.next({ args: e, options: r, mutation: n });
   }
-  return id;
-}, "");
-function noop() {
 }
-function useMutation(options, queryClient) {
-  const defaultQueryClient = useQueryClient({ unsafe: !!queryClient });
-  const finalQueryClient = queryClient ?? defaultQueryClient;
-  const optionsRef = useLiveRef(options);
-  const defaultKey = useConstant(() => [nanoid()]);
-  const serializedKey = serializeKey(options.mutationKey ?? defaultKey.current);
-  const mutationsToCancel = useRef([]);
-  const observedMutation = useMemo(() => {
-    return finalQueryClient.mutationObserver.observeBy({
-      mutationKey: optionsRef.current.mutationKey ?? defaultKey.current
-    });
-  }, [serializedKey, defaultKey, finalQueryClient, optionsRef]);
-  const result = useObserve(observedMutation.result$) ?? observedMutation.lastValue;
-  const mutate = useCallback(
-    (mutationArgs) => {
-      finalQueryClient.mutationRunners.mutate({
-        options: {
-          ...optionsRef.current,
-          mutationKey: optionsRef.current.mutationKey ?? defaultKey.current
-        },
-        args: mutationArgs
-      }).catch(noop);
-      const mutation = finalQueryClient.getMutationCache().findLatest({
-        mutationKey: optionsRef.current.mutationKey ?? defaultKey.current
-      });
-      if (mutation) {
-        mutationsToCancel.current.push(mutation);
-      }
-    },
-    [finalQueryClient, serializedKey, defaultKey, optionsRef]
-  );
-  const cancel = useCallback(() => {
-    mutationsToCancel.current.forEach((mutation) => {
-      mutation.cancel();
+const te = (t, e, { exact: r = !1 } = {}) => r ? N(t) === N(e) : t.reduce((n, s, i) => n ? s === void 0 && !t.slice(i, t.length - 1).some((l) => l !== void 0) ? !0 : ee(s) === ee(e[i]) : !1, !0);
+var L;
+class St {
+  constructor(e, r = {}, n) {
+    y(this, "numberOfObservers", 0);
+    y(this, "mutationRunner");
+    de(this, L, new I(void 0));
+    y(this, "observed$");
+    y(this, "result$");
+    y(this, "getObserverResultFromState", (e) => ({
+      ...W(),
+      ...e,
+      isSuccess: e.status === "success",
+      isPending: e.status === "pending",
+      isIdle: e.status === "idle",
+      isError: e.status === "error",
+      mutate: this.mutate,
+      reset: this.reset
+    }));
+    var s;
+    this.client = e, this.options = r, this.options.mutationKey = ((s = this.options) == null ? void 0 : s.mutationKey) ?? [Ne()], this.mutationRunner = n ?? new vt(this.options), this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this), this.result$ = this.mutationRunner.state$.pipe(
+      p((i) => ({
+        state: this.getObserverResultFromState(i),
+        options: {}
+      }))
+    ), k(this, L).pipe(
+      $(G),
+      _(
+        (i) => this.mutationRunner.state$.pipe(
+          P(i.mutation.observeTillFinished().pipe(ge()))
+        )
+      )
+    ).subscribe(), this.observed$ = k(this, L).pipe(
+      w(
+        (i) => (i == null ? void 0 : i.mutation.state$.pipe(
+          p((u) => ({
+            state: this.getObserverResultFromState(u),
+            options: i.options
+          }))
+        )) ?? M
+      ),
+      _(({ state: i, options: u }) => (i.status === "error" && (u != null && u.onError && (u == null || u.onError(
+        i.error,
+        i.variables,
+        i.context
+      )), u != null && u.onSettled && (u == null || u.onSettled(
+        i.data,
+        i.error,
+        i.variables,
+        i.context
+      ))), i.status === "success" && (u != null && u.onSuccess && (u == null || u.onSuccess(
+        i.data,
+        i.variables,
+        i.context
+      )), u != null && u.onSettled && (u == null || u.onSettled(
+        i.data,
+        i.error,
+        i.variables,
+        i.context
+      ))), M))
+    );
+  }
+  setOptions(e) {
+    var n;
+    const r = this.options;
+    this.options = this.client.defaultMutationOptions({
+      mutationKey: this.options.mutationKey,
+      ...e
+    }), (n = k(this, L).getValue()) == null || n.mutation.setOptions(this.options), this.options.mutationKey && r.mutationKey && !te(this.options.mutationKey, r.mutationKey, {
+      exact: !0
+    }) && this.reset();
+  }
+  observe() {
+    var n;
+    const e = this.getObserverResultFromState(
+      ((n = k(this, L).getValue()) == null ? void 0 : n.mutation.state) ?? W()
+    );
+    return { result$: O(this.observed$, this.result$).pipe(
+      p(({ state: s }) => (console.log({ state: s }), s))
+    ), lastValue: e };
+  }
+  /**
+   * @important
+   * Compliance react-query only
+   */
+  subscribe(e) {
+    const r = this.observe().result$.subscribe((n) => {
+      e(n);
     });
-  }, []);
-  useEffect(() => {
     return () => {
-      if (optionsRef.current.cancelOnUnMount) {
-        cancel();
-      }
+      r.unsubscribe();
     };
-  }, [cancel, optionsRef]);
-  return { mutate, cancel, ...result };
-}
-const arrayEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
-function shallowEqual(objA, objB) {
-  if (objA === null || objA === void 0 || objB === void 0) {
-    return objA === objB;
-  }
-  if (typeof objA !== "object" || typeof objB !== "object") {
-    return objA === objB;
   }
-  if (objA.constructor !== (objB == null ? void 0 : objB.constructor)) {
-    return false;
+  async mutate(e, r = {}) {
+    const n = this.client.getMutationCache().build(this.client, this.options);
+    return k(this, L).next({ mutation: n, options: r }), this.mutationRunner.trigger({
+      args: e,
+      options: this.options,
+      mutation: n
+    }), await new Promise((s, i) => {
+      n.observeTillFinished().pipe(ge()).subscribe({
+        error: (u) => {
+          i(u);
+        },
+        next: (u) => {
+          u.error ? i(u.error) : s(u.data);
+        }
+      });
+    });
   }
-  const keysA = Object.keys(objA);
-  const keysB = Object.keys(objB);
-  if (keysA.length !== keysB.length) {
-    return false;
+  getCurrentResult() {
+    var r;
+    const e = this.client.getMutationCache().find({ exact: !0, mutationKey: (r = this.options) == null ? void 0 : r.mutationKey });
+    return this.getObserverResultFromState(
+      (e == null ? void 0 : e.state) ?? W()
+    );
   }
-  for (const key of keysA) {
-    if (!objB.hasOwnProperty(key) || objA[key] !== objB[key]) {
-      return false;
-    }
+  reset() {
+    var e;
+    (e = k(this, L).getValue()) == null || e.mutation.reset();
   }
-  return true;
 }
-function isDefined(arg) {
-  return arg !== null && arg !== void 0;
+L = new WeakMap();
+function wt() {
 }
-const createActivityTrigger = (params$) => {
-  return params$.pipe(
-    switchMap(({ options: { refetchOnWindowFocus = true } }) => {
-      const shouldRunTrigger = typeof refetchOnWindowFocus === "function" ? refetchOnWindowFocus({}) : refetchOnWindowFocus;
-      return shouldRunTrigger !== false ? merge(
-        fromEvent(document, "visibilitychange").pipe(
-          filter(() => !document.hidden),
-          map(() => ({
-            type: "refetch",
-            ignoreStale: shouldRunTrigger === "always"
-          }))
-        ),
-        fromEvent(window, "focus").pipe(
-          map(() => ({
-            type: "refetch",
-            ignoreStale: shouldRunTrigger === "always"
-          }))
-        )
-      ) : EMPTY;
-    })
+function yr(t, e) {
+  const r = Pe({ unsafe: !!e }), n = e ?? r, s = U(t), i = we(() => [Ne()]), u = N(t.mutationKey ?? i.current), [l] = Xe(
+    () => new St(
+      n,
+      t
+    )
   );
-};
-const createNetworkTrigger = (params$) => {
-  return params$.pipe(
-    switchMap(({ options: { refetchOnReconnect = true } }) => {
-      const shouldRunTrigger = typeof refetchOnReconnect === "function" ? refetchOnReconnect({}) : refetchOnReconnect;
-      return shouldRunTrigger !== false ? fromEvent(window, "online").pipe(
-        map(() => ({
+  K(() => {
+    l.setOptions(t);
+  }, [l, t]);
+  const f = ye(() => l.observe(), [u, l]), d = fe(f.result$) ?? f.lastValue, h = Y(
+    (g, a) => {
+      l.mutate(g, a).catch(wt);
+    },
+    [l]
+  );
+  return K(() => () => {
+    s.current.cancelOnUnMount && l.reset();
+  }, [l, s]), { ...d, mutate: h, mutateAsync: d.mutate };
+}
+const Le = (t, e) => t.length === e.length && t.every((r, n) => r === e[n]), Ot = (t) => t.pipe(
+  w(({ options: { refetchOnWindowFocus: e = !0 } }) => {
+    const r = typeof e == "function" ? e({}) : e;
+    return r !== !1 ? O(
+      me(document, "visibilitychange").pipe(
+        $(() => !document.hidden),
+        p(() => ({
           type: "refetch",
-          ignoreStale: shouldRunTrigger === "always"
+          ignoreStale: r === "always"
         }))
-      ) : EMPTY;
-    })
-  );
-};
-const useQueryParams = ({
-  queryKey,
-  queryFn,
-  ...options
+      ),
+      me(window, "focus").pipe(
+        p(() => ({
+          type: "refetch",
+          ignoreStale: r === "always"
+        }))
+      )
+    ) : M;
+  })
+), Et = (t) => t.pipe(
+  w(({ options: { refetchOnReconnect: e = !0 } }) => {
+    const r = typeof e == "function" ? e({}) : e;
+    return r !== !1 ? me(window, "online").pipe(
+      p(() => ({
+        type: "refetch",
+        ignoreStale: r === "always"
+      }))
+    ) : M;
+  })
+), Rt = ({
+  queryKey: t,
+  queryFn: e,
+  ...r
 }) => {
-  const params$ = useBehaviorSubject({ queryKey, options, queryFn });
-  useEffect(() => {
-    params$.current.next({
-      queryKey,
-      options,
-      queryFn
+  const n = lt({ queryKey: t, options: r, queryFn: e });
+  return K(() => {
+    n.current.next({
+      queryKey: t,
+      options: r,
+      queryFn: e
     });
-  }, [queryKey, options, queryFn, params$]);
-  return params$;
-};
-const defaultValue = {
+  }, [t, r, e, n]), n;
+}, Ct = {
   data: void 0,
-  isLoading: true,
+  isLoading: !0,
   error: void 0,
   status: "loading",
   fetchStatus: "idle"
 };
-function useQuery({
-  queryKey,
-  queryFn,
-  ...options
+function $r({
+  queryKey: t,
+  queryFn: e,
+  ...r
 }) {
-  const internalRefresh$ = useSubject();
-  const client = useQueryClient();
-  const params$ = useQueryParams({ queryFn, queryKey, ...options });
-  const result = useObserve(
+  const n = Oe(), s = Pe(), i = Rt({ queryFn: e, queryKey: t, ...r }), u = fe(
     () => {
-      const key$ = params$.current.pipe(map(({ queryKey: queryKey2 }) => queryKey2 ?? []));
-      const initialTrigger$ = of(null);
-      const newKeyTrigger$ = key$.pipe(
-        distinctUntilChanged(arrayEqual),
-        skip(1)
-      );
-      const isQueryObject = (query) => !!query && typeof query !== "function";
-      const newObservableObjectQuery$ = params$.current.pipe(
-        map(({ queryFn: queryFn2 }) => queryFn2),
-        filter(isQueryObject),
-        distinctUntilChanged(shallowEqual),
-        isQueryObject(params$.current.getValue().queryFn) ? skip(1) : identity
-      );
-      const fn$ = params$.current.pipe(
-        map(({ queryFn: queryFn2 }) => queryFn2),
-        filter(isDefined)
+      const f = i.current.pipe(p(({ queryKey: v }) => v ?? [])), d = S(null), h = f.pipe(
+        R(Le),
+        B(1)
+      ), g = (v) => !!v && typeof v != "function", a = i.current.pipe(
+        p(({ queryFn: v }) => v),
+        $(g),
+        R(T),
+        g(i.current.getValue().queryFn) ? B(1) : le
+      ), c = i.current.pipe(
+        p(({ queryFn: v }) => v),
+        $(G)
+      ), o = i.current.pipe(p(({ options: v }) => v)), m = Ot(i.current), C = Et(i.current), b = O(
+        d,
+        h,
+        a
+      ), j = O(
+        n.current,
+        O(m, C).pipe(Ve(500))
       );
-      const options$ = params$.current.pipe(map(({ options: options2 }) => options2));
-      const activityRefetch$ = createActivityTrigger(params$.current);
-      const networkRefetch$ = createNetworkTrigger(params$.current);
-      const newQueryTrigger$ = merge(
-        initialTrigger$,
-        newKeyTrigger$,
-        newObservableObjectQuery$
-      );
-      const trigger$ = merge(
-        internalRefresh$.current,
-        merge(activityRefetch$, networkRefetch$).pipe(throttleTime(500))
-      );
-      return newQueryTrigger$.pipe(
-        withLatestFrom(key$),
-        switchMap(([, key]) => {
-          const { result$ } = client.client.query({
-            key,
-            fn$,
-            options$,
-            trigger$
+      return b.pipe(
+        D(f),
+        w(([, v]) => {
+          const { result$: E } = s.client.query({
+            key: v,
+            fn$: c,
+            options$: o,
+            trigger$: j
           });
-          return result$.pipe(
-            scan(
-              (previousValue, { data: currentData, ...currentValue }) => ({
+          return E.pipe(
+            pe(
+              (Q, { data: z, ...Ee }) => ({
                 data: void 0,
-                ...previousValue,
-                ...currentValue,
-                isLoading: currentValue.status === "loading",
-                ...currentData && {
-                  data: currentData.result
+                ...Q,
+                ...Ee,
+                isLoading: Ee.status === "loading",
+                ...z && {
+                  data: z.result
                 }
               }),
               {}
@@ -669,53 +681,49 @@ function useQuery({
     },
     {
       defaultValue: {
-        ...defaultValue,
-        isLoading: params$.current.getValue().options.enabled !== false
+        ...Ct,
+        isLoading: i.current.getValue().options.enabled !== !1
       }
     },
-    [client]
-  );
-  const refetch = useCallback(() => {
-    internalRefresh$.current.next({ type: "refetch", ignoreStale: true });
-  }, [internalRefresh$]);
-  return { ...result, refetch };
+    [s]
+  ), l = Y(() => {
+    n.current.next({ type: "refetch", ignoreStale: !0 });
+  }, [n]);
+  return { ...u, refetch: l };
 }
-function useSubscribeEffect(source, unsafeOptions, deps = []) {
-  const options = unsafeOptions != null && !Array.isArray(unsafeOptions) ? unsafeOptions : {};
-  const retryOption = options.retry ?? true;
-  const isSourceFn = typeof source === "function";
-  const makeObservable = useCallback(
-    isSourceFn ? source : () => source,
-    isSourceFn ? deps : [source]
-  );
-  const enhancerMakeObservable = useCallback(
-    () => makeObservable().pipe(
-      catchError((error) => {
-        console.error(error);
-        throw error;
+function vr(t, e, r = []) {
+  const s = (e != null && !Array.isArray(e) ? e : {}).retry ?? !0, i = typeof t == "function", u = Y(
+    i ? t : () => t,
+    i ? r : [t]
+  ), l = Y(
+    () => u().pipe(
+      A((f) => {
+        throw console.error(f), f;
       }),
-      retryOption ? retry() : identity
+      s ? et() : le
     ),
-    [makeObservable, retryOption]
+    [u, s]
   );
-  useSubscribe(enhancerMakeObservable, deps);
+  Se(l, r);
 }
-const retryOnError = (options) => retryBackoff({
-  initialInterval: 100,
-  ...typeof options.retry === "function" ? {
-    shouldRetry: options.retry
+const Ue = ({
+  retryDelay: t,
+  retry: e,
+  ...r
+}) => yt({
+  initialInterval: typeof t == "number" ? t : 100,
+  ...typeof e == "function" ? {
+    shouldRetry: e
   } : {
-    maxRetries: options.retry === false ? 0 : options.retry ?? 3
-  }
-});
-const mergeResults$1 = (stream$) => stream$.pipe(
-  scan(
-    (acc, current) => {
-      return {
-        ...acc,
-        ...current
-      };
-    },
+    maxRetries: e === !1 ? 0 : e ?? 0
+  },
+  ...r
+}), xt = (t) => t.pipe(
+  pe(
+    (e, r) => ({
+      ...e,
+      ...r
+    }),
     {
       data: void 0,
       error: void 0,
@@ -723,347 +731,273 @@ const mergeResults$1 = (stream$) => stream$.pipe(
       status: "loading"
     }
   ),
-  distinctUntilChanged(
-    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
+  R(
+    ({ data: e, ...r }, { data: n, ...s }) => T(r, s) && T(e, n)
   )
-);
-const resetStyle = { backgroundColor: "transparent", color: "inherit" };
-function createLogger(env) {
-  const _logger = {
+), Vt = { backgroundColor: "transparent", color: "inherit" };
+function je(t) {
+  const e = {
     namespaces: [
       {
         name: "@reactjrx",
         style: { backgroundColor: "#d02f4e", color: "white" }
       }
     ],
-    namespace(name, style) {
-      const logger2 = createLogger(env);
-      logger2.namespaces.push({
-        name,
-        style: style ?? resetStyle
-      });
-      return logger2;
+    namespace(r, n) {
+      const s = je(t);
+      return s.namespaces.push({
+        name: r,
+        style: n ?? Vt
+      }), s;
     },
     printNamespaces() {
       return {
-        namespaces: _logger.namespaces.map(({ name }) => `%c ${name} %c`).join(" "),
-        styles: _logger.namespaces.reduce((acc, { style }) => {
-          acc.push(
-            `background-color: ${style.backgroundColor}; color: ${style.color};`
-          );
-          acc.push("background-color: transparent; color: inherit;");
-          return acc;
-        }, [])
+        namespaces: e.namespaces.map(({ name: r }) => `%c ${r} %c`).join(" "),
+        styles: e.namespaces.reduce((r, { style: n }) => (r.push(
+          `background-color: ${n.backgroundColor}; color: ${n.color};`
+        ), r.push("background-color: transparent; color: inherit;"), r), [])
       };
     },
-    print(method, ...message) {
-      if (env === "development") {
-        const { namespaces, styles } = _logger.printNamespaces();
-        console[method](namespaces, ...styles, ...message);
+    print(r, ...n) {
+      if (t === "development") {
+        const { namespaces: s, styles: i } = e.printNamespaces();
+        console[r](s, ...i, ...n);
       }
-      return _logger;
+      return e;
     },
-    printWithoutNamespace(method, ...message) {
-      if (env === "development") {
-        console[method](...message);
-      }
-      return _logger;
+    printWithoutNamespace(r, ...n) {
+      return t === "development" && console[r](...n), e;
     },
-    log(...message) {
-      return _logger.print("log", ...message);
+    log(...r) {
+      return e.print("log", ...r);
     },
-    warn(...message) {
-      return _logger.print("warn", ...message);
+    warn(...r) {
+      return e.print("warn", ...r);
     },
-    error(...message) {
-      return _logger.print("error", ...message);
+    error(...r) {
+      return e.print("error", ...r);
     },
-    group(...message) {
-      return _logger.print("group", ...message);
+    group(...r) {
+      return e.print("group", ...r);
     },
     groupEnd() {
-      if (env === "development") {
-        console.groupEnd();
-      }
-      return _logger;
+      return t === "development" && console.groupEnd(), e;
     }
   };
-  return _logger;
+  return e;
 }
-const Logger = createLogger("production");
-const logger$3 = Logger.namespace("store");
-const createDebugger = (store$) => {
-  return store$.pipe(
-    map(
-      (value) => [...value.keys()].reduce((acc, key) => {
-        var _a;
-        acc[key] = (_a = value.get(key)) == null ? void 0 : _a.getValue();
-        return acc;
-      }, {})
-    ),
-    distinctUntilChanged(shallowEqual)
-  ).subscribe((value) => {
-    logger$3.log("store", "update", value);
-  });
-};
-const createQueryStore = () => {
-  const store = /* @__PURE__ */ new Map();
-  const store$ = new BehaviorSubject(store);
-  const queryEventSubject = new Subject();
-  const queryTriggerSubject = new Subject();
-  const notify = () => {
-    store$.next(store);
-  };
-  const setValue = (key, value) => {
-    store.set(key, new BehaviorSubject(value));
-    notify();
-  };
-  const getValue = (serializedKey) => {
-    var _a;
-    return (_a = store.get(serializedKey)) == null ? void 0 : _a.getValue();
-  };
-  const getValue$ = (key) => {
-    return store$.pipe(
-      map(() => store.get(key)),
-      filter(isDefined),
-      map((entry) => entry.getValue()),
-      distinctUntilChanged(shallowEqual)
-    );
-  };
-  const updateValue = (key, value) => {
-    const existingObject = store.get(key);
-    if (!existingObject)
-      return;
-    if (typeof value === "function") {
-      existingObject.next({
-        ...existingObject.getValue(),
-        ...value(existingObject.getValue())
-      });
-    } else {
-      existingObject.next({ ...existingObject.getValue(), ...value });
-    }
-    store$.next(store);
-  };
-  const updateMany = (value, predicate = () => true) => {
-    store.forEach((oldValue$) => {
-      const oldValue = oldValue$.getValue();
-      if (predicate(oldValue)) {
-        oldValue$.next({ ...oldValue, ...value });
-      }
-    });
-    store$.next(store);
-  };
-  const deleteValue = (key) => {
-    store.delete(key);
-    store$.next(store);
-  };
-  const addRunner = (key, stream) => {
-    updateValue(key, (old) => ({
-      ...old,
-      runners: [...old.runners, stream]
+const X = je("production"), Tt = X.namespace("store"), Mt = (t) => t.pipe(
+  p(
+    (e) => [...e.keys()].reduce((r, n) => {
+      var s;
+      return r[n] = (s = e.get(n)) == null ? void 0 : s.getValue(), r;
+    }, {})
+  ),
+  R(T)
+).subscribe((e) => {
+  Tt.log("store", "update", e);
+}), It = () => {
+  const t = /* @__PURE__ */ new Map(), e = new I(t), r = new F(), n = new F(), s = () => {
+    e.next(t);
+  }, i = (c, o) => {
+    t.set(c, new I(o)), s();
+  }, u = (c) => {
+    var o;
+    return (o = t.get(c)) == null ? void 0 : o.getValue();
+  }, l = (c) => e.pipe(
+    p(() => t.get(c)),
+    $(G),
+    p((o) => o.getValue()),
+    R(T)
+  ), f = (c, o) => {
+    const m = t.get(c);
+    m && (typeof o == "function" ? m.next({
+      ...m.getValue(),
+      ...o(m.getValue())
+    }) : m.next({ ...m.getValue(), ...o }), e.next(t));
+  }, d = (c, o = () => !0) => {
+    t.forEach((m) => {
+      const C = m.getValue();
+      o(C) && m.next({ ...C, ...c });
+    }), e.next(t);
+  }, h = (c) => {
+    t.delete(c), e.next(t);
+  }, g = (c, o) => (f(c, (m) => ({
+    ...m,
+    runners: [...m.runners, o]
+  })), () => {
+    var C;
+    const m = ((C = t.get(c)) == null ? void 0 : C.getValue().runners.filter((b) => b !== o)) ?? [];
+    f(c, (b) => ({
+      ...b,
+      runners: m
     }));
+  }), a = () => {
+    const c = Mt(e);
     return () => {
-      var _a;
-      const newListeners = ((_a = store.get(key)) == null ? void 0 : _a.getValue().runners.filter((reference) => reference !== stream)) ?? [];
-      updateValue(key, (old) => ({
-        ...old,
-        runners: newListeners
-      }));
-    };
-  };
-  const start = () => {
-    const debugger$ = createDebugger(store$);
-    return () => {
-      debugger$.unsubscribe();
+      c.unsubscribe();
     };
   };
   return {
-    set: setValue,
-    get: getValue,
-    get$: getValue$,
-    delete: deleteValue,
-    update: updateValue,
-    keys: () => store.keys(),
-    updateMany,
-    addRunner,
-    store$,
-    queryEvent$: queryEventSubject.asObservable(),
-    dispatchQueryEvent: (event) => {
-      queryEventSubject.next(event);
+    set: i,
+    get: u,
+    get$: l,
+    delete: h,
+    update: f,
+    keys: () => t.keys(),
+    updateMany: d,
+    addRunner: g,
+    store$: e,
+    queryEvent$: r.asObservable(),
+    dispatchQueryEvent: (c) => {
+      r.next(c);
     },
-    queryTrigger$: queryTriggerSubject.asObservable(),
-    dispatchQueryTrigger: (event) => {
-      queryTriggerSubject.next(event);
+    queryTrigger$: n.asObservable(),
+    dispatchQueryTrigger: (c) => {
+      n.next(c);
     },
-    size: () => store.size,
-    start
+    size: () => t.size,
+    start: a
   };
-};
-const createQueryTrigger = ({
-  options$,
-  queryStore,
-  key
+}, Qt = ({
+  options$: t,
+  queryStore: e,
+  key: r
 }) => {
-  const enabledOption$ = options$.pipe(
-    map(({ enabled = true }) => enabled),
-    distinctUntilChanged()
+  const s = t.pipe(
+    p(({ enabled: i = !0 }) => i),
+    R()
+  ).pipe(
+    B(1),
+    $((i) => i)
   );
-  const enabledTrigger$ = enabledOption$.pipe(
-    skip(1),
-    filter((enabled) => enabled)
-  );
-  return merge(
-    queryStore.queryTrigger$.pipe(
-      filter((event) => key === event.key),
-      map(({ trigger: trigger2 }) => trigger2)
+  return O(
+    e.queryTrigger$.pipe(
+      $((i) => r === i.key),
+      p(({ trigger: i }) => i)
     ),
-    enabledTrigger$.pipe(
-      map(() => ({
+    s.pipe(
+      p(() => ({
         type: "enabled",
-        ignoreStale: false
+        ignoreStale: !1
       }))
     )
   );
-};
-const deduplicate = (key, queryStore) => (source) => {
-  if (key === serializeKey([]))
-    return source;
-  return defer(() => {
-    var _a;
-    const sourceFromStore = (_a = queryStore.get(key)) == null ? void 0 : _a.deduplication_fn;
-    if (sourceFromStore)
-      return sourceFromStore;
-    let sourceToDeduplicate;
-    const deleteFromStore = () => {
-      var _a2;
-      if (((_a2 = queryStore.get(key)) == null ? void 0 : _a2.deduplication_fn) === sourceToDeduplicate) {
-        queryStore.update(key, {
-          deduplication_fn: void 0
-        });
-      }
-    };
-    sourceToDeduplicate = source.pipe(
-      /**
-       * Ideally we would want to remove the query from the store only on finalize,
-       * which means whenever the query complete or error. Unfortunately finalize is
-       * triggered after a new stream arrive which create a concurrency issue.
-       * tap is triggered correctly synchronously and before a new query arrive.
-       */
-      tap({
-        error: deleteFromStore,
-        complete: deleteFromStore
-      }),
-      /**
-       * Because tap is not called on unsubscription we still need to handle the case.
-       */
-      finalize(deleteFromStore),
-      shareReplay({
-        refCount: true,
-        bufferSize: 1
-      })
-    );
-    queryStore.update(key, {
-      deduplication_fn: sourceToDeduplicate
+}, Ft = (t, e) => (r) => t === N([]) ? r : se(() => {
+  var u;
+  const n = (u = e.get(t)) == null ? void 0 : u.deduplication_fn;
+  if (n)
+    return n;
+  let s;
+  const i = () => {
+    var l;
+    ((l = e.get(t)) == null ? void 0 : l.deduplication_fn) === s && e.update(t, {
+      deduplication_fn: void 0
     });
-    return sourceToDeduplicate;
-  });
-};
-const notifyQueryResult = (options$) => (stream$) => stream$.pipe(
-  withLatestFrom(options$),
-  map(([result, options]) => {
-    var _a, _b;
-    if (result.error) {
-      (_a = options.onError) == null ? void 0 : _a.call(options, result.error);
-    } else {
-      (_b = options.onSuccess) == null ? void 0 : _b.call(options, result);
-    }
-    return result;
+  };
+  return s = r.pipe(
+    /**
+     * Ideally we would want to remove the query from the store only on finalize,
+     * which means whenever the query complete or error. Unfortunately finalize is
+     * triggered after a new stream arrive which create a concurrency issue.
+     * tap is triggered correctly synchronously and before a new query arrive.
+     */
+    x({
+      error: i,
+      complete: i
+    }),
+    /**
+     * Because tap is not called on unsubscription we still need to handle the case.
+     */
+    ae(i),
+    $e({
+      refCount: !0,
+      bufferSize: 1
+    })
+  ), e.update(t, {
+    deduplication_fn: s
+  }), s;
+}), _t = (t) => (e) => e.pipe(
+  D(t),
+  p(([r, n]) => {
+    var s, i;
+    return r.error ? (s = n.onError) == null || s.call(n, r.error) : (i = n.onSuccess) == null || i.call(n, r), r;
   })
-);
-const registerResultInCache = ({
-  queryStore,
-  serializedKey,
-  options
-}) => (stream) => stream.pipe(
-  tap(({ data }) => {
-    if (data == null ? void 0 : data.result) {
-      const result = data == null ? void 0 : data.result;
-      queryStore.update(serializedKey, {
-        ...options.cacheTime !== 0 && {
-          cache_fnResult: { result }
+), Pt = ({
+  queryStore: t,
+  serializedKey: e,
+  options: r
+}) => (n) => n.pipe(
+  x(({ data: s }) => {
+    if (s != null && s.result) {
+      const i = s == null ? void 0 : s.result;
+      t.update(e, {
+        ...r.cacheTime !== 0 && {
+          cache_fnResult: { result: i }
         }
       });
     }
   })
-);
-const createQueryFetch = ({
-  options$,
-  options,
-  fn,
-  queryStore,
-  serializedKey,
-  trigger: trigger2,
-  trigger$
+), Nt = ({
+  options$: t,
+  options: e,
+  fn: r,
+  queryStore: n,
+  serializedKey: s,
+  trigger: i,
+  trigger$: u
 }) => {
-  const enabledOption$ = options$.pipe(
-    map(({ enabled = true }) => enabled),
-    distinctUntilChanged()
-  );
-  const disabled$ = enabledOption$.pipe(
-    distinctUntilChanged(),
-    filter((enabled) => !enabled)
-  );
-  const deferredQuery = defer(() => {
-    const queryOrResponse = typeof fn === "function" ? fn() : fn;
-    return from(queryOrResponse);
-  });
-  const fnExecution$ = deferredQuery.pipe(
-    retryOnError(options),
-    deduplicate(serializedKey, queryStore),
-    tap(() => {
-      queryStore.dispatchQueryEvent({
-        key: serializedKey,
+  const f = t.pipe(
+    p(({ enabled: b = !0 }) => b),
+    R()
+  ).pipe(
+    R(),
+    $((b) => !b)
+  ), h = se(() => {
+    const b = typeof r == "function" ? r() : r;
+    return ne(b);
+  }).pipe(
+    Ue(e),
+    Ft(s, n),
+    x(() => {
+      n.dispatchQueryEvent({
+        key: s,
         type: "fetchSuccess"
-      });
-      queryStore.update(serializedKey, {
+      }), n.update(s, {
         lastFetchedAt: (/* @__PURE__ */ new Date()).getTime()
       });
     }),
-    map((result) => ({
+    p((b) => ({
       status: "success",
-      data: { result },
+      data: { result: b },
       error: void 0
     })),
-    endWith({
+    tt({
       fetchStatus: "idle"
     }),
-    catchError((error) => {
-      queryStore.dispatchQueryEvent({
-        key: serializedKey,
-        type: "fetchError"
-      });
-      return of({
-        fetchStatus: "idle",
-        status: "error",
-        data: void 0,
-        error
-      });
-    }),
-    notifyQueryResult(options$),
-    registerResultInCache({ serializedKey, options, queryStore })
-  );
-  const newCache$ = queryStore.queryEvent$.pipe(
-    filter(
-      (event) => event.key === serializedKey && event.type === "queryDataSet"
+    A((b) => (n.dispatchQueryEvent({
+      key: s,
+      type: "fetchError"
+    }), S({
+      fetchStatus: "idle",
+      status: "error",
+      data: void 0,
+      error: b
+    }))),
+    _t(t),
+    Pt({ serializedKey: s, options: e, queryStore: n })
+  ), g = n.queryEvent$.pipe(
+    $(
+      (b) => b.key === s && b.type === "queryDataSet"
     ),
-    map(() => {
-      var _a, _b;
-      return (_b = (_a = queryStore.get(serializedKey)) == null ? void 0 : _a.cache_fnResult) == null ? void 0 : _b.result;
+    p(() => {
+      var b, j;
+      return (j = (b = n.get(s)) == null ? void 0 : b.cache_fnResult) == null ? void 0 : j.result;
     }),
-    filter(isDefined),
-    map((result) => ({
+    $(G),
+    p((b) => ({
       status: "success",
-      data: { result }
+      data: { result: b }
     })),
     /**
      * @important
@@ -1071,815 +1005,574 @@ const createQueryFetch = ({
      * For example if user set query data inside onSuccess callback, we simulate
      * a small delay to ensure it happens after.
      */
-    delay(1)
-  );
-  const execution$ = merge(
-    disabled$.pipe(
-      take(1),
-      map(() => ({
+    rt(1)
+  ), a = O(
+    f.pipe(
+      be(1),
+      p(() => ({
         fetchStatus: "idle"
       }))
     ),
-    merge(
-      of({ fetchStatus: "fetching", error: void 0 }),
-      fnExecution$
-    ).pipe(takeUntil(disabled$)),
-    newCache$
-  ).pipe(takeUntil(trigger$));
-  const query = queryStore.get(serializedKey);
-  const cacheResult = query == null ? void 0 : query.cache_fnResult;
-  const hasCache = !!cacheResult;
-  const ignoreStale = trigger2.type === "refetch" && trigger2.ignoreStale;
-  if (hasCache) {
-    if (!(query == null ? void 0 : query.isStale) && !ignoreStale) {
-      return of({
-        fetchStatus: "idle",
-        status: "success",
-        data: { result: cacheResult.result },
-        error: void 0
-      });
-    } else {
-      return merge(
-        of({
-          fetchStatus: "fetching",
-          status: "success",
-          data: { result: cacheResult.result },
-          error: void 0
-        }),
-        execution$
-      );
-    }
-  }
-  return execution$;
-};
-const compareKeys = (keyA, keyB, { exact = false } = {}) => {
-  if (exact) {
-    return serializeKey(keyA) === serializeKey(keyB);
-  }
-  return keyA.reduce((acc, value, index) => {
-    if (!acc)
-      return false;
-    if (value === void 0) {
-      const hasNextItemInLineNotUndefined = keyA.slice(index, keyA.length - 1).some((item) => item !== void 0);
-      if (!hasNextItemInLineNotUndefined) {
-        return true;
-      }
-    }
-    return serializeObject(value) === serializeObject(keyB[index]);
-  }, true);
-};
-const logger$2 = Logger.namespace("invalidation");
-const createInvalidationClient = ({
-  queryStore
-}) => {
-  const invalidateQueries = ({
-    queryKey,
-    exact = false,
-    predicate
+    O(
+      S({ fetchStatus: "fetching", error: void 0 }),
+      h
+    ).pipe(P(f)),
+    g
+  ).pipe(P(u)), c = n.get(s), o = c == null ? void 0 : c.cache_fnResult, m = !!o, C = i.type === "refetch" && i.ignoreStale;
+  return m ? !(c != null && c.isStale) && !C ? S({
+    fetchStatus: "idle",
+    status: "success",
+    data: { result: o.result },
+    error: void 0
+  }) : O(
+    S({
+      fetchStatus: "fetching",
+      status: "success",
+      data: { result: o.result },
+      error: void 0
+    }),
+    a
+  ) : a;
+}, q = X.namespace("invalidation"), kt = ({
+  queryStore: t
+}) => ({
+  invalidateQueries: ({
+    queryKey: r,
+    exact: n = !1,
+    predicate: s
   } = {}) => {
-    let keysToRefetch = [];
-    if (queryKey) {
-      logger$2.log(`invalidation requested for`, queryKey);
-      queryStore.updateMany({ isStale: true }, (entry) => {
-        const isValid = compareKeys(queryKey, entry.queryKey, { exact });
-        if (isValid) {
-          keysToRefetch.push(serializeKey(entry.queryKey));
-        }
-        return isValid;
-      });
-    } else if (predicate) {
-      queryStore.updateMany({ isStale: true }, (entry) => {
-        const isValid = predicate(entry);
-        if (isValid) {
-          keysToRefetch.push(serializeKey(entry.queryKey));
-        }
-        return isValid;
-      });
-    } else {
-      logger$2.log(`Invalidation requested for all queries`);
-      queryStore.updateMany({ isStale: true });
-      keysToRefetch = Array.from(queryStore.keys());
-    }
-    keysToRefetch.forEach((key) => {
-      queryStore.update(key, {
+    let i = [];
+    r ? (q.log("invalidation requested for", r), t.updateMany({ isStale: !0 }, (u) => {
+      const l = te(r, u.queryKey, { exact: n });
+      return l && i.push(N(u.queryKey)), l;
+    })) : s ? t.updateMany({ isStale: !0 }, (u) => {
+      const l = s(u);
+      return l && i.push(N(u.queryKey)), l;
+    }) : (q.log("Invalidation requested for all queries"), t.updateMany({ isStale: !0 }), i = Array.from(t.keys())), i.forEach((u) => {
+      t.update(u, {
         deduplication_fn: void 0
-      });
-      queryStore.dispatchQueryTrigger({
-        key,
-        trigger: { ignoreStale: true, type: "refetch" }
+      }), t.dispatchQueryTrigger({
+        key: u,
+        trigger: { ignoreStale: !0, type: "refetch" }
       });
     });
-  };
-  return {
-    invalidateQueries
-  };
-};
-const createRefetchClient = (_) => {
-  const pipeQueryResult = ({
-    options$
-  }) => (stream) => {
-    const sharedStream = stream.pipe(share());
-    return merge(
-      sharedStream,
-      sharedStream.pipe(
-        filter(
-          (result) => !!result.data && result.fetchStatus !== "fetching"
+  }
+}), Lt = (t) => ({
+  pipeQueryResult: ({
+    options$: n
+  }) => (s) => {
+    const i = s.pipe(J());
+    return O(
+      i,
+      i.pipe(
+        $(
+          (u) => !!u.data && u.fetchStatus !== "fetching"
         ),
-        distinctUntilChanged((prev, curr) => prev.data === curr.data),
-        withLatestFrom(options$),
-        map(([, { refetchInterval }]) => refetchInterval),
-        filter(isDefined),
-        switchMap((refetchInterval) => {
-          if (typeof refetchInterval === "number") {
-            return timer(refetchInterval).pipe(
-              map(() => ({
-                type: "refetch",
-                ignoreStale: true
-              })),
-              switchMap(() => EMPTY)
-            );
-          }
-          return EMPTY;
-        })
+        R((u, l) => u.data === l.data),
+        D(n),
+        p(([, { refetchInterval: u }]) => u),
+        $(G),
+        w((u) => typeof u == "number" ? ie(u).pipe(
+          p(() => ({
+            type: "refetch",
+            ignoreStale: !0
+          })),
+          w(() => M)
+        ) : M)
       )
     );
-  };
-  const refetchQueries = (_2) => {
-  };
-  return {
-    pipeQueryResult,
-    refetchQueries
-  };
-};
-const difference = (a, b) => a.filter((element) => !b.includes(element));
-const createQueryListener = (store, onQuery) => store.store$.pipe(
-  map((store2) => [...store2.keys()]),
-  startWith([]),
-  pairwise(),
-  mergeMap(([previousKeys, currentKeys]) => {
-    const newKeys = difference(currentKeys, previousKeys);
-    return merge(
-      ...newKeys.map((key) => {
-        const deleted$ = store.store$.pipe(
-          map(() => store.get(key)),
-          filter((item) => item === void 0)
+  },
+  refetchQueries: (n) => {
+  }
+}), Ut = (t, e) => t.filter((r) => !e.includes(r)), jt = (t, e) => t.store$.pipe(
+  p((r) => [...r.keys()]),
+  Ie([]),
+  oe(),
+  _(([r, n]) => {
+    const s = Ut(n, r);
+    return O(
+      ...s.map((i) => {
+        const u = t.store$.pipe(
+          p(() => t.get(i)),
+          $((l) => l === void 0)
         );
-        return merge(NEVER, of(key)).pipe(
-          tap(() => {
+        return O(Qe, S(i)).pipe(
+          x(() => {
           }),
-          onQuery,
-          finalize(() => {
+          e,
+          ae(() => {
           }),
-          takeUntil(deleted$)
+          P(u)
         );
       })
     );
   })
-);
-const mapStoreQueryToRunnerOptions = (stream) => stream.pipe(
-  switchMap((entry) => combineLatest(entry.runners)),
-  map((runnerValues) => runnerValues.map(({ options }) => options))
-);
-const mapOptionsToOption$1 = (stream) => stream.pipe(
-  map(
-    (options) => options.reduce(
-      (acc, value) => {
-        return {
-          ...acc,
-          lowestStaleTime: value.staleTime === void 0 ? acc.lowestStaleTime : Math.min(
-            value.staleTime ?? Infinity,
-            acc.lowestStaleTime ?? Infinity
-          )
-        };
-      },
+), Ae = (t) => t.pipe(
+  w((e) => Fe(e.runners)),
+  p((e) => e.map(({ options: r }) => r))
+), At = (t) => t.pipe(
+  p(
+    (e) => e.reduce(
+      (r, n) => ({
+        ...r,
+        lowestStaleTime: n.staleTime === void 0 ? r.lowestStaleTime : Math.min(
+          n.staleTime ?? 1 / 0,
+          r.lowestStaleTime ?? 1 / 0
+        )
+      }),
       { lowestStaleTime: void 0 }
     )
   ),
-  distinctUntilChanged(shallowEqual)
-);
-const onlyFetchEventDone = (key) => (stream) => stream.pipe(
-  filter(
-    (event) => event.key === key && (event.type === "fetchError" || event.type === "fetchSuccess")
+  R(T)
+), Kt = (t) => (e) => e.pipe(
+  $(
+    (r) => r.key === t && (r.type === "fetchError" || r.type === "fetchSuccess")
   )
-);
-const markAsStale = ({
-  queryStore
-}) => (stream) => stream.pipe(
-  switchMap((key) => {
-    const query$ = queryStore.get$(key);
-    return queryStore.queryEvent$.pipe(
-      onlyFetchEventDone(key),
-      switchMap(
-        () => query$.pipe(
-          mapStoreQueryToRunnerOptions,
-          mapOptionsToOption$1,
-          tap(({ lowestStaleTime = 0 }) => {
-            var _a;
-            if (lowestStaleTime === 0) {
-              logger$2.log(key, "marked as stale!", {
-                staleTime: lowestStaleTime
-              });
-              queryStore.update(key, { isStale: true });
-            } else if ((_a = queryStore.get(key)) == null ? void 0 : _a.isStale) {
-              logger$2.log(key, "marked non stale", {
-                staleTime: lowestStaleTime
-              });
-              queryStore.update(key, { isStale: false });
-            }
+), zt = ({
+  queryStore: t
+}) => (e) => e.pipe(
+  w((r) => {
+    const n = t.get$(r);
+    return t.queryEvent$.pipe(
+      Kt(r),
+      w(
+        () => n.pipe(
+          Ae,
+          At,
+          x(({ lowestStaleTime: s = 0 }) => {
+            var i;
+            s === 0 ? (q.log(r, "marked as stale!", {
+              staleTime: s
+            }), t.update(r, { isStale: !0 })) : (i = t.get(r)) != null && i.isStale && (q.log(r, "marked non stale", {
+              staleTime: s
+            }), t.update(r, { isStale: !1 }));
           }),
-          filter(
-            ({ lowestStaleTime }) => lowestStaleTime !== Infinity && lowestStaleTime !== 0
+          $(
+            ({ lowestStaleTime: s }) => s !== 1 / 0 && s !== 0
           ),
-          switchMap(({ lowestStaleTime = 0 }) => timer(lowestStaleTime)),
-          tap(() => {
-            var _a;
-            if (!((_a = queryStore.get(key)) == null ? void 0 : _a.isStale)) {
-              logger$2.log(key, "marked as stale!");
-              queryStore.update(key, { isStale: true });
-            }
+          w(({ lowestStaleTime: s = 0 }) => ie(s)),
+          x(() => {
+            var s;
+            (s = t.get(r)) != null && s.isStale || (q.log(r, "marked as stale!"), t.update(r, { isStale: !0 }));
           })
         )
       ),
-      map(() => key)
+      p(() => r)
     );
   })
-);
-const mapOptionsToOption = (stream) => stream.pipe(
-  map(
-    (options) => options.reduce(
-      (acc, value) => {
-        return {
-          ...acc,
-          lowestCacheTime: value.cacheTime === void 0 ? acc.lowestCacheTime : Math.min(
-            value.cacheTime ?? Infinity,
-            acc.lowestCacheTime ?? Infinity
-          )
-        };
-      },
+), Jt = (t) => t.pipe(
+  p(
+    (e) => e.reduce(
+      (r, n) => ({
+        ...r,
+        lowestCacheTime: n.cacheTime === void 0 ? r.lowestCacheTime : Math.min(
+          n.cacheTime ?? 1 / 0,
+          r.lowestCacheTime ?? 1 / 0
+        )
+      }),
       { lowestCacheTime: void 0 }
     )
   ),
-  distinctUntilChanged(shallowEqual)
-);
-const onCacheUpdate = (stream) => stream.pipe(
-  map((item) => item.cache_fnResult),
-  distinctUntilChanged(shallowEqual)
-);
-const invalidateCache = ({
-  queryStore
-}) => (stream) => stream.pipe(
-  switchMap((key) => {
-    const query$ = queryStore.get$(key);
-    const invalidateCache$ = query$.pipe(
-      onCacheUpdate,
-      switchMap(
-        () => query$.pipe(
-          mapStoreQueryToRunnerOptions,
-          mapOptionsToOption,
-          switchMap(
+  R(T)
+), Wt = (t) => t.pipe(
+  p((e) => e.cache_fnResult),
+  R(T)
+), Yt = ({
+  queryStore: t
+}) => (e) => e.pipe(
+  w((r) => {
+    const n = t.get$(r);
+    return n.pipe(
+      Wt,
+      w(
+        () => n.pipe(
+          Ae,
+          Jt,
+          w(
             ({
-              lowestCacheTime = 5 * 60 * 1e3
+              lowestCacheTime: i = 5 * 60 * 1e3
               /* 5mn */
-            }) => timer(lowestCacheTime).pipe(
-              tap(() => {
-                queryStore.update(key, { cache_fnResult: void 0 });
+            }) => ie(i).pipe(
+              x(() => {
+                t.update(r, { cache_fnResult: void 0 });
               })
             )
           )
         )
       )
-    );
-    return invalidateCache$.pipe(map(() => key));
+    ).pipe(p(() => r));
   })
-);
-const garbageCache = ({
-  queryStore
-}) => (stream) => stream.pipe(
-  switchMap((key) => {
-    const query$ = queryStore.get$(key);
-    return query$.pipe(
-      filter((entry) => !entry.cache_fnResult),
-      map((entry) => entry.runners.length > 0),
-      pairwise(),
-      filter(([hadRunners, hasRunners]) => hadRunners && !hasRunners),
-      tap(() => {
-        queryStore.delete(key);
-      }),
-      map(() => key)
-    );
-  })
-);
-const getInitialQueryEntity = ({ key }) => ({
-  isStale: true,
-  queryKey: key,
+), Gt = ({
+  queryStore: t
+}) => (e) => e.pipe(
+  w((r) => t.get$(r).pipe(
+    $((s) => !s.cache_fnResult),
+    p((s) => s.runners.length > 0),
+    oe(),
+    $(([s, i]) => s && !i),
+    x(() => {
+      t.delete(r);
+    }),
+    p(() => r)
+  ))
+), Ke = ({ key: t }) => ({
+  isStale: !0,
+  queryKey: t,
   runners: []
-});
-const updateStoreWithNewQuery = ({
-  queryStore,
-  serializedKey,
-  runner$,
-  options$,
-  key
-}) => (stream) => stream.pipe(
-  withLatestFrom(options$),
-  map(([trigger2, options]) => {
-    if (key.length === 0)
-      return [trigger2, void 0];
-    if (trigger2.type !== "initial")
-      return [trigger2, void 0];
-    if (!queryStore.get(serializedKey)) {
-      queryStore.set(serializedKey, getInitialQueryEntity({ key }));
-    } else {
-      queryStore.update(serializedKey, {
-        queryKey: key,
-        ...options.markStale && {
-          isStale: true
-        }
-      });
+}), Ht = ({
+  queryStore: t,
+  serializedKey: e,
+  runner$: r,
+  options$: n,
+  key: s
+}) => (i) => i.pipe(
+  D(n),
+  p(([u, l]) => s.length === 0 ? [u, void 0] : u.type !== "initial" ? [u, void 0] : (t.get(e) ? t.update(e, {
+    queryKey: s,
+    ...l.markStale && {
+      isStale: !0
     }
-    return [trigger2, queryStore.addRunner(serializedKey, runner$)];
-  })
-);
-const logger$1 = Logger.namespace("cache");
-const createCacheClient = ({
-  queryStore
-}) => {
-  const setQueryData = ({
-    queryKey,
-    updater
+  }) : t.set(e, Ke({ key: s })), [u, t.addRunner(e, r)]))
+), Dt = X.namespace("cache"), Xt = ({
+  queryStore: t
+}) => ({
+  setQueryData: ({
+    queryKey: r,
+    updater: n
   }) => {
-    const serializedKey = serializeKey(queryKey);
-    if (queryKey.length === 0)
-      return;
-    logger$1.log("set cache for query", serializeKey);
-    if (!queryStore.get(serializedKey)) {
-      queryStore.set(serializedKey, getInitialQueryEntity({ key: queryKey }));
-    }
-    queryStore.update(serializedKey, (entity) => {
-      var _a;
-      if (typeof updater === "function") {
-        const callableUpdater = updater;
-        return {
-          ...entity,
-          cache_fnResult: {
-            result: callableUpdater(
-              (_a = entity.cache_fnResult) == null ? void 0 : _a.result
-            )
-          }
-        };
-      }
-      return {
-        ...entity,
+    const s = N(r);
+    r.length !== 0 && (Dt.log("set cache for query", N), t.get(s) || t.set(s, Ke({ key: r })), t.update(s, (i) => {
+      var u;
+      return typeof n == "function" ? {
+        ...i,
+        cache_fnResult: {
+          result: n(
+            (u = i.cache_fnResult) == null ? void 0 : u.result
+          )
+        }
+      } : {
+        ...i,
         cache_fnResult: {
-          result: updater
+          result: n
         }
       };
-    });
-    queryStore.dispatchQueryEvent({
-      key: serializedKey,
+    }), t.dispatchQueryEvent({
+      key: s,
       type: "queryDataSet"
-    });
-  };
-  return {
-    setQueryData
-  };
-};
-const logger = Logger.namespace("refetch");
-const markQueryAsStaleIfRefetch = ({
-  key,
-  serializedKey,
-  queryStore
-}) => (stream) => {
-  return stream.pipe(
-    tap((trigger2) => {
-      if (trigger2.type !== "refetch")
-        return;
-      const query = queryStore.get(serializedKey);
-      if (query && trigger2.ignoreStale && !query.isStale) {
-        logger.log(key, "marked stale by trigger!");
-        queryStore.update(serializedKey, {
-          isStale: true
-        });
-      }
-    })
-  );
-};
-const dispatchExternalRefetchToAllQueries = ({
-  queryStore,
-  serializedKey
-}) => (stream) => stream.pipe(
-  tap((trigger2) => {
-    if (trigger2.type === "refetch") {
-      queryStore.update(serializedKey, {
-        deduplication_fn: void 0
-      });
-      queryStore.dispatchQueryTrigger({
-        key: serializedKey,
-        trigger: trigger2
-      });
-    }
+    }));
+  }
+}), Zt = X.namespace("refetch"), qt = ({
+  key: t,
+  serializedKey: e,
+  queryStore: r
+}) => (n) => n.pipe(
+  x((s) => {
+    if (s.type !== "refetch")
+      return;
+    const i = r.get(e);
+    i && s.ignoreStale && !i.isStale && (Zt.log(t, "marked stale by trigger!"), r.update(e, {
+      isStale: !0
+    }));
+  })
+), Bt = ({
+  queryStore: t,
+  serializedKey: e
+}) => (r) => r.pipe(
+  x((n) => {
+    n.type === "refetch" && (t.update(e, {
+      deduplication_fn: void 0
+    }), t.dispatchQueryTrigger({
+      key: e,
+      trigger: n
+    }));
   }),
-  filter((trigger2) => trigger2.type !== "refetch")
-);
-const getDefaultMutationState = () => ({
-  context: void 0,
-  data: void 0,
-  error: null,
-  status: "idle",
-  submittedAt: 0,
-  variables: void 0
-});
-const mergeResults = (stream$) => stream$.pipe(
-  scan((acc, current) => {
-    return {
-      ...acc,
-      ...current,
-      data: current.data ?? acc.data,
-      error: current.error ?? acc.error
-    };
-  }, getDefaultMutationState()),
-  distinctUntilChanged(
-    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
-  )
-);
-const createMutationRunner = ({
-  __queryFinalizeHook,
-  __queryInitHook,
-  __queryTriggerHook,
-  mutationKey,
-  mutationCache
+  $((n) => n.type !== "refetch")
+), V = (t) => se(() => {
+  const e = t();
+  return e instanceof Promise ? ne(e) : e instanceof Me ? e : S(e);
+}), er = ({
+  variables: t,
+  state: e,
+  options: r
 }) => {
-  const trigger$ = new Subject();
-  const cancel$ = new Subject();
-  let closed = false;
-  const mapOperator$ = new BehaviorSubject(
-    "merge"
-  );
-  const destroy = () => {
-    if (closed) {
-      throw new Error("Trying to close an already closed mutation");
+  const n = e.isPaused, s = async () => await Promise.reject(new Error("No mutationFn found")), i = r.mutationFn ?? s, l = Te(
+    () => n,
+    S(e.context),
+    V(
+      // eslint-disable-next-line @typescript-eslint/promise-function-async
+      () => {
+        var a;
+        return ((a = r.onMutate) == null ? void 0 : a.call(r, t)) ?? void 0;
+      }
+    )
+  ).pipe(J()), f = (a, c, o) => (console.error(a), V(
+    () => {
+      var C;
+      return (C = r.onError) == null ? void 0 : C.call(r, a, t, c);
     }
-    closed = true;
-    mapOperator$.complete();
-    trigger$.complete();
-    cancel$.next();
-    cancel$.complete();
-  };
-  const stableMapOperator$ = mapOperator$.pipe(
-    filter(isDefined),
-    distinctUntilChanged()
-  );
-  const runner$ = stableMapOperator$.pipe(
-    __queryInitHook ?? identity,
-    mergeMap((mapOperator) => {
-      const switchOperator = mapOperator === "concat" ? concatMap$1 : mapOperator === "switch" ? switchMap : mergeMap;
-      return trigger$.pipe(
-        takeUntil(stableMapOperator$.pipe(skip(1))),
-        switchOperator(({ args }) => {
-          const mutation = mutationCache.findLatest({
-            exact: true,
-            mutationKey
+  ).pipe(
+    A(() => S(a)),
+    p(
+      () => ({
+        failureCount: o,
+        error: a,
+        failureReason: a,
+        context: c,
+        status: "error"
+      })
+    )
+  )), d = l.pipe(
+    w((a) => (typeof i == "function" ? (
+      // eslint-disable-next-line @typescript-eslint/promise-function-async
+      V(() => i(t))
+    ) : i).pipe(
+      p(
+        (o) => ({
+          result: {
+            data: o
+          },
+          error: null,
+          context: a
+        })
+      ),
+      Ue({
+        ...r,
+        caughtError: (o, m) => S({
+          failureCount: o,
+          failureReason: m
+        }),
+        catchError: (o, m) => f(m, a, o).pipe(
+          p((C) => ({
+            ...C,
+            result: void 0
+          }))
+        )
+      }),
+      ve(
+        ({ result: o, error: m }) => (o == null ? void 0 : o.data) === void 0 && m === void 0,
+        !0
+      )
+    ))
+  ), h = S({
+    ...e,
+    variables: t,
+    status: "pending",
+    isPaused: !1,
+    failureCount: 0,
+    failureReason: null,
+    submittedAt: e.submittedAt ?? (/* @__PURE__ */ new Date()).getTime()
+  });
+  return O(
+    h,
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    l.pipe(p((a) => ({ context: a }))),
+    d.pipe(
+      w(({ result: a, error: c, ...o }) => {
+        if (!a && !c)
+          return S({
+            ...o
           });
-          if (!mutation) {
-            return of({});
+        const m = c ? S(null) : V(
+          () => {
+            var v;
+            return (v = r.onSuccess) == null ? void 0 : v.call(
+              r,
+              a == null ? void 0 : a.data,
+              t,
+              o.context
+            );
           }
-          const mutation$ = mutation.execute(args);
-          const queryIsOver$ = merge(
-            cancel$,
-            mutation$.pipe(
-              filter(({ status }) => status === "success" || status === "error")
+        ), b = V(
+          () => {
+            var v;
+            return (v = r.onSettled) == null ? void 0 : v.call(
+              r,
+              a == null ? void 0 : a.data,
+              c,
+              t,
+              o.context
+            );
+          }
+        ).pipe(
+          A((v) => a ? S(a) : S(v))
+        );
+        return ue(m, b).pipe(
+          ce(),
+          p(
+            () => c ? {
+              error: c,
+              data: void 0,
+              variables: t,
+              ...o
+            } : {
+              status: "success",
+              error: c,
+              data: a == null ? void 0 : a.data,
+              variables: t,
+              ...o
+            }
+          ),
+          A(
+            (v) => f(v, o.context, 0).pipe(
+              p((E) => ({
+                ...E,
+                data: void 0
+              }))
             )
-          );
-          const isThisCurrentFunctionLastOneCalled = trigger$.pipe(
-            take(1),
-            map(() => mapOperator === "concat"),
-            startWith(true),
-            takeUntil(queryIsOver$)
-          );
-          const result$ = combineLatest([
-            mutation$,
-            isThisCurrentFunctionLastOneCalled
-          ]).pipe(
-            map(([result, isLastMutationCalled]) => {
-              if ((result.status === "success" || result.status === "error") && !isLastMutationCalled) {
-                return {};
-              }
-              return result;
-            }),
-            mergeResults
-          );
-          return result$;
-        }),
-        mergeResults,
-        __queryTriggerHook ?? identity
-      );
-    }),
-    __queryFinalizeHook ?? identity,
-    shareReplay(1)
+          )
+        );
+      })
+    )
+  ).pipe(
+    pe((a, c) => ({
+      ...a,
+      ...c,
+      data: c.data ?? a.data,
+      error: c.error ?? a.error
+    }), W()),
+    R(
+      ({ data: a, ...c }, { data: o, ...m }) => T(c, m) && T(a, o)
+    )
   );
-  cancel$.subscribe(() => {
-    var _a;
-    (_a = mutationCache.findAll({
-      mutationKey,
-      exact: true
-    })) == null ? void 0 : _a.forEach((mutation) => {
-      mutation.cancel();
-    });
-  });
-  return {
-    mutationKey,
-    runner$,
-    trigger: ({
-      args,
-      options
-    }) => {
-      mapOperator$.next(options.mapOperator);
-      trigger$.next({ args, options });
-    },
-    cancel$,
-    destroy,
-    getClosed: () => closed
-  };
 };
-class MutationRunners {
-  constructor(client) {
-    /**
-     * Contain all active mutation for a given key.
-     * A mutation ca have several triggers running (it is not necessarily one function running)
-     *
-     * @important
-     * - automatically cleaned as soon as the last mutation is done for a given key
-     */
-    __publicField(this, "mutationRunnersByKey$", new BehaviorSubject(/* @__PURE__ */ new Map()));
-    this.client = client;
-  }
-  /**
-   * @helper
-   */
-  setMutationRunnersByKey(key, value) {
-    const map2 = this.mutationRunnersByKey$.getValue();
-    map2.set(key, value);
-    this.mutationRunnersByKey$.next(map2);
-  }
-  /**
-   * @helper
-   */
-  deleteMutationRunnersByKey(key) {
-    const map2 = this.mutationRunnersByKey$.getValue();
-    map2.delete(key);
-    this.mutationRunnersByKey$.next(map2);
-  }
-  /**
-   * @helper
-   */
-  getMutationRunnersByKey(key) {
-    return this.mutationRunnersByKey$.getValue().get(key);
-  }
-  async mutate(params) {
-    const { mutationKey } = params.options;
-    const serializedMutationKey = serializeKey(mutationKey);
-    let mutationForKey = this.getMutationRunnersByKey(serializedMutationKey);
-    if (!mutationForKey) {
-      mutationForKey = {
-        ...createMutationRunner({
-          ...params.options,
-          client: this.client,
-          mutationCache: this.client.getMutationCache()
-        }),
-        mutationKey
-      };
-      this.setMutationRunnersByKey(serializedMutationKey, mutationForKey);
-      mutationForKey.runner$.subscribe();
-      this.client.getMutationCache().mutationsBy({
-        exact: true,
-        mutationKey
-      }).pipe(
-        distinctUntilChanged(shallowEqual),
-        skip(1),
-        filter((items) => items.length === 0),
-        take(1)
-      ).subscribe(() => {
-        mutationForKey == null ? void 0 : mutationForKey.destroy();
-        this.deleteMutationRunnersByKey(serializedMutationKey);
-      });
-    }
-    const mutation = this.client.getMutationCache().build(this.client, params.options);
-    mutationForKey.trigger(params);
-    return await new Promise((resolve, reject) => {
-      mutation.observeTillFinished().pipe(last()).subscribe({
-        error: reject,
-        next: resolve
-      });
-    });
-  }
-  destroy() {
-    this.mutationRunnersByKey$.complete();
-  }
-}
-const functionAsObservable = (fn) => {
-  return defer(() => {
-    const result = fn();
-    if (result instanceof Promise) {
-      return from(result);
-    }
-    if (result instanceof Observable) {
-      return result;
-    }
-    return of(result);
-  });
-};
-class Mutation {
+class tr {
   constructor({
-    options,
-    mutationCache
+    options: e,
+    mutationCache: r,
+    state: n
   }) {
-    __publicField(this, "state", getDefaultMutationState());
-    __publicField(this, "state$");
-    __publicField(this, "options");
-    __publicField(this, "mutationCache");
-    __publicField(this, "observerCount", new BehaviorSubject(0));
-    __publicField(this, "observerCount$", this.observerCount.asObservable());
-    __publicField(this, "cancelSubject", new Subject());
-    __publicField(this, "executeSubject", new Subject());
-    this.options = options;
-    this.mutationCache = mutationCache;
-    this.state$ = merge(
-      of(this.state),
-      this.executeSubject.pipe(
-        switchMap((variables) => this.createMutation(variables)),
-        tap((value) => {
-          this.state = { ...this.state, ...value };
-        }),
-        takeUntil(this.cancelSubject)
+    y(this, "mutationCache");
+    y(this, "observerCount", new I(0));
+    y(this, "destroySubject", new F());
+    y(this, "resetSubject", new F());
+    y(this, "executeSubject", new F());
+    y(this, "state", W());
+    y(this, "state$");
+    y(this, "options");
+    y(this, "observerCount$", this.observerCount.asObservable());
+    y(this, "destroyed$", this.destroySubject.asObservable());
+    this.options = e, this.mutationCache = r, this.state = n ?? this.state;
+    const s = S(this.state), i = this.resetSubject.pipe(
+      p(() => W())
+    ), u = this.executeSubject.pipe(
+      w(
+        (l) => er({
+          options: {
+            ...this.options,
+            onMutate: (f) => {
+              const d = V(
+                () => {
+                  var g, a;
+                  return (a = (g = r.config).onMutate) == null ? void 0 : a.call(
+                    g,
+                    f,
+                    this
+                  );
+                }
+              ), h = V(
+                // eslint-disable-next-line @typescript-eslint/promise-function-async
+                () => {
+                  var g, a;
+                  return ((a = (g = this.options).onMutate) == null ? void 0 : a.call(g, f)) ?? void 0;
+                }
+              );
+              return d.pipe(_(() => h));
+            },
+            onError: (f, d, h) => {
+              const g = V(
+                () => {
+                  var c, o;
+                  return (o = (c = r.config).onError) == null ? void 0 : o.call(
+                    c,
+                    f,
+                    d,
+                    h,
+                    this
+                  );
+                }
+              ), a = V(
+                () => {
+                  var c, o;
+                  return (o = (c = this.options).onError) == null ? void 0 : o.call(c, f, d, h);
+                }
+              );
+              return ue(g, a).pipe(ce());
+            },
+            onSettled: (f, d, h, g) => {
+              const a = V(
+                () => {
+                  var o, m;
+                  return (m = (o = r.config).onSettled) == null ? void 0 : m.call(
+                    o,
+                    f,
+                    d,
+                    h,
+                    g,
+                    this
+                  );
+                }
+              ), c = V(
+                () => {
+                  var o, m;
+                  return (m = (o = this.options).onSettled) == null ? void 0 : m.call(o, f, d, h, g);
+                }
+              );
+              return ue(a, c).pipe(ce());
+            },
+            onSuccess: (f, d, h) => {
+              const g = V(
+                () => {
+                  var c, o;
+                  return (o = (c = r.config).onSuccess) == null ? void 0 : o.call(
+                    c,
+                    f,
+                    d,
+                    h,
+                    this
+                  );
+                }
+              ), a = V(
+                () => {
+                  var c, o;
+                  return (o = (c = this.options).onSuccess) == null ? void 0 : o.call(c, f, d, h);
+                }
+              );
+              return ue(g, a).pipe(ce());
+            }
+          },
+          state: this.state,
+          variables: l
+        })
       ),
-      NEVER
-    ).pipe(
+      x((l) => {
+        this.state = { ...this.state, ...l };
+      }),
+      P(this.destroySubject)
+    );
+    this.state$ = O(s, u, i).pipe(
       /**
        * refCount as true somewhat make NEVER complete when there are
        * no more observers. I thought I should have to complete manually (which is
        * why we still cancel the observable when we remove it from cache)
        */
-      shareReplay({ bufferSize: 1, refCount: true }),
-      takeUntil(this.cancelSubject),
-      (source) => {
-        return new Observable(
-          (observer) => {
-            this.observerCount.next(this.observerCount.getValue() + 1);
-            const sub = source.subscribe(observer);
-            return () => {
-              this.observerCount.next(this.observerCount.getValue() - 1);
-              sub.unsubscribe();
-            };
-          }
-        );
-      }
-    );
-  }
-  createMutation(variables) {
-    const mutationFn = this.options.mutationFn;
-    const onCacheMutate$ = functionAsObservable(
-      () => {
-        var _a, _b;
-        return (_b = (_a = this.mutationCache.config).onMutate) == null ? void 0 : _b.call(
-          _a,
-          variables,
-          this
-        );
-      }
-    );
-    const onMutate = concat(
-      onCacheMutate$.pipe(
-        mergeMap(() => {
-          const onMutate$ = functionAsObservable(
-            // eslint-disable-next-line @typescript-eslint/promise-function-async
-            () => {
-              var _a, _b;
-              return ((_b = (_a = this.options).onMutate) == null ? void 0 : _b.call(_a, variables)) ?? void 0;
-            }
-          );
-          return onMutate$;
-        })
-      )
-    );
-    const queryRunner$ = onMutate.pipe(
-      switchMap((context) => {
-        const fn$ = typeof mutationFn === "function" ? (
-          // eslint-disable-next-line @typescript-eslint/promise-function-async
-          functionAsObservable(() => mutationFn(variables))
-        ) : mutationFn;
-        return fn$.pipe(
-          retryOnError(this.options),
-          take(1),
-          map((data) => ({ data, context, isError: false })),
-          catchError((error) => {
-            console.error(error);
-            const onCacheError$ = functionAsObservable(
-              () => {
-                var _a, _b;
-                return (_b = (_a = this.mutationCache.config).onError) == null ? void 0 : _b.call(_a, error, variables, context, this);
-              }
-            );
-            const onError$ = functionAsObservable(
-              () => {
-                var _a, _b;
-                return (_b = (_a = this.options).onError) == null ? void 0 : _b.call(_a, error, variables, context);
-              }
-            );
-            return concat(onCacheError$, onError$).pipe(
-              toArray(),
-              map(() => ({ data: error, context, isError: true }))
-            );
-          })
-        );
+      $e({ bufferSize: 1, refCount: !1 }),
+      P(this.destroySubject),
+      ke((l) => {
+        this.observerCount.next(l);
       })
     );
-    const initState$ = of({
-      ...this.state,
-      variables,
-      status: "pending",
-      submittedAt: (/* @__PURE__ */ new Date()).getTime()
-    });
-    const mutation$ = merge(
-      initState$,
-      queryRunner$.pipe(
-        switchMap(({ data: dataOrError, isError, context }) => {
-          const error = isError ? dataOrError : null;
-          const data = isError ? void 0 : dataOrError;
-          const onCacheSuccess$ = isError ? of(null) : functionAsObservable(
-            () => {
-              var _a, _b;
-              return (_b = (_a = this.mutationCache.config).onSuccess) == null ? void 0 : _b.call(
-                _a,
-                data,
-                variables,
-                context,
-                this
-              );
-            }
-          );
-          const onSuccess$ = isError ? of(null) : functionAsObservable(
-            () => {
-              var _a, _b;
-              return (_b = (_a = this.options).onSuccess) == null ? void 0 : _b.call(_a, data, variables, context);
-            }
-          );
-          const onCacheSettled$ = functionAsObservable(
-            () => {
-              var _a, _b;
-              return (_b = (_a = this.mutationCache.config).onSettled) == null ? void 0 : _b.call(
-                _a,
-                data,
-                error,
-                variables,
-                context,
-                this
-              );
-            }
-          );
-          const onSettled$ = functionAsObservable(
-            () => {
-              var _a, _b;
-              return (_b = (_a = this.options).onSettled) == null ? void 0 : _b.call(_a, data, error, variables, context);
-            }
-          );
-          const result$ = concat(
-            onCacheSuccess$,
-            onSuccess$,
-            onCacheSettled$,
-            onSettled$
-          ).pipe(
-            toArray(),
-            map(
-              () => isError ? {
-                status: "error",
-                error,
-                data,
-                context,
-                variables
-              } : {
-                status: "success",
-                error,
-                data,
-                context,
-                variables
-              }
-            )
-          );
-          return result$;
-        })
-      )
-    ).pipe(
-      mergeResults,
-      this.options.__queryRunnerHook ?? identity,
-      takeUntil(this.cancelSubject)
-    );
-    return mutation$;
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  setOptions(e) {
+    this.options = { ...this.options, ...e };
   }
   observeTillFinished() {
     return this.state$.pipe(
-      takeWhile(
-        (result) => result.status !== "error" && result.status !== "success",
-        true
+      ve(
+        (e) => e.status !== "error" && e.status !== "success",
+        !0
       )
     );
   }
@@ -1888,509 +1581,358 @@ class Mutation {
    * The resulting observable will complete as soon as the mutation
    * is over, unlike the state which can be re-subscribed later.
    */
-  execute(variables) {
-    this.executeSubject.next(variables);
-    this.executeSubject.complete();
-    return this.observeTillFinished();
+  execute(e) {
+    return this.executeSubject.next(e), this.executeSubject.complete(), this.observeTillFinished();
   }
-  cancel() {
-    this.cancelSubject.next();
-    this.cancelSubject.complete();
-    this.executeSubject.complete();
+  continue() {
+    return this.execute(this.state.variables);
+  }
+  destroy() {
+    this.destroySubject.next(), this.destroySubject.complete(), this.executeSubject.complete();
+  }
+  reset() {
+    this.resetSubject.next(), this.resetSubject.complete(), this.destroy();
   }
 }
-const createPredicateForFilters = ({
-  mutationKey,
-  status,
-  predicate,
-  exact = true
-} = {}) => {
-  const finalPredicate = (mutation) => {
-    if (exact && mutationKey !== void 0 && !compareKeys(mutation.options.mutationKey, mutationKey, { exact })) {
-      return false;
-    }
-    if (!exact && mutationKey !== void 0 && !compareKeys(mutationKey, mutation.options.mutationKey, { exact })) {
-      return false;
-    }
-    if (status && mutation.state.status !== status)
-      return false;
-    if (predicate) {
-      return predicate(mutation);
-    }
-    return true;
-  };
-  return finalPredicate;
-};
-class MutationCache {
-  constructor(config = {}) {
-    __publicField(this, "mutationsSubject", new BehaviorSubject([]));
-    __publicField(this, "mutations$", this.mutationsSubject.pipe(
-      map((mutations) => mutations.map(({ mutation }) => mutation)),
-      distinctUntilChanged(arrayEqual),
-      share()
+const he = ({
+  mutationKey: t,
+  status: e,
+  predicate: r,
+  exact: n = !0
+} = {}) => (i) => n && t !== void 0 && i.options.mutationKey !== void 0 && !te(i.options.mutationKey, t, { exact: n }) || !n && t !== void 0 && i.options.mutationKey !== void 0 && !te(t, i.options.mutationKey, { exact: n }) || e && i.state.status !== e ? !1 : r ? r(i) : !0;
+class rr {
+  constructor(e = {}) {
+    y(this, "mutationsSubject", new I([]));
+    y(this, "mutations$", this.mutationsSubject.pipe(
+      p((e) => e.map((r) => r)),
+      R(Le),
+      J()
     ));
-    __publicField(this, "added$", this.mutations$.pipe(
-      pairwise(),
-      map(
-        ([previous, current]) => current.filter((mutation) => !previous.includes(mutation))[0]
+    y(this, "added$", this.mutations$.pipe(
+      oe(),
+      p(
+        ([e, r]) => r.filter((n) => !e.includes(n))[0]
       ),
-      filter(isDefined),
-      share()
+      $(G),
+      J()
     ));
-    __publicField(this, "removed$", this.mutations$.pipe(
-      pairwise(),
-      map(
-        ([previous, current]) => previous.filter((mutation) => !current.includes(mutation))
+    y(this, "removed$", this.mutations$.pipe(
+      oe(),
+      p(
+        ([e, r]) => e.filter((n) => !r.includes(n))
       ),
-      mergeMap((removedItems) => from(removedItems)),
-      share()
+      _((e) => ne(e)),
+      J()
     ));
-    __publicField(this, "stateChange$", this.added$.pipe(
-      mergeMap(
-        (mutation) => mutation.state$.pipe(
-          map(() => mutation),
-          takeUntil(
+    y(this, "stateChange$", this.added$.pipe(
+      _(
+        (e) => e.state$.pipe(
+          p(() => e),
+          P(
             this.removed$.pipe(
-              filter((removedMutation) => removedMutation === mutation)
+              $((r) => r === e)
             )
           )
         )
       ),
-      share()
+      J()
     ));
-    this.config = config;
-  }
-  subscribe(listener) {
-    const sub = merge(
-      this.added$.pipe(
-        tap((mutation) => {
-          listener({
-            type: "added",
-            mutation
-          });
-        })
-      ),
-      this.removed$.pipe(
-        tap((mutation) => {
-          listener({
-            type: "removed",
-            mutation
-          });
-        })
-      ),
-      this.stateChange$.pipe(
-        tap((mutation) => {
-          listener({
-            type: "updated",
-            action: {
-              ...mutation.state,
-              // @todo
-              type: "success"
-            },
-            mutation
-          });
-        })
-      )
-    ).subscribe();
-    return () => {
-      sub.unsubscribe();
-    };
+    this.config = e;
   }
-  build(client, options) {
-    const mutation = new Mutation({
+  build(e, r, n) {
+    const s = new tr({
       mutationCache: this,
-      // mutationId: ++this.#mutationId,
-      options: client.defaultMutationOptions(options)
-      // state
+      options: e.defaultMutationOptions(r),
+      state: n
     });
-    const sub = mutation.state$.pipe(
+    return s.state$.pipe(
       /**
        * Once a mutation is finished and there are no more observers than us
        * we start the process of cleaning it up based on gc settings
        */
-      filter(({ status }) => status === "success" || status === "error"),
-      switchMap(
-        () => mutation.observerCount$.pipe(
-          filter((count) => count <= 1),
-          take(1)
+      $(({ status: i }) => i === "success" || i === "error"),
+      w(
+        () => s.observerCount$.pipe(
+          $((i) => i <= 1),
+          be(1)
         )
       ),
-      switchMap(() => timer(mutation.options.gcTime ?? 0)),
-      take(1)
+      // defaults to 5mn
+      w(() => ie(s.options.gcTime ?? 5 * 60 * 1e3)),
+      be(1)
     ).subscribe({
       complete: () => {
-        this.remove(mutation);
+        this.mutationsSubject.next(
+          this.mutationsSubject.getValue().filter((i) => s !== i)
+        );
       }
-    });
-    this.mutationsSubject.next([
-      ...this.mutationsSubject.getValue(),
-      { mutation, sub }
-    ]);
-    return mutation;
+    }), this.mutationsSubject.next([...this.mutationsSubject.getValue(), s]), s;
   }
   getAll() {
     return this.findAll();
   }
-  remove(mutation) {
-    this.removeBy({ predicate: (item) => item === mutation });
-  }
-  removeBy(filters) {
-    const defaultedFilters = { exact: true, ...filters };
-    const predicate = createPredicateForFilters(defaultedFilters);
-    const toRemove = this.mutationsSubject.getValue().filter(({ mutation }) => {
-      return predicate(mutation);
-    }).map(({ mutation, sub }) => {
-      mutation.cancel();
-      sub.unsubscribe();
-      return mutation;
-    });
-    this.mutationsSubject.next(
-      this.mutationsSubject.getValue().filter(({ mutation }) => !toRemove.includes(mutation))
-    );
-  }
-  find(filters) {
-    var _a;
-    const defaultedFilters = { exact: true, ...filters };
-    const predicate = createPredicateForFilters(defaultedFilters);
-    return (_a = this.mutationsSubject.getValue().find(({ mutation }) => predicate(mutation))) == null ? void 0 : _a.mutation;
+  remove(e) {
+    const r = this.mutationsSubject.getValue().find((n) => n === e);
+    r == null || r.destroy();
   }
-  findLatest(filters) {
-    var _a;
-    const defaultedFilters = { exact: true, ...filters };
-    const predicate = createPredicateForFilters(defaultedFilters);
-    return (_a = this.mutationsSubject.getValue().slice().reverse().find(({ mutation }) => predicate(mutation))) == null ? void 0 : _a.mutation;
+  find(e) {
+    const r = { exact: !0, ...e }, n = he(r);
+    return this.mutationsSubject.getValue().find((s) => n(s));
   }
-  findAll(filters = {}) {
-    const defaultedFilters = { exact: true, ...filters };
-    const predicate = createPredicateForFilters(defaultedFilters);
-    return this.mutationsSubject.getValue().filter(({ mutation }) => predicate(mutation)).map(({ mutation }) => mutation);
+  findAll(e = {}) {
+    const r = { exact: !0, ...e }, n = he(r);
+    return this.mutationsSubject.getValue().filter((s) => n(s)).map((s) => s);
   }
-  mutationsBy(filters) {
-    const defaultedFilters = { exact: true, ...filters };
-    const predicate = createPredicateForFilters(defaultedFilters);
-    return this.mutations$.pipe(
-      map((mutations) => mutations.filter(predicate)),
-      distinctUntilChanged(arrayEqual)
-    );
-  }
-  mutationStateBy({
-    filters,
-    select
+  observe({
+    filters: e,
+    select: r
   } = {}) {
-    const predicate = createPredicateForFilters(filters);
-    const finalSelect = select ?? ((mutation) => mutation.state);
-    const lastValue = this.getAll().reduce((acc, mutation) => {
-      const result = [...acc, mutation];
-      return result;
-    }, []).filter(predicate).map((mutation) => finalSelect(mutation));
-    const value$ = this.stateChange$.pipe(
-      startWith(),
-      map(() => {
-        const filteredMutations = this.getAll().filter(predicate);
-        return filteredMutations.map(finalSelect);
-      }),
-      distinctUntilChanged(shallowEqual)
-    );
-    return { value$, lastValue };
-  }
-  cancelBy(filters) {
-    this.findAll(filters).forEach((mutation) => {
-      mutation.cancel();
-    });
+    const n = he(e), s = r ?? ((l) => l.state), i = this.getAll().reduce((l, f) => [...l, f], []).filter(n).map((l) => s(l));
+    return { value$: this.stateChange$.pipe(
+      Ie(),
+      p(() => this.getAll().filter(n).map(s)),
+      R(T)
+    ), lastValue: i };
   }
-  clear() {
-    this.getAll().forEach((mutation) => {
-      this.remove(mutation);
-    });
-  }
-}
-class MutationObserver {
-  constructor(client, options) {
-    __publicField(this, "getDerivedState", (state) => {
-      return {
-        ...getDefaultMutationState(),
-        ...state,
-        isSuccess: state.status === "success",
-        isPending: state.status === "pending",
-        isIdle: state.status === "idle",
-        isError: state.status === "error"
-      };
-    });
-    this.client = client;
-    this.options = options;
-  }
-  observeBy(filters) {
-    const reduceStateFromMutation = (values) => {
-      var _a;
-      return values.reduce(
-        (acc, { state, options }) => {
-          if (options.mapOperator === "switch")
-            return state;
-          if (acc && state.submittedAt >= acc.submittedAt) {
-            return {
-              ...state,
-              data: state.data ?? acc.data,
-              error: state.error ?? acc.error
-            };
-          }
-          return acc;
-        },
-        ((_a = values[0]) == null ? void 0 : _a.state) ?? getDefaultMutationState()
-      );
-    };
-    const mutations = this.client.getMutationCache().findAll(filters);
-    const lastValue = this.getDerivedState(
-      reduceStateFromMutation(mutations)
-    );
-    const result$ = this.client.getMutationCache().mutationsBy(filters).pipe(
-      switchMap(
-        (mutations2) => combineLatest(
-          mutations2.map(
-            (mutation) => this.observe(mutation).pipe(
-              map((state) => ({ state, options: mutation.options }))
-            )
-          )
-        )
+  /**
+   * @important
+   * ISO api react-query
+   */
+  subscribe(e) {
+    const r = O(
+      this.added$.pipe(
+        x((n) => {
+          e({
+            type: "added",
+            mutation: n
+          });
+        })
       ),
-      map(reduceStateFromMutation),
-      filter(isDefined),
-      map(this.getDerivedState),
-      distinctUntilChanged(shallowEqual)
-    );
-    return { result$, lastValue };
-  }
-  observe(mutation) {
-    return mutation.state$;
-  }
-  subscribe(subscription) {
-    const sub = this.client.getMutationCache().mutations$.pipe(
-      mergeMap((mutations) => {
-        const observed$ = mutations.map(
-          (mutation) => this.observe(mutation).pipe(
-            // we only want next changes
-            skip(1)
-          )
-        );
-        return merge(...observed$);
-      })
-    ).subscribe(subscription);
+      this.removed$.pipe(
+        x((n) => {
+          e({
+            type: "removed",
+            mutation: n
+          });
+        })
+      ),
+      this.stateChange$.pipe(
+        x((n) => {
+          e({
+            type: "updated",
+            action: {
+              ...n.state,
+              type: "success"
+            },
+            mutation: n
+          });
+        })
+      )
+    ).subscribe();
     return () => {
-      sub.unsubscribe();
+      r.unsubscribe();
     };
   }
-  async mutate(variables, options) {
-    const mergedOptions = {
-      ...this.options,
-      ...options
-    };
-    return await this.client.mutationRunners.mutate({
-      args: variables,
-      options: {
-        mutationFn: async () => void 0,
-        ...mergedOptions,
-        mutationKey: mergedOptions.mutationKey ?? [nanoid()]
-      }
+  resumePausedMutations() {
+    const e = this.findAll({
+      predicate: (n) => n.state.isPaused
     });
+    if (!e.length)
+      return M;
+    const r = e.map((n) => n.continue());
+    return Fe(r);
   }
-  reset() {
-    this.client.getMutationCache().getAll().forEach((mutation) => {
-      mutation.cancel();
+  clear() {
+    this.getAll().forEach((e) => {
+      this.remove(e);
     });
   }
-  destroy() {
-  }
 }
-const createClient = () => {
-  const queryStore = createQueryStore();
-  const invalidationClient = createInvalidationClient({ queryStore });
-  const cacheClient = createCacheClient({ queryStore });
-  const refetchClient = createRefetchClient();
-  let hasCalledStart = false;
-  const query = ({
-    key,
-    fn$: maybeFn$,
-    fn: maybeFn,
-    trigger$: externalTrigger$ = new Subject(),
-    options$ = new BehaviorSubject({})
+const nr = () => {
+  const t = It(), e = kt({ queryStore: t }), r = Xt({ queryStore: t }), n = Lt();
+  let s = !1;
+  const i = ({
+    key: d,
+    fn$: h,
+    fn: g,
+    trigger$: a = new F(),
+    options$: c = new I({})
   }) => {
-    if (!hasCalledStart) {
+    if (!s)
       throw new Error("You forgot to start client");
-    }
-    const serializedKey = serializeKey(key);
-    const fn$ = maybeFn$ ?? (maybeFn ? of(maybeFn) : NEVER);
-    Logger.log("query$)", serializedKey);
-    const runner$ = options$.pipe(map((options) => ({ options })));
-    let deleteRunner = () => {
+    const o = N(d), m = h ?? (g ? S(g) : Qe);
+    X.log("query$)", o);
+    const C = c.pipe(p((E) => ({ options: E })));
+    let b = () => {
     };
-    const trigger$ = merge(
-      externalTrigger$.pipe(
-        dispatchExternalRefetchToAllQueries({
-          queryStore,
-          serializedKey
+    const j = O(
+      a.pipe(
+        Bt({
+          queryStore: t,
+          serializedKey: o
         })
       ),
-      createQueryTrigger({
-        options$,
-        key: serializedKey,
-        queryStore
+      Qt({
+        options$: c,
+        key: o,
+        queryStore: t
       })
-    ).pipe(share());
-    const result$ = merge(
-      of({
-        type: "initial"
-      }),
-      trigger$
-    ).pipe(
-      updateStoreWithNewQuery({
-        key,
-        queryStore,
-        runner$,
-        serializedKey,
-        options$
-      }),
-      map(([value, deleteRunnerFn]) => {
-        if (deleteRunnerFn) {
-          deleteRunner = deleteRunnerFn;
-        }
-        return value;
-      }),
-      markQueryAsStaleIfRefetch({
-        key,
-        options$,
-        queryStore,
-        serializedKey
-      }),
-      withLatestFrom(fn$, options$),
-      map(([trigger2, fn, options]) => ({ trigger: trigger2, fn, options })),
-      map((value) => {
-        Logger.log(serializedKey, "query trigger", {
-          trigger: value.trigger,
-          options: value.options
-        });
-        return value;
-      }),
-      filter(({ options }) => options.enabled !== false),
-      mergeMap(
-        ({ fn, options, trigger: trigger2 }) => createQueryFetch({
-          options$,
-          options,
-          fn,
-          queryStore,
-          serializedKey,
-          trigger: trigger2,
-          trigger$
-        })
-      ),
-      mergeResults$1,
-      withLatestFrom(options$),
-      takeWhile(([result, options]) => {
-        const shouldStop = result.data !== void 0 && options.terminateOnFirstResult;
-        return !shouldStop;
-      }, true),
-      map(([result]) => result),
-      finalize(() => {
-        deleteRunner();
-      })
-    );
+    ).pipe(J());
     return {
-      result$
+      result$: O(
+        S({
+          type: "initial"
+        }),
+        j
+      ).pipe(
+        Ht({
+          key: d,
+          queryStore: t,
+          runner$: C,
+          serializedKey: o,
+          options$: c
+        }),
+        p(([E, Q]) => (Q && (b = Q), E)),
+        qt({
+          key: d,
+          options$: c,
+          queryStore: t,
+          serializedKey: o
+        }),
+        D(m, c),
+        p(([E, Q, z]) => ({ trigger: E, fn: Q, options: z })),
+        p((E) => (X.log(o, "query trigger", {
+          trigger: E.trigger,
+          options: E.options
+        }), E)),
+        $(({ options: E }) => E.enabled !== !1),
+        _(
+          ({ fn: E, options: Q, trigger: z }) => Nt({
+            options$: c,
+            options: Q,
+            fn: E,
+            queryStore: t,
+            serializedKey: o,
+            trigger: z,
+            trigger$: j
+          })
+        ),
+        xt,
+        D(c),
+        ve(([E, Q]) => !(E.data !== void 0 && Q.terminateOnFirstResult), !0),
+        p(([E]) => E),
+        ae(() => {
+          b();
+        })
+      )
     };
-  };
-  const queryListener$ = createQueryListener(
-    queryStore,
-    (stream) => stream.pipe(
-      switchMap((key) => {
-        const key$ = of(key);
-        return merge(
-          invalidateCache({
-            queryStore
-          })(key$),
-          markAsStale({
-            queryStore
-          })(key$),
-          garbageCache({
-            queryStore
-          })(key$)
+  }, u = jt(
+    t,
+    (d) => d.pipe(
+      w((h) => {
+        const g = S(h);
+        return O(
+          Yt({
+            queryStore: t
+          })(g),
+          zt({
+            queryStore: t
+          })(g),
+          Gt({
+            queryStore: t
+          })(g)
         );
       })
     )
   );
-  const destroy = () => {
-  };
-  const start = () => {
-    hasCalledStart = true;
-    const queryListenerSub = queryListener$.subscribe();
-    const started = [queryStore.start()];
-    return () => {
-      started.forEach((destroy2) => {
-        destroy2();
-      });
-      queryListenerSub.unsubscribe();
-    };
-  };
   return {
-    start,
-    query,
-    queryStore,
-    ...invalidationClient,
-    ...cacheClient,
-    ...refetchClient,
-    destroy
+    start: () => {
+      s = !0;
+      const d = u.subscribe(), h = [t.start()];
+      return () => {
+        h.forEach((g) => {
+          g();
+        }), d.unsubscribe();
+      };
+    },
+    query: i,
+    queryStore: t,
+    ...e,
+    ...r,
+    ...n,
+    destroy: () => {
+    }
   };
 };
-class QueryClient {
-  constructor({ mutationCache } = {
-    mutationCache: new MutationCache()
+var re;
+class Sr {
+  constructor({ mutationCache: e } = {
+    mutationCache: new rr()
   }) {
-    __publicField(this, "client");
-    __publicField(this, "mutationCache");
-    __publicField(this, "mutationRunners");
-    __publicField(this, "mutationObserver");
-    this.mutationCache = mutationCache;
-    this.mutationRunners = new MutationRunners(this);
-    this.mutationObserver = new MutationObserver(this);
-    this.client = createClient();
+    y(this, "client");
+    y(this, "mutationCache");
+    de(this, re, /* @__PURE__ */ new Map());
+    this.mutationCache = e, this.client = nr();
   }
   mount() {
-    const stop = this.client.start();
+    const e = this.client.start();
     return () => {
-      this.mutationRunners.destroy();
-      stop();
+      e();
     };
   }
   getMutationCache() {
     return this.mutationCache;
   }
-  defaultMutationOptions(options) {
-    return options;
+  defaultMutationOptions(e) {
+    return {
+      ...(e == null ? void 0 : e.mutationKey) && this.getMutationDefaults(e.mutationKey),
+      ...e
+    };
+  }
+  getMutationDefaults(e) {
+    const r = [...k(this, re).values()];
+    let n = {};
+    return r.forEach((s) => {
+      te(e, s.mutationKey) && (n = { ...n, ...s.defaultOptions });
+    }), n;
+  }
+  setMutationDefaults(e, r) {
+    k(this, re).set(N(e), {
+      mutationKey: e,
+      defaultOptions: r
+    });
+  }
+  async resumePausedMutations() {
+    return await nt(this.mutationCache.resumePausedMutations());
   }
   clear() {
   }
 }
+re = new WeakMap();
 export {
-  MutationCache,
-  QueryClient,
-  QueryClientProvider,
-  SIGNAL_RESET,
-  createClient,
-  createLocalforageAdapter,
-  createSharedStoreAdapter,
-  exponentialBackoffDelay,
-  getDelay,
-  retryBackoff,
-  signal,
-  trigger,
-  useBehaviorSubject,
-  useLiveRef,
-  useMutation,
-  useObserve,
-  useObserveCallback,
-  usePersistSignals,
-  useQuery,
-  useQueryClient,
-  useSignalValue,
-  useSubject,
-  useSubscribe,
-  useSubscribeEffect,
-  useUnmountObservable
+  rr as MutationCache,
+  Sr as QueryClient,
+  br as QueryClientProvider,
+  pt as SIGNAL_RESET,
+  nr as createClient,
+  hr as createLocalforageAdapter,
+  dr as createSharedStoreAdapter,
+  bt as exponentialBackoffDelay,
+  mt as getDelay,
+  yt as retryBackoff,
+  pr as signal,
+  lr as trigger,
+  lt as useBehaviorSubject,
+  U as useLiveRef,
+  yr as useMutation,
+  fe as useObserve,
+  ar as useObserveCallback,
+  gr as usePersistSignals,
+  $r as useQuery,
+  Pe as useQueryClient,
+  fr as useSignalValue,
+  Oe as useSubject,
+  Se as useSubscribe,
+  vr as useSubscribeEffect,
+  mr as useUnmountObservable
 };