@adyen/adyen-platform-experience-web 1.10.1 → 1.11.0

package/dist/es/external/.pnpm/@tanstack_query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/queryObserver.js

@@ -0,0 +1,301 @@
+import { focusManager as z } from "./focusManager.js";
+import { environmentManager as L } from "./environmentManager.js";
+import { notifyManager as B } from "./notifyManager.js";
+import { fetchState as H } from "./query.js";
+import { Subscribable as V } from "./subscribable.js";
+import { pendingThenable as k } from "./thenable.js";
+import { resolveEnabled as o, shallowEqualObjects as C, resolveStaleTime as d, noop as K, isValidTimeout as A, timeUntilStale as N, replaceData as _ } from "./utils.js";
+import { timeoutManager as R } from "./timeoutManager.js";
+var rt = class extends V {
+  constructor(t, e) {
+    super(), this.options = e, this.#s = t, this.#r = null, this.#i = k(), this.bindMethods(), this.setOptions(e);
+  }
+  #s;
+  #t = void 0;
+  #p = void 0;
+  #e = void 0;
+  #a;
+  #c;
+  #i;
+  #r;
+  #b;
+  #u;
+  // This property keeps track of the last query with defined data.
+  // It will be used to pass the previous data and query to the placeholder function between renders.
+  #d;
+  #h;
+  #o;
+  #n;
+  #f = /* @__PURE__ */ new Set();
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    this.listeners.size === 1 && (this.#t.addObserver(this), j(this.#t, this.options) ? this.#l() : this.updateResult(), this.#g());
+  }
+  onUnsubscribe() {
+    this.hasListeners() || this.destroy();
+  }
+  shouldFetchOnReconnect() {
+    return T(
+      this.#t,
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return T(
+      this.#t,
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set(), this.#O(), this.#y(), this.#t.removeObserver(this);
+  }
+  setOptions(t) {
+    const e = this.options, s = this.#t;
+    if (this.options = this.#s.defaultQueryOptions(t), this.options.enabled !== void 0 && typeof this.options.enabled != "boolean" && typeof this.options.enabled != "function" && typeof o(this.options.enabled, this.#t) != "boolean")
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    this.#S(), this.#t.setOptions(this.options), e._defaulted && !C(this.options, e) && this.#s.getQueryCache().notify({
+      type: "observerOptionsUpdated",
+      query: this.#t,
+      observer: this
+    });
+    const i = this.hasListeners();
+    i && W(
+      this.#t,
+      s,
+      this.options,
+      e
+    ) && this.#l(), this.updateResult(), i && (this.#t !== s || o(this.options.enabled, this.#t) !== o(e.enabled, this.#t) || d(this.options.staleTime, this.#t) !== d(e.staleTime, this.#t)) && this.#v();
+    const a = this.#m();
+    i && (this.#t !== s || o(this.options.enabled, this.#t) !== o(e.enabled, this.#t) || a !== this.#n) && this.#R(a);
+  }
+  getOptimisticResult(t) {
+    const e = this.#s.getQueryCache().build(this.#s, t), s = this.createResult(e, t);
+    return J(this, s) && (this.#e = s, this.#c = this.options, this.#a = this.#t.state), s;
+  }
+  getCurrentResult() {
+    return this.#e;
+  }
+  trackResult(t, e) {
+    return new Proxy(t, {
+      get: (s, i) => (this.trackProp(i), e?.(i), i === "promise" && (this.trackProp("data"), !this.options.experimental_prefetchInRender && this.#i.status === "pending" && this.#i.reject(
+        new Error(
+          "experimental_prefetchInRender feature flag is not enabled"
+        )
+      )), Reflect.get(s, i))
+    });
+  }
+  trackProp(t) {
+    this.#f.add(t);
+  }
+  getCurrentQuery() {
+    return this.#t;
+  }
+  refetch({ ...t } = {}) {
+    return this.fetch({
+      ...t
+    });
+  }
+  fetchOptimistic(t) {
+    const e = this.#s.defaultQueryOptions(t), s = this.#s.getQueryCache().build(this.#s, e);
+    return s.fetch().then(() => this.createResult(s, e));
+  }
+  fetch(t) {
+    return this.#l({
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }).then(() => (this.updateResult(), this.#e));
+  }
+  #l(t) {
+    this.#S();
+    let e = this.#t.fetch(
+      this.options,
+      t
+    );
+    return t?.throwOnError || (e = e.catch(K)), e;
+  }
+  #v() {
+    this.#O();
+    const t = d(
+      this.options.staleTime,
+      this.#t
+    );
+    if (L.isServer() || this.#e.isStale || !A(t))
+      return;
+    const s = N(this.#e.dataUpdatedAt, t) + 1;
+    this.#h = R.setTimeout(() => {
+      this.#e.isStale || this.updateResult();
+    }, s);
+  }
+  #m() {
+    return (typeof this.options.refetchInterval == "function" ? this.options.refetchInterval(this.#t) : this.options.refetchInterval) ?? !1;
+  }
+  #R(t) {
+    this.#y(), this.#n = t, !(L.isServer() || o(this.options.enabled, this.#t) === !1 || !A(this.#n) || this.#n === 0) && (this.#o = R.setInterval(() => {
+      (this.options.refetchIntervalInBackground || z.isFocused()) && this.#l();
+    }, this.#n));
+  }
+  #g() {
+    this.#v(), this.#R(this.#m());
+  }
+  #O() {
+    this.#h && (R.clearTimeout(this.#h), this.#h = void 0);
+  }
+  #y() {
+    this.#o && (R.clearInterval(this.#o), this.#o = void 0);
+  }
+  createResult(t, e) {
+    const s = this.#t, i = this.options, a = this.#e, f = this.#a, g = this.#c, O = t !== s ? t.state : this.#p, { state: w } = t;
+    let r = { ...w }, D = !1, n;
+    if (e._optimisticResults) {
+      const h = this.hasListeners(), u = !h && j(t, e), b = h && W(t, s, e, i);
+      (u || b) && (r = {
+        ...r,
+        ...H(w.data, t.options)
+      }), e._optimisticResults === "isRestoring" && (r.fetchStatus = "idle");
+    }
+    let { error: F, errorUpdatedAt: E, status: c } = r;
+    n = r.data;
+    let U = !1;
+    if (e.placeholderData !== void 0 && n === void 0 && c === "pending") {
+      let h;
+      a?.isPlaceholderData && e.placeholderData === g?.placeholderData ? (h = a.data, U = !0) : h = typeof e.placeholderData == "function" ? e.placeholderData(
+        this.#d?.state.data,
+        this.#d
+      ) : e.placeholderData, h !== void 0 && (c = "success", n = _(
+        a?.data,
+        h,
+        e
+      ), D = !0);
+    }
+    if (e.select && n !== void 0 && !U)
+      if (a && n === f?.data && e.select === this.#b)
+        n = this.#u;
+      else
+        try {
+          this.#b = e.select, n = e.select(n), n = _(a?.data, n, e), this.#u = n, this.#r = null;
+        } catch (h) {
+          this.#r = h;
+        }
+    this.#r && (F = this.#r, n = this.#u, E = Date.now(), c = "error");
+    const y = r.fetchStatus === "fetching", S = c === "pending", I = c === "error", P = S && y, M = n !== void 0, l = {
+      status: c,
+      fetchStatus: r.fetchStatus,
+      isPending: S,
+      isSuccess: c === "success",
+      isError: I,
+      isInitialLoading: P,
+      isLoading: P,
+      data: n,
+      dataUpdatedAt: r.dataUpdatedAt,
+      error: F,
+      errorUpdatedAt: E,
+      failureCount: r.fetchFailureCount,
+      failureReason: r.fetchFailureReason,
+      errorUpdateCount: r.errorUpdateCount,
+      isFetched: t.isFetched(),
+      isFetchedAfterMount: r.dataUpdateCount > O.dataUpdateCount || r.errorUpdateCount > O.errorUpdateCount,
+      isFetching: y,
+      isRefetching: y && !S,
+      isLoadingError: I && !M,
+      isPaused: r.fetchStatus === "paused",
+      isPlaceholderData: D,
+      isRefetchError: I && M,
+      isStale: Q(t, e),
+      refetch: this.refetch,
+      promise: this.#i,
+      isEnabled: o(e.enabled, t) !== !1
+    };
+    if (this.options.experimental_prefetchInRender) {
+      const h = l.data !== void 0, u = l.status === "error" && !h, b = (m) => {
+        u ? m.reject(l.error) : h && m.resolve(l.data);
+      }, x = () => {
+        const m = this.#i = l.promise = k();
+        b(m);
+      }, v = this.#i;
+      switch (v.status) {
+        case "pending":
+          t.queryHash === s.queryHash && b(v);
+          break;
+        case "fulfilled":
+          (u || l.data !== v.value) && x();
+          break;
+        case "rejected":
+          (!u || l.error !== v.reason) && x();
+          break;
+      }
+    }
+    return l;
+  }
+  updateResult() {
+    const t = this.#e, e = this.createResult(this.#t, this.options);
+    if (this.#a = this.#t.state, this.#c = this.options, this.#a.data !== void 0 && (this.#d = this.#t), C(e, t))
+      return;
+    this.#e = e;
+    const s = () => {
+      if (!t)
+        return !0;
+      const { notifyOnChangeProps: i } = this.options, a = typeof i == "function" ? i() : i;
+      if (a === "all" || !a && !this.#f.size)
+        return !0;
+      const f = new Set(
+        a ?? this.#f
+      );
+      return this.options.throwOnError && f.add("error"), Object.keys(this.#e).some((g) => {
+        const p = g;
+        return this.#e[p] !== t[p] && f.has(p);
+      });
+    };
+    this.#I({ listeners: s() });
+  }
+  #S() {
+    const t = this.#s.getQueryCache().build(this.#s, this.options);
+    if (t === this.#t)
+      return;
+    const e = this.#t;
+    this.#t = t, this.#p = t.state, this.hasListeners() && (e?.removeObserver(this), t.addObserver(this));
+  }
+  onQueryUpdate() {
+    this.updateResult(), this.hasListeners() && this.#g();
+  }
+  #I(t) {
+    B.batch(() => {
+      t.listeners && this.listeners.forEach((e) => {
+        e(this.#e);
+      }), this.#s.getQueryCache().notify({
+        query: this.#t,
+        type: "observerResultsUpdated"
+      });
+    });
+  }
+};
+function G(t, e) {
+  return o(e.enabled, t) !== !1 && t.state.data === void 0 && !(t.state.status === "error" && e.retryOnMount === !1);
+}
+function j(t, e) {
+  return G(t, e) || t.state.data !== void 0 && T(t, e, e.refetchOnMount);
+}
+function T(t, e, s) {
+  if (o(e.enabled, t) !== !1 && d(e.staleTime, t) !== "static") {
+    const i = typeof s == "function" ? s(t) : s;
+    return i === "always" || i !== !1 && Q(t, e);
+  }
+  return !1;
+}
+function W(t, e, s, i) {
+  return (t !== e || o(i.enabled, t) === !1) && (!s.suspense || t.state.status !== "error") && Q(t, s);
+}
+function Q(t, e) {
+  return o(e.enabled, t) !== !1 && t.isStaleByTime(d(e.staleTime, t));
+}
+function J(t, e) {
+  return !C(t.getCurrentResult(), e);
+}
+export {
+  rt as QueryObserver
+};

package/dist/es/external/.pnpm/@tanstack_query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/removable.js

@@ -0,0 +1,26 @@
+import { timeoutManager as i } from "./timeoutManager.js";
+import { environmentManager as t } from "./environmentManager.js";
+import { isValidTimeout as m } from "./utils.js";
+var a = class {
+  #i;
+  destroy() {
+    this.clearGcTimeout();
+  }
+  scheduleGc() {
+    this.clearGcTimeout(), m(this.gcTime) && (this.#i = i.setTimeout(() => {
+      this.optionalRemove();
+    }, this.gcTime));
+  }
+  updateGcTime(e) {
+    this.gcTime = Math.max(
+      this.gcTime || 0,
+      e ?? (t.isServer() ? 1 / 0 : 300 * 1e3)
+    );
+  }
+  clearGcTimeout() {
+    this.#i && (i.clearTimeout(this.#i), this.#i = void 0);
+  }
+};
+export {
+  a as Removable
+};

package/dist/es/external/.pnpm/@tanstack_query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/retryer.js

@@ -0,0 +1,76 @@
+import { focusManager as F } from "./focusManager.js";
+import { onlineManager as h } from "./onlineManager.js";
+import { pendingThenable as b } from "./thenable.js";
+import { environmentManager as j } from "./environmentManager.js";
+import { sleep as D } from "./utils.js";
+function E(e) {
+  return Math.min(1e3 * 2 ** e, 3e4);
+}
+function O(e) {
+  return (e ?? "online") === "online" ? h.isOnline() : !0;
+}
+var k = class extends Error {
+  constructor(e) {
+    super("CancelledError"), this.revert = e?.revert, this.silent = e?.silent;
+  }
+};
+function z(e) {
+  let c = !1, s = 0, a;
+  const n = b(), r = () => n.status !== "pending", v = (t) => {
+    if (!r()) {
+      const i = new k(t);
+      u(i), e.onCancel?.(i);
+    }
+  }, R = () => {
+    c = !0;
+  }, C = () => {
+    c = !1;
+  }, f = () => F.isFocused() && (e.networkMode === "always" || h.isOnline()) && e.canRun(), d = () => O(e.networkMode) && e.canRun(), M = (t) => {
+    r() || (a?.(), n.resolve(t));
+  }, u = (t) => {
+    r() || (a?.(), n.reject(t));
+  }, p = () => new Promise((t) => {
+    a = (i) => {
+      (r() || f()) && t(i);
+    }, e.onPause?.();
+  }).then(() => {
+    a = void 0, r() || e.onContinue?.();
+  }), m = () => {
+    if (r())
+      return;
+    let t;
+    const i = s === 0 ? e.initialPromise : void 0;
+    try {
+      t = i ?? e.fn();
+    } catch (o) {
+      t = Promise.reject(o);
+    }
+    Promise.resolve(t).then(M).catch((o) => {
+      if (r())
+        return;
+      const l = e.retry ?? (j.isServer() ? 0 : 3), y = e.retryDelay ?? E, P = typeof y == "function" ? y(s, o) : y, w = l === !0 || typeof l == "number" && s < l || typeof l == "function" && l(s, o);
+      if (c || !w) {
+        u(o);
+        return;
+      }
+      s++, e.onFail?.(s, o), D(P).then(() => f() ? void 0 : p()).then(() => {
+        c ? u(o) : m();
+      });
+    });
+  };
+  return {
+    promise: n,
+    status: () => n.status,
+    cancel: v,
+    continue: () => (a?.(), n),
+    cancelRetry: R,
+    continueRetry: C,
+    canStart: d,
+    start: () => (d() ? m() : p().then(m), n)
+  };
+}
+export {
+  k as CancelledError,
+  O as canFetch,
+  z as createRetryer
+};

package/dist/es/external/.pnpm/@tanstack_query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/subscribable.js

@@ -0,0 +1,20 @@
+var e = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set(), this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(s) {
+    return this.listeners.add(s), this.onSubscribe(), () => {
+      this.listeners.delete(s), this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+};
+export {
+  e as Subscribable
+};

package/dist/es/external/.pnpm/@tanstack_query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/thenable.js

@@ -0,0 +1,25 @@
+function r() {
+  let n, l;
+  const t = new Promise((e, c) => {
+    n = e, l = c;
+  });
+  t.status = "pending", t.catch(() => {
+  });
+  function s(e) {
+    Object.assign(t, e), delete t.resolve, delete t.reject;
+  }
+  return t.resolve = (e) => {
+    s({
+      status: "fulfilled",
+      value: e
+    }), n(e);
+  }, t.reject = (e) => {
+    s({
+      status: "rejected",
+      reason: e
+    }), l(e);
+  }, t;
+}
+export {
+  r as pendingThenable
+};

package/dist/es/external/.pnpm/@tanstack_query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/timeoutManager.js

@@ -0,0 +1,53 @@
+var r = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (e, t) => setTimeout(e, t),
+  clearTimeout: (e) => clearTimeout(e),
+  setInterval: (e, t) => setInterval(e, t),
+  clearInterval: (e) => clearInterval(e)
+}, i = class {
+  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+  // type at app boot; and if we leave that type, then any new timer provider
+  // would need to support the default provider's concrete timer ID, which is
+  // infeasible across environments.
+  //
+  // We settle for type safety for the TimeoutProvider type, and accept that
+  // this class is unsafe internally to allow for extension.
+  #e = r;
+  #t = !1;
+  setTimeoutProvider(e) {
+    process.env.NODE_ENV !== "production" && this.#t && e !== this.#e && console.error(
+      "[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.",
+      { previous: this.#e, provider: e }
+    ), this.#e = e, process.env.NODE_ENV !== "production" && (this.#t = !1);
+  }
+  setTimeout(e, t) {
+    return process.env.NODE_ENV !== "production" && (this.#t = !0), this.#e.setTimeout(e, t);
+  }
+  clearTimeout(e) {
+    this.#e.clearTimeout(e);
+  }
+  setInterval(e, t) {
+    return process.env.NODE_ENV !== "production" && (this.#t = !0), this.#e.setInterval(e, t);
+  }
+  clearInterval(e) {
+    this.#e.clearInterval(e);
+  }
+}, o = new i();
+function s(e) {
+  setTimeout(e, 0);
+}
+export {
+  i as TimeoutManager,
+  r as defaultTimeoutProvider,
+  s as systemSetTimeoutZero,
+  o as timeoutManager
+};

package/dist/es/external/.pnpm/@tanstack_query-core@5.95.2/node_modules/@tanstack/query-core/build/modern/utils.js

@@ -0,0 +1,185 @@
+import { timeoutManager as w } from "./timeoutManager.js";
+var P = typeof window > "u" || "Deno" in globalThis;
+function K() {
+}
+function E(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function I(e) {
+  return typeof e == "number" && e >= 0 && e !== 1 / 0;
+}
+function T(e, t) {
+  return Math.max(e + (t || 0) - Date.now(), 0);
+}
+function v(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function A(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function N(e, t) {
+  const {
+    type: r = "all",
+    exact: n,
+    fetchStatus: i,
+    predicate: u,
+    queryKey: s,
+    stale: f
+  } = e;
+  if (s) {
+    if (n) {
+      if (t.queryHash !== k(s, t.options))
+        return !1;
+    } else if (!O(t.queryKey, s))
+      return !1;
+  }
+  if (r !== "all") {
+    const o = t.isActive();
+    if (r === "active" && !o || r === "inactive" && o)
+      return !1;
+  }
+  return !(typeof f == "boolean" && t.isStale() !== f || i && i !== t.state.fetchStatus || u && !u(t));
+}
+function H(e, t) {
+  const { exact: r, status: n, predicate: i, mutationKey: u } = e;
+  if (u) {
+    if (!t.options.mutationKey)
+      return !1;
+    if (r) {
+      if (p(t.options.mutationKey) !== p(u))
+        return !1;
+    } else if (!O(t.options.mutationKey, u))
+      return !1;
+  }
+  return !(n && t.state.status !== n || i && !i(t));
+}
+function k(e, t) {
+  return (t?.queryKeyHashFn || p)(e);
+}
+function p(e) {
+  return JSON.stringify(
+    e,
+    (t, r) => g(r) ? Object.keys(r).sort().reduce((n, i) => (n[i] = r[i], n), {}) : r
+  );
+}
+function O(e, t) {
+  return e === t ? !0 : typeof e != typeof t ? !1 : e && t && typeof e == "object" && typeof t == "object" ? Object.keys(t).every((r) => O(e[r], t[r])) : !1;
+}
+var q = Object.prototype.hasOwnProperty;
+function m(e, t, r = 0) {
+  if (e === t)
+    return e;
+  if (r > 500) return t;
+  const n = S(e) && S(t);
+  if (!n && !(g(e) && g(t))) return t;
+  const u = (n ? e : Object.keys(e)).length, s = n ? t : Object.keys(t), f = s.length, o = n ? new Array(f) : {};
+  let h = 0;
+  for (let l = 0; l < f; l++) {
+    const c = n ? l : s[l], a = e[c], y = t[c];
+    if (a === y) {
+      o[c] = a, (n ? l < u : q.call(e, c)) && h++;
+      continue;
+    }
+    if (a === null || y === null || typeof a != "object" || typeof y != "object") {
+      o[c] = y;
+      continue;
+    }
+    const j = m(a, y, r + 1);
+    o[c] = j, j === a && h++;
+  }
+  return u === f && h === u ? e : o;
+}
+function M(e, t) {
+  if (!t || Object.keys(e).length !== Object.keys(t).length)
+    return !1;
+  for (const r in e)
+    if (e[r] !== t[r])
+      return !1;
+  return !0;
+}
+function S(e) {
+  return Array.isArray(e) && e.length === Object.keys(e).length;
+}
+function g(e) {
+  if (!d(e))
+    return !1;
+  const t = e.constructor;
+  if (t === void 0)
+    return !0;
+  const r = t.prototype;
+  return !(!d(r) || !r.hasOwnProperty("isPrototypeOf") || Object.getPrototypeOf(e) !== Object.prototype);
+}
+function d(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function z(e) {
+  return new Promise((t) => {
+    w.setTimeout(t, e);
+  });
+}
+function D(e, t, r) {
+  if (typeof r.structuralSharing == "function")
+    return r.structuralSharing(e, t);
+  if (r.structuralSharing !== !1) {
+    if (process.env.NODE_ENV !== "production")
+      try {
+        return m(e, t);
+      } catch (n) {
+        throw console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${r.queryHash}]: ${n}`
+        ), n;
+      }
+    return m(e, t);
+  }
+  return t;
+}
+function Q(e, t, r = 0) {
+  const n = [...e, t];
+  return r && n.length > r ? n.slice(1) : n;
+}
+function $(e, t, r = 0) {
+  const n = [t, ...e];
+  return r && n.length > r ? n.slice(0, -1) : n;
+}
+var b = /* @__PURE__ */ Symbol();
+function x(e, t) {
+  return process.env.NODE_ENV !== "production" && e.queryFn === b && console.error(
+    `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${e.queryHash}'`
+  ), !e.queryFn && t?.initialPromise ? () => t.initialPromise : !e.queryFn || e.queryFn === b ? () => Promise.reject(new Error(`Missing queryFn: '${e.queryHash}'`)) : e.queryFn;
+}
+function J(e, t) {
+  return typeof e == "function" ? e(...t) : !!e;
+}
+function V(e, t, r) {
+  let n = !1, i;
+  return Object.defineProperty(e, "signal", {
+    enumerable: !0,
+    get: () => (i ??= t(), n || (n = !0, i.aborted ? r() : i.addEventListener("abort", r, { once: !0 })), i)
+  }), e;
+}
+export {
+  V as addConsumeAwareSignal,
+  Q as addToEnd,
+  $ as addToStart,
+  x as ensureQueryFn,
+  E as functionalUpdate,
+  p as hashKey,
+  k as hashQueryKeyByOptions,
+  S as isPlainArray,
+  g as isPlainObject,
+  P as isServer,
+  I as isValidTimeout,
+  H as matchMutation,
+  N as matchQuery,
+  K as noop,
+  O as partialMatchKey,
+  D as replaceData,
+  m as replaceEqualDeep,
+  A as resolveEnabled,
+  v as resolveStaleTime,
+  M as shallowEqualObjects,
+  J as shouldThrowError,
+  b as skipToken,
+  z as sleep,
+  T as timeUntilStale
+};