reactjrx 1.62.0 → 1.67.3

package/dist/index.js

@@ -1,642 +1,670 @@
-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, ReplaySubject, concatMap as concatMap$1, 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 C, tap as x, finalize as ae, catchError as j, EMPTY as T, Subject as F, identity as le, BehaviorSubject as I, map as p, of as S, zip as Ze, merge as E, throttleTime as Ve, asyncScheduler as qe, switchMap as w, from as re, defer as ne, throwError as Ce, iif as Me, timer as se, Observable as Te, 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 ce, NEVER as Qe, combineLatest as Fe, takeWhile as ve, concat as ie, toArray as ue, lastValueFrom as nt } from "rxjs";
+import { catchError as Re, 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;
+        C(at),
+        x((m) => {
+          i.current = m;
         }),
-        finalize(next),
-        catchError((error) => {
-          console.error(error);
-          valueRef.current = void 0;
-          return EMPTY;
-        })
-      ).subscribe(next);
+        ae(g),
+        j((m) => (console.error(m), i.current = void 0, T))
+      ).subscribe(g);
       return () => {
-        if (optionsRef.current.unsubscribeOnUnmount === false)
-          return;
-        sub.unsubscribe();
+        l.current.unsubscribeOnUnmount !== !1 && o.unsubscribe();
       };
     },
-    [...deps]
-  );
-  const getSnapshot = useCallback(() => {
-    return valueRef.current;
-  }, []);
-  const result = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  return result;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...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(
+      j((l) => (console.error(
+        "Uncaught error at useSubscribe. Please consider adding a catchError or other handling."
+      ), console.error(l), T))
     ).subscribe();
     return () => {
-      sub.unsubscribe();
+      u.unsubscribe();
     };
-  }, [...deps, sourceAsObservable]);
+  }, [
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    ...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;
+}, Ee = ({
+  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;
-      }
-    };
-  }, []);
-  return subject;
+    n.current || (s.current != null && s.current(), r.current.complete(), n.current = !0);
+  }), [i, s, r]), r;
+}, ar = (t, e) => {
+  const r = Ee();
+  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);
-  }, []);
-  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);
-  useEffect(() => {
-    if (completed.current) {
-      subject.current = new BehaviorSubject(state);
-      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;
       }
-    };
-  }, []);
-  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)),
+      C()
     ),
     {
-      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
+}) => re(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;
-        })
+        j((d) => (console.error("Unable to hydrate", d), T))
       );
     },
-    { 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 ? E(
+    ...n.current.map(
+      ({ signal: l, version: f }) => l.subject.pipe(
+        Ve(500, qe, {
+          trailing: !0
+        }),
+        w(
+          () => re(
+            ht({ adapter: i.current, signal: l, version: f })
           )
         )
       )
-    );
-  }, [isHydrated, adapterRef]);
-  return { isHydrated };
-};
-const useUnmountObservable = () => {
-  const subject = useSubject({
+    )
+  ) : T, [u, i]), { isHydrated: u };
+}, mr = () => {
+  const t = Ee({
     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) => ne(() => {
+    let f = 0;
+    const d = (h, g) => h < r && s(h, g);
+    return l.pipe(
+      Re((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 E(
+          g,
+          Ce(() => h)
         );
       }),
-      tap$1(() => {
-        if (resetOnSuccess) {
-          index = 0;
-        }
+      st((h) => h.pipe(
+        it((g) => {
+          const a = f - 1;
+          return Me(
+            () => d(a, g),
+            se(
+              mt(u(a, e), n)
+            ),
+            Ce(() => g)
+          );
+        })
+      )),
+      Re((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 destroy = client.start();
-    return () => {
-      destroy();
-    };
-  }, [client]);
-  return null;
-};
-const QueryClientProvider = memo(
-  ({ children, client }) => {
-    const value = useMemo(() => ({ client: client.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 } = {}) => {
-  const context = useContext(Context);
-  if (!unsafe && context.client === null) {
+), Pe = ({
+  unsafe: t = !1
+} = {}) => {
+  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 M(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 Te((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),
+      C()
+    );
+    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 = ne(() => (d.execute(f), T)), g = d.observeTillFinished().pipe(
+              ge(),
+              _(() => d.state$),
+              P(this.trigger$)
+            ), a = d.observeTillFinished().pipe(B(1));
+            return E(a, g, h).pipe(
+              e ?? le,
+              P(E(n, l))
+            );
+          }),
+          pe((f, d) => ({
+            ...f,
+            ...d,
+            ...d.status === "pending" && {
+              data: d.data ?? f.data
+            },
+            ...d.status === "pending" && {
+              error: d.error ?? f.error
+            }
+          }), W()),
+          C(
+            ({ data: f, ...d }, { data: h, ...g }) => M(d, g) && M(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)},`;
-    }, "[");
+  trigger({ args: e, options: r, mutation: n }) {
+    r.mapOperator && this.mapOperator$.next(r.mapOperator), this.trigger$.next({ args: e, options: r, mutation: n });
   }
-  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 += "_";
+}
+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
+          }))
+        )) ?? T
+      ),
+      _(({ 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
+      ))), T))
+    );
   }
-  return id;
-}, "");
-function useMutation(options, queryClient) {
-  const defaultQueryClient = useQueryClient({ unsafe: !!queryClient });
-  const finalQueryClient = (queryClient == null ? void 0 : queryClient.client) ?? defaultQueryClient;
-  const optionsRef = useLiveRef(options);
-  const defaultKey = useConstant(() => [nanoid()]);
-  const key = serializeKey(options.mutationKey ?? defaultKey.current);
-  const observedMutation = useMemo(
-    () => finalQueryClient.mutationClient.mutationResultObserver.observe({
-      key
-    }),
-    [key]
-  );
-  const result = useObserve(observedMutation.result$) ?? observedMutation.lastValue;
-  const mutate = useCallback(
-    (mutationArgs) => {
-      finalQueryClient.mutationClient.mutate({
-        options: {
-          ...optionsRef.current,
-          mutationKey: optionsRef.current.mutationKey ?? defaultKey.current
-        },
-        args: mutationArgs
-      });
-    },
-    [finalQueryClient, key]
-  );
-  const cancel = useCallback(() => {
-    finalQueryClient.mutationClient.cancel({
-      key: optionsRef.current.mutationKey ?? defaultKey.current
+  setOptions(e) {
+    this.options = this.client.defaultMutationOptions({
+      mutationKey: this.options.mutationKey,
+      ...e
+    }), this.options.mutationKey && this.client.getMutationCache().findAll({
+      exact: !0,
+      mutationKey: this.options.mutationKey
+    }).forEach((r) => {
+      r.setOptions(e);
+    });
+  }
+  observe() {
+    var n;
+    const e = this.getObserverResultFromState(
+      ((n = k(this, L).getValue()) == null ? void 0 : n.mutation.state) ?? W()
+    );
+    return { result$: E(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);
     });
-  }, [finalQueryClient]);
-  useEffect(() => {
     return () => {
-      if (optionsRef.current.cancelOnUnMount) {
-        finalQueryClient.mutationClient.cancel({
-          key: optionsRef.current.mutationKey ?? defaultKey.current
-        });
-      }
+      r.unsubscribe();
     };
-  }, []);
-  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;
+  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);
+        }
+      });
+    });
   }
-  if (objA.constructor !== (objB == null ? void 0 : objB.constructor)) {
-    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()
+    );
   }
-  const keysA = Object.keys(objA);
-  const keysB = Object.keys(objB);
-  if (keysA.length !== keysB.length) {
-    return false;
+  reset() {
+    var e;
+    (e = k(this, L).getValue()) == null || e.mutation.reset();
   }
-  for (const key of keysA) {
-    if (!objB.hasOwnProperty(key) || objA[key] !== objB[key]) {
-      return false;
-    }
+  cancel() {
+    var e;
+    console.log("cancel"), (e = k(this, L).getValue()) == null || e.mutation.destroy();
   }
-  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, 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.cancel();
+  }, [l, s]), { ...d, mutate: h, mutateAsync: d.mutate };
+}
+const Le = (t, e) => t.length === e.length && t.every((r, n) => r === e[n]), Et = (t) => t.pipe(
+  w(({ options: { refetchOnWindowFocus: e = !0 } }) => {
+    const r = typeof e == "function" ? e({}) : e;
+    return r !== !1 ? E(
+      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"
+        }))
+      )
+    ) : T;
+  })
+), Ot = (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"
+      }))
+    ) : T;
+  })
+), Ct = ({
+  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]);
-  return params$;
-};
-const defaultValue = {
+  }, [t, r, e, n]), n;
+}, Rt = {
   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 = Ee(), s = Pe(), i = Ct({ 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 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))
+      const f = i.current.pipe(p(({ queryKey: v }) => v ?? [])), d = S(null), h = f.pipe(
+        C(Le),
+        B(1)
+      ), g = (v) => !!v && typeof v != "function", a = i.current.pipe(
+        p(({ queryFn: v }) => v),
+        $(g),
+        C(M),
+        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 = Et(i.current), R = Ot(i.current), b = E(
+        d,
+        h,
+        a
+      ), A = E(
+        n.current,
+        E(m, R).pipe(Ve(500))
       );
-      return newQueryTrigger$.pipe(
-        withLatestFrom(key$),
-        switchMap(([, key]) => {
-          const { result$ } = client.query({
-            key,
-            fn$,
-            options$,
-            trigger$
+      return b.pipe(
+        D(f),
+        w(([, v]) => {
+          const { result$: O } = s.client.query({
+            key: v,
+            fn$: c,
+            options$: o,
+            trigger$: A
           });
-          return result$.pipe(
-            scan(
-              (previousValue, { data: currentData, ...currentValue }) => ({
+          return O.pipe(
+            pe(
+              (Q, { data: z, ...Oe }) => ({
                 data: void 0,
-                ...previousValue,
-                ...currentValue,
-                isLoading: currentValue.status === "loading",
-                ...currentData && {
-                  data: currentData.result
+                ...Q,
+                ...Oe,
+                isLoading: Oe.status === "loading",
+                ...z && {
+                  data: z.result
                 }
               }),
               {}
@@ -656,53 +684,49 @@ function useQuery({
     },
     {
       defaultValue: {
-        ...defaultValue,
-        isLoading: params$.current.getValue().options.enabled !== false
+        ...Rt,
+        isLoading: i.current.getValue().options.enabled !== !1
       }
     },
-    [client]
-  );
-  const refetch = useCallback(() => {
-    internalRefresh$.current.next({ type: "refetch", ignoreStale: true });
-  }, [client]);
-  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(
+      j((f) => {
+        throw console.error(f), f;
       }),
-      retryOption ? retry() : identity
+      s ? et() : le
     ),
-    [makeObservable]
+    [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,
@@ -710,347 +734,273 @@ const mergeResults$1 = (stream$) => stream$.pipe(
       status: "loading"
     }
   ),
-  distinctUntilChanged(
-    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
+  C(
+    ({ data: e, ...r }, { data: n, ...s }) => M(r, s) && M(e, n)
   )
-);
-const resetStyle = { backgroundColor: "transparent", color: "inherit" };
-function createLogger(env) {
-  const _logger = {
+), Vt = { backgroundColor: "transparent", color: "inherit" };
+function Ae(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 = Ae(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 = Ae("production"), Mt = X.namespace("store"), Tt = (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;
+    }, {})
+  ),
+  C(M)
+).subscribe((e) => {
+  Mt.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()),
+    C(M)
+  ), 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 R = m.getValue();
+      o(R) && m.next({ ...R, ...c });
+    }), e.next(t);
+  }, h = (c) => {
+    t.delete(c), e.next(t);
+  }, g = (c, o) => (f(c, (m) => ({
+    ...m,
+    runners: [...m.runners, o]
+  })), () => {
+    var R;
+    const m = ((R = t.get(c)) == null ? void 0 : R.getValue().runners.filter((b) => b !== o)) ?? [];
+    f(c, (b) => ({
+      ...b,
+      runners: m
     }));
+  }), a = () => {
+    const c = Tt(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),
+    C()
+  ).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 E(
+    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 : ne(() => {
+  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),
+    C()
+  ).pipe(
+    C(),
+    $((b) => !b)
+  ), h = ne(() => {
+    const b = typeof r == "function" ? r() : r;
+    return re(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"
+    j((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, A;
+      return (A = (b = n.get(s)) == null ? void 0 : b.cache_fnResult) == null ? void 0 : A.result;
     }),
-    filter(isDefined),
-    map((result) => ({
+    $(G),
+    p((b) => ({
       status: "success",
-      data: { result }
+      data: { result: b }
     })),
     /**
      * @important
@@ -1058,1044 +1008,934 @@ 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 = E(
+    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
+    E(
+      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, R = i.type === "refetch" && i.ignoreStale;
+  return m ? !(c != null && c.isStale) && !R ? S({
+    fetchStatus: "idle",
+    status: "success",
+    data: { result: o.result },
+    error: void 0
+  }) : E(
+    S({
+      fetchStatus: "fetching",
+      status: "success",
+      data: { result: o.result },
+      error: void 0
+    }),
+    a
+  ) : a;
+}, oe = (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), 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 = oe(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 E(
+      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;
-        })
+        C((u, l) => u.data === l.data),
+        D(n),
+        p(([, { refetchInterval: u }]) => u),
+        $(G),
+        w((u) => typeof u == "number" ? se(u).pipe(
+          p(() => ({
+            type: "refetch",
+            ignoreStale: !0
+          })),
+          w(() => T)
+        ) : T)
       )
     );
-  };
-  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)), At = (t, e) => t.store$.pipe(
+  p((r) => [...r.keys()]),
+  Ie([]),
+  ce(),
+  _(([r, n]) => {
+    const s = Ut(n, r);
+    return E(
+      ...s.map((i) => {
+        const u = t.store$.pipe(
+          p(() => t.get(i)),
+          $((l) => l === void 0)
         );
-        return merge(NEVER, of(key)).pipe(
-          tap(() => {
+        return E(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
-          )
-        };
-      },
+), je = (t) => t.pipe(
+  w((e) => Fe(e.runners)),
+  p((e) => e.map(({ options: r }) => r))
+), jt = (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")
+  C(M)
+), 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(
+          je,
+          jt,
+          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 }) => se(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(
+  C(M)
+), Wt = (t) => t.pipe(
+  p((e) => e.cache_fnResult),
+  C(M)
+), Yt = ({
+  queryStore: t
+}) => (e) => e.pipe(
+  w((r) => {
+    const n = t.get$(r);
+    return n.pipe(
+      Wt,
+      w(
+        () => n.pipe(
+          je,
+          Jt,
+          w(
             ({
-              lowestCacheTime = 5 * 60 * 1e3
+              lowestCacheTime: i = 5 * 60 * 1e3
               /* 5mn */
-            }) => timer(lowestCacheTime).pipe(
-              tap(() => {
-                queryStore.update(key, { cache_fnResult: void 0 });
+            }) => se(i).pipe(
+              x(() => {
+                t.update(r, { cache_fnResult: void 0 });
               })
             )
           )
         )
       )
-    );
-    return invalidateCache$.pipe(map(() => key));
-  })
-);
-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)
-    );
+    ).pipe(p(() => r));
   })
-);
-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),
+    ce(),
+    $(([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
-        });
+    }));
+  }
+}), 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
+    }));
+  }),
+  $((n) => n.type !== "refetch")
+), V = (t) => ne(() => {
+  const e = t();
+  return e instanceof Promise ? re(e) : e instanceof Te ? e : S(e);
+}), er = ({
+  variables: t,
+  state: e,
+  options: r
+}) => {
+  const n = e.isPaused, s = async () => await Promise.reject(new Error("No mutationFn found")), i = r.mutationFn ?? s, l = Me(
+    () => 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;
       }
-    })
-  );
-};
-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
-      });
+    )
+  ).pipe(J()), f = (a, c, o) => (console.error(a), V(
+    () => {
+      var R;
+      return (R = r.onError) == null ? void 0 : R.call(r, a, t, c);
     }
-  }),
-  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)
-  )
-);
-class Mutation {
-  constructor({
-    args,
-    ...options
-  }) {
-    __publicField(this, "stateSubject", new ReplaySubject(1));
-    /**
-     * @important
-     * convenience over usage of stateSubject for sync access
-     */
-    __publicField(this, "state", getDefaultMutationState());
-    __publicField(this, "options");
-    __publicField(this, "mutation$");
-    this.options = options;
-    const mutationFn = options.mutationFn;
-    this.state.variables = args;
-    this.stateSubject.next(this.state);
-    const mutationFnObservable = typeof mutationFn === "function" ? defer(() => from(mutationFn(args))) : mutationFn;
-    const queryRunner$ = mutationFnObservable.pipe(
-      retryOnError(options),
-      take(1),
-      map((data) => ({ data, isError: false })),
-      catchError((error) => {
-        console.error(error);
-        if (options.onError != null) {
-          options.onError(error, args);
-        }
-        return of({ data: error, isError: true });
+  ).pipe(
+    j(() => S(a)),
+    p(
+      () => ({
+        failureCount: o,
+        error: a,
+        failureReason: a,
+        context: c,
+        status: "error"
       })
-    );
-    const initState$ = of({
-      ...this.state,
-      status: "pending",
-      submittedAt: (/* @__PURE__ */ new Date()).getTime()
-    });
-    this.mutation$ = merge(
-      initState$,
-      queryRunner$.pipe(
-        map(({ data, isError }) => {
-          if (!isError) {
-            if (options.onSuccess != null)
-              options.onSuccess(data, args);
-          }
-          return isError ? {
-            status: "error",
-            error: data,
-            data: void 0
-          } : {
-            status: "success",
-            error: null,
-            data
-          };
+    )
+  )), 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
         })
-      )
-    ).pipe(
-      mergeResults,
-      tap((value) => {
-        this.state = { ...this.state, ...value };
-        this.stateSubject.next(this.state);
+      ),
+      Ue({
+        ...r,
+        caughtError: (o, m) => S({
+          failureCount: o,
+          failureReason: m
+        }),
+        catchError: (o, m) => f(m, a, o).pipe(
+          p((R) => ({
+            ...R,
+            result: void 0
+          }))
+        )
       }),
-      options.__queryRunnerHook ?? identity,
-      share()
-    );
-  }
-}
-const createMutationRunner = ({
-  __queryFinalizeHook,
-  __queryInitHook,
-  __queryTriggerHook
-}) => {
-  const trigger$ = new Subject();
-  const cancel$ = new Subject();
-  let closed = false;
-  const mapOperator$ = new BehaviorSubject("merge");
-  const mutationsSubject = new BehaviorSubject([]);
-  const destroy = () => {
-    if (closed) {
-      throw new Error("Trying to close an already closed mutation");
-    }
-    closed = true;
-    mapOperator$.complete();
-    mutationsSubject.complete();
-    trigger$.complete();
-    cancel$.next();
-    cancel$.complete();
-  };
-  const stableMapOperator$ = mapOperator$.pipe(
-    filter(isDefined),
-    distinctUntilChanged()
-  );
-  const mutation$ = stableMapOperator$.pipe(
-    __queryInitHook ?? identity,
-    mergeMap((mapOperator) => {
-      const switchOperator = mapOperator === "concat" ? concatMap$1 : mapOperator === "switch" ? switchMap : mergeMap;
-      let mutationsForCurrentMapOperatorSubject = [];
-      const removeMutation = (mutation) => {
-        mutationsForCurrentMapOperatorSubject = mutationsForCurrentMapOperatorSubject.filter(
-          (item) => item !== mutation
+      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 E(
+    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
+          });
+        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
+            );
+          }
+        ), 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(
+          j((v) => a ? S(a) : S(v))
         );
-        mutationsSubject.next(
-          mutationsSubject.getValue().filter((item) => item !== mutation)
+        return ie(m, b).pipe(
+          ue(),
+          p(
+            () => c ? {
+              error: c,
+              data: void 0,
+              variables: t,
+              ...o
+            } : {
+              status: "success",
+              error: c,
+              data: a == null ? void 0 : a.data,
+              variables: t,
+              ...o
+            }
+          ),
+          j(
+            (v) => f(v, o.context, 0).pipe(
+              p((O) => ({
+                ...O,
+                data: void 0
+              }))
+            )
+          )
         );
-      };
-      return trigger$.pipe(
-        takeUntil(stableMapOperator$.pipe(skip(1))),
-        map(({ args, options }) => {
-          const mutation = new Mutation({
-            args,
-            ...options,
-            mapOperator
-          });
-          mutationsForCurrentMapOperatorSubject = [
-            ...mutationsForCurrentMapOperatorSubject,
-            mutation
-          ];
-          mutationsSubject.next([...mutationsSubject.getValue(), mutation]);
-          return mutation;
-        }),
-        switchOperator((mutation) => {
-          if (!mutationsSubject.getValue().includes(mutation))
-            return of({});
-          const queryIsOver$ = mutation.mutation$.pipe(
-            map(({ data, error }) => error || data)
-          );
-          const isThisCurrentFunctionLastOneCalled = trigger$.pipe(
-            take(1),
-            map(() => mapOperator === "concat"),
-            startWith(true),
-            takeUntil(queryIsOver$)
-          );
-          const result$ = combineLatest([
-            mutation.mutation$,
-            isThisCurrentFunctionLastOneCalled
-          ]).pipe(
-            map(([result, isLastMutationCalled]) => {
-              if ((result.status === "success" || result.status === "error") && !isLastMutationCalled) {
-                return {};
-              }
-              return result;
-            }),
-            takeUntil(cancel$.pipe()),
-            mergeResults,
-            finalize(() => {
-              removeMutation(mutation);
-            })
-          );
-          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()),
+    C(
+      ({ data: a, ...c }, { data: o, ...m }) => M(c, m) && M(a, o)
+    )
   );
-  cancel$.subscribe(() => {
-    if (mutationsSubject.getValue().length === 0)
-      return;
-    mutationsSubject.next([]);
-  });
-  return {
-    mutation$,
-    trigger: ({
-      args,
-      options
-    }) => {
-      mapOperator$.next(options.mapOperator);
-      trigger$.next({ args, options });
-    },
-    cancel$,
-    destroy,
-    mutationsSubject,
-    getClosed: () => closed
-  };
 };
-const createPredicateForFilters = ({
-  mutationKey,
-  status,
-  predicate
-} = {}) => {
-  const defaultPredicate = (mutation) => {
-    if (mutationKey !== void 0 && // @todo optimize
-    serializeKey(mutation.options.mutationKey) !== serializeKey(mutationKey)) {
-      return false;
-    }
-    if (status && mutation.state.status !== status)
-      return false;
-    return true;
-  };
-  const finalPredicate = predicate ?? defaultPredicate;
-  return finalPredicate;
-};
-class MutationResultObserver {
-  constructor(mutationRunnersByKey$) {
-    /**
-     * Mutation result subject. It can be used whether there is a mutation
-     * running or not and can be directly observed.
-     *
-     * @important
-     * - automatically cleaned as soon as the last mutation is done for a given key
-     */
-    __publicField(this, "mutationResults$", new BehaviorSubject(/* @__PURE__ */ new Map()));
-    mutationRunnersByKey$.pipe(
-      switchMap((mapItem) => {
-        const runners = Array.from(mapItem.values()).map((runner) => {
-          const serializedMutationKey = serializeKey(runner.mutationKey);
-          return runner.mutation$.pipe(
-            tap((result) => {
-              this.updateResultForKey({
-                serializedMutationKey,
-                result
-              });
-            }),
-            finalize(() => {
-              this.deleteResultForKey({ serializedMutationKey });
-            })
-          );
-        });
-        return merge(...runners);
+class tr {
+  constructor({
+    options: e,
+    mutationCache: r,
+    state: n
+  }) {
+    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 ie(g, a).pipe(ue());
+            },
+            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 ie(a, c).pipe(ue());
+            },
+            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 ie(g, a).pipe(ue());
+            }
+          },
+          state: this.state,
+          variables: l
+        })
+      ),
+      x((l) => {
+        this.state = { ...this.state, ...l };
+      }),
+      P(this.destroySubject)
+    );
+    this.state$ = E(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)
+       */
+      $e({ bufferSize: 1, refCount: !1 }),
+      P(this.destroySubject),
+      ke((l) => {
+        this.observerCount.next(l);
       })
-    ).subscribe();
+    );
   }
-  getDefaultResultValue() {
-    return {
-      ...getDefaultMutationState(),
-      isSuccess: false,
-      isPending: false,
-      isIdle: true,
-      isError: false
-    };
+  get meta() {
+    return this.options.meta;
   }
-  deleteResultForKey({
-    serializedMutationKey
-  }) {
-    const resultMap = this.mutationResults$.getValue();
-    resultMap.delete(serializedMutationKey);
-    this.mutationResults$.next(resultMap);
+  setOptions(e) {
+    this.options = { ...this.options, ...e };
   }
-  updateResultForKey({
-    serializedMutationKey,
-    result
-  }) {
-    const resultForKeySubject = this.mutationResults$.getValue().get(serializedMutationKey);
-    const valueForResult = {
-      ...this.getDefaultResultValue(),
-      ...result,
-      isSuccess: result.status === "success",
-      isPending: result.status === "pending",
-      isIdle: result.status === "idle",
-      isError: result.status === "error"
-    };
-    if (!resultForKeySubject) {
-      const resultMap = this.mutationResults$.getValue();
-      resultMap.set(
-        serializedMutationKey,
-        new BehaviorSubject(valueForResult)
-      );
-      this.mutationResults$.next(resultMap);
-    } else {
-      resultForKeySubject == null ? void 0 : resultForKeySubject.next(valueForResult);
-    }
+  observeTillFinished() {
+    return this.state$.pipe(
+      ve(
+        (e) => e.status !== "error" && e.status !== "success",
+        !0
+      )
+    );
   }
-  observe({ key }) {
-    var _a;
-    const currentResultValue = (_a = this.mutationResults$.getValue().get(key)) == null ? void 0 : _a.getValue();
-    const lastValue = currentResultValue ?? this.getDefaultResultValue();
-    const result$ = this.mutationResults$.pipe(
-      switchMap((resultMap) => {
-        const subject = resultMap.get(key);
-        return subject ?? EMPTY;
-      })
-    ).pipe(filter(isDefined));
-    return { result$, lastValue };
+  /**
+   * @important
+   * The resulting observable will complete as soon as the mutation
+   * is over, unlike the state which can be re-subscribed later.
+   */
+  execute(e) {
+    return this.executeSubject.next(e), this.executeSubject.complete(), this.observeTillFinished();
+  }
+  continue() {
+    return this.execute(this.state.variables);
   }
   destroy() {
-    this.mutationResults$.complete();
+    this.destroySubject.next(), this.destroySubject.complete(), this.executeSubject.complete();
+  }
+  reset() {
+    this.resetSubject.next(), this.resetSubject.complete(), this.destroy();
   }
 }
-class MutationClient {
-  constructor() {
-    /**
-     * 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()));
-    __publicField(this, "mutate$", new Subject());
-    __publicField(this, "cancel$", new Subject());
-    /**
-     * Observable to track how many running mutations per runner
-     */
-    __publicField(this, "isMutatingSubject", new BehaviorSubject([]));
-    /**
-     * List of all mutations running
-     */
-    __publicField(this, "mutationsSubject", new BehaviorSubject([]));
-    __publicField(this, "mutationResultObserver", new MutationResultObserver(
-      this.mutationRunnersByKey$
+const he = ({
+  mutationKey: t,
+  status: e,
+  predicate: r,
+  exact: n = !0
+} = {}) => (i) => n && t !== void 0 && i.options.mutationKey !== void 0 && !oe(i.options.mutationKey, t, { exact: n }) || !n && t !== void 0 && i.options.mutationKey !== void 0 && !oe(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)),
+      C(Le),
+      J()
     ));
-    this.mutate$.pipe(
-      tap(({ options, args }) => {
-        const { mutationKey } = options;
-        const serializedMutationKey = serializeKey(mutationKey);
-        let mutationForKey = this.getMutationRunnersByKey(
-          serializedMutationKey
-        );
-        if (!mutationForKey) {
-          mutationForKey = {
-            ...createMutationRunner(options),
-            mutationKey
-          };
-          this.setMutationRunnersByKey(serializedMutationKey, mutationForKey);
-          mutationForKey.mutation$.subscribe();
-          mutationForKey.mutationsSubject.pipe(
-            distinctUntilChanged(shallowEqual),
-            skip(1),
-            filter((items) => items.length === 0)
-          ).subscribe(() => {
-            mutationForKey == null ? void 0 : mutationForKey.destroy();
-            this.deleteMutationRunnersByKey(serializedMutationKey);
-          });
-        }
-        mutationForKey.trigger({ args, options });
-      })
-    ).subscribe();
-    this.cancel$.pipe(
-      tap(({ key }) => {
-        var _a;
-        const serializedKey = serializeKey(key);
-        (_a = this.mutationRunnersByKey$.getValue().get(serializedKey)) == null ? void 0 : _a.cancel$.next();
-      })
-    ).subscribe();
-    this.mutationRunnersByKey$.pipe(
-      switchMap((mapItem) => {
-        const mutationRunners = Array.from(mapItem.values());
-        const mutations$ = combineLatest(
-          mutationRunners.map(
-            (runner) => runner.mutationsSubject.pipe(
-              map((mutations) => mutations.map((mutation) => mutation))
+    y(this, "added$", this.mutations$.pipe(
+      ce(),
+      p(
+        ([e, r]) => r.filter((n) => !e.includes(n))[0]
+      ),
+      $(G),
+      J()
+    ));
+    y(this, "removed$", this.mutations$.pipe(
+      ce(),
+      p(
+        ([e, r]) => e.filter((n) => !r.includes(n))
+      ),
+      _((e) => re(e)),
+      J()
+    ));
+    y(this, "stateChange$", this.added$.pipe(
+      _(
+        (e) => e.state$.pipe(
+          p(() => e),
+          P(
+            this.removed$.pipe(
+              $((r) => r === e)
             )
           )
+        )
+      ),
+      J()
+    ));
+    this.config = e;
+  }
+  build(e, r, n) {
+    const s = new tr({
+      mutationCache: this,
+      options: e.defaultMutationOptions(r),
+      state: n
+    });
+    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
+       */
+      $(({ status: i }) => i === "success" || i === "error"),
+      w(
+        () => s.observerCount$.pipe(
+          $((i) => i <= 1),
+          be(1)
+        )
+      ),
+      // defaults to 5mn
+      w(() => se(s.options.gcTime ?? 5 * 60 * 1e3)),
+      be(1)
+    ).subscribe({
+      complete: () => {
+        this.mutationsSubject.next(
+          this.mutationsSubject.getValue().filter((i) => s !== i)
         );
-        return mutations$.pipe(
-          map(
-            (mutationsByKeys) => mutationsByKeys.reduce((acc, value) => [...acc, ...value], [])
-          )
-        );
-      }),
-      startWith([]),
-      distinctUntilChanged(shallowEqual)
-    ).subscribe(this.mutationsSubject);
+      }
+    }), this.mutationsSubject.next([...this.mutationsSubject.getValue(), s]), s;
   }
-  /**
-   * @helper
-   */
-  setMutationRunnersByKey(key, value) {
-    const map2 = this.mutationRunnersByKey$.getValue();
-    map2.set(key, value);
-    this.mutationRunnersByKey$.next(map2);
+  getAll() {
+    return this.findAll();
   }
-  /**
-   * @helper
-   */
-  deleteMutationRunnersByKey(key) {
-    const map2 = this.mutationRunnersByKey$.getValue();
-    map2.delete(key);
-    this.mutationRunnersByKey$.next(map2);
+  remove(e) {
+    const r = this.mutationsSubject.getValue().find((n) => n === e);
+    r == null || r.destroy();
   }
-  /**
-   * @helper
-   */
-  getMutationRunnersByKey(key) {
-    return this.mutationRunnersByKey$.getValue().get(key);
+  find(e) {
+    const r = { exact: !0, ...e }, n = he(r);
+    return this.mutationsSubject.getValue().find((s) => n(s));
   }
-  useIsMutating(filters = {}) {
-    const predicate = createPredicateForFilters(filters);
-    const reduceByNumber = (entries) => entries.reduce((acc, mutation) => {
-      return predicate(mutation) && mutation.state.status === "pending" ? 1 + acc : acc;
-    }, 0);
-    const lastValue = reduceByNumber(this.mutationsSubject.getValue());
-    const value$ = this.mutationsSubject.pipe(
-      switchMap((mutations) => {
-        const mutationsOnStateUpdate = mutations.map(
-          (mutation) => mutation.stateSubject.pipe(map(() => mutation))
-        );
-        return mutationsOnStateUpdate.length === 0 ? of([]) : combineLatest(mutationsOnStateUpdate);
-      }),
-      map(reduceByNumber),
-      distinctUntilChanged()
-    );
-    return { value$, lastValue };
+  findAll(e = {}) {
+    const r = { exact: !0, ...e }, n = he(r);
+    return this.mutationsSubject.getValue().filter((s) => n(s)).map((s) => s);
   }
-  mutationState({
-    filters,
-    select
+  observe({
+    filters: e,
+    select: r
   } = {}) {
-    const predicate = createPredicateForFilters(filters);
-    const finalSelect = select ?? ((mutation) => mutation.state);
-    const lastValue = this.mutationsSubject.getValue().reduce((acc, mutation) => {
-      const result = [...acc, mutation];
-      return result;
-    }, []).filter(predicate).map((mutation) => finalSelect(mutation));
-    const value$ = this.mutationsSubject.pipe(
-      switchMap((mutations) => {
-        const mutationsOnStateUpdate = mutations.map(
-          (mutation) => mutation.stateSubject.pipe(
-            filter(() => predicate(mutation)),
-            map(() => finalSelect(mutation))
-          )
-        );
-        return mutationsOnStateUpdate.length === 0 ? of([]) : combineLatest(mutationsOnStateUpdate);
-      }),
-      distinctUntilChanged(shallowEqual)
-    );
-    return { value$, lastValue };
-  }
-  mutate(params) {
-    this.mutate$.next(params);
+    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)),
+      C(M)
+    ), lastValue: i };
   }
   /**
-   * This will cancel any current mutation runnings.
-   * No discrimination process
+   * @important
+   * ISO api react-query
    */
-  cancel(params) {
-    this.cancel$.next(params);
+  subscribe(e) {
+    const r = E(
+      this.added$.pipe(
+        x((n) => {
+          e({
+            type: "added",
+            mutation: n
+          });
+        })
+      ),
+      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 () => {
+      r.unsubscribe();
+    };
   }
-  destroy() {
-    this.cancel$.complete();
-    this.mutate$.complete();
-    this.mutationResultObserver.destroy();
-    this.mutationRunnersByKey$.complete();
-    this.isMutatingSubject.complete();
-    this.mutationsSubject.complete();
+  resumePausedMutations() {
+    const e = this.findAll({
+      predicate: (n) => n.state.isPaused
+    });
+    if (!e.length)
+      return T;
+    const r = e.map((n) => n.continue());
+    return Fe(r);
+  }
+  clear() {
+    this.getAll().forEach((e) => {
+      this.remove(e);
+    });
   }
 }
-const createClient = () => {
-  const queryStore = createQueryStore();
-  const invalidationClient = createInvalidationClient({ queryStore });
-  const cacheClient = createCacheClient({ queryStore });
-  const refetchClient = createRefetchClient();
-  const mutationClient = new MutationClient();
-  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 R = c.pipe(p((O) => ({ options: O })));
+    let b = () => {
     };
-    const trigger$ = merge(
-      externalTrigger$.pipe(
-        dispatchExternalRefetchToAllQueries({
-          queryStore,
-          serializedKey
-        })
-      ),
-      createQueryTrigger({
-        options$,
-        key: serializedKey,
-        queryStore
-      })
-    ).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$
+    const A = E(
+      a.pipe(
+        Bt({
+          queryStore: t,
+          serializedKey: o
         })
       ),
-      mergeResults$1,
-      withLatestFrom(options$),
-      takeWhile(([result, options]) => {
-        const shouldStop = result.data !== void 0 && options.terminateOnFirstResult;
-        return !shouldStop;
-      }, true),
-      map(([result]) => result),
-      finalize(() => {
-        deleteRunner();
+      Qt({
+        options$: c,
+        key: o,
+        queryStore: t
       })
-    );
+    ).pipe(J());
     return {
-      result$
+      result$: E(
+        S({
+          type: "initial"
+        }),
+        A
+      ).pipe(
+        Ht({
+          key: d,
+          queryStore: t,
+          runner$: R,
+          serializedKey: o,
+          options$: c
+        }),
+        p(([O, Q]) => (Q && (b = Q), O)),
+        qt({
+          key: d,
+          options$: c,
+          queryStore: t,
+          serializedKey: o
+        }),
+        D(m, c),
+        p(([O, Q, z]) => ({ trigger: O, fn: Q, options: z })),
+        p((O) => (X.log(o, "query trigger", {
+          trigger: O.trigger,
+          options: O.options
+        }), O)),
+        $(({ options: O }) => O.enabled !== !1),
+        _(
+          ({ fn: O, options: Q, trigger: z }) => Nt({
+            options$: c,
+            options: Q,
+            fn: O,
+            queryStore: t,
+            serializedKey: o,
+            trigger: z,
+            trigger$: A
+          })
+        ),
+        xt,
+        D(c),
+        ve(([O, Q]) => !(O.data !== void 0 && Q.terminateOnFirstResult), !0),
+        p(([O]) => O),
+        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 = At(
+    t,
+    (d) => d.pipe(
+      w((h) => {
+        const g = S(h);
+        return E(
+          Yt({
+            queryStore: t
+          })(g),
+          zt({
+            queryStore: t
+          })(g),
+          Gt({
+            queryStore: t
+          })(g)
         );
       })
     )
   );
-  const start = () => {
-    hasCalledStart = true;
-    const queryListenerSub = queryListener$.subscribe();
-    const started = [queryStore.start()];
-    return () => {
-      started.forEach((destroy2) => {
-        destroy2();
-      });
-      queryListenerSub.unsubscribe();
-    };
-  };
-  const destroy = () => {
-    mutationClient.destroy();
-  };
   return {
-    start,
-    query,
-    queryStore,
-    mutationClient,
-    ...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() {
-    __publicField(this, "client");
-    this.client = createClient();
+var te;
+class Sr {
+  constructor({ mutationCache: e } = {
+    mutationCache: new rr()
+  }) {
+    y(this, "client");
+    y(this, "mutationCache");
+    de(this, te, /* @__PURE__ */ new Map());
+    this.mutationCache = e, this.client = nr();
+  }
+  mount() {
+    const e = this.client.start();
+    return () => {
+      e();
+    };
+  }
+  getMutationCache() {
+    return this.mutationCache;
+  }
+  defaultMutationOptions(e) {
+    return {
+      ...(e == null ? void 0 : e.mutationKey) && this.getMutationDefaults(e.mutationKey),
+      ...e
+    };
+  }
+  getMutationDefaults(e) {
+    const r = [...k(this, te).values()];
+    let n = {};
+    return r.forEach((s) => {
+      oe(e, s.mutationKey) && (n = { ...n, ...s.defaultOptions });
+    }), n;
+  }
+  setMutationDefaults(e, r) {
+    k(this, te).set(N(e), {
+      mutationKey: e,
+      defaultOptions: r
+    });
+  }
+  async resumePausedMutations() {
+    return await nt(this.mutationCache.resumePausedMutations());
+  }
+  clear() {
   }
 }
+te = new WeakMap();
 export {
-  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,
+  Ee as useSubject,
+  Se as useSubscribe,
+  vr as useSubscribeEffect,
+  mr as useUnmountObservable
 };