web-core-tcm 0.0.62 → 0.0.64

package/dist/node_modules/alova/dist/clienthook/index.esm.js

@@ -1,89 +1,2129 @@
-import { noop as x, $self as F, isFn as u, isPlainObject as O, undefinedValue as R, instanceOf as A, trueValue as d, falseValue as v, len as w, PromiseCls as V, newInstance as L, forEach as P, splice as b, pushItem as h } from "../../../@alova/shared/dist/alova-shared.esm.js";
-const j = {
+import { isPlainObject as oe, instanceOf as k, trueValue as D, falseValue as w, newInstance as F, PromiseCls as Ut, pushItem as at, isFn as Y, noop as Z, len as N, forEach as X, undefinedValue as p, splice as xt, $self as se, filterItem as Dt, nullValue as Wt, isNumber as At, clearTimeoutTimer as Bs, setTimeoutFn as jt, createAssert as _t, injectReferingObject as Ks, mapItem as vt, FrameworkReadableState as Le, FrameworkState as Bn, objAssign as Ge, includes as Tt, ObjectCls as Me, deleteAttr as pn, objectKeys as yt, getHandlerMethod as es, getContext as He, getMethodInternalKey as Kt, promiseResolve as Ot, sloughConfig as re, omit as Ns, promiseThen as mt, buildNamespacedCacheKey as qs, getTime as ns, createEventManager as qt, createSyncOnceRunner as zs, isArray as lt, objectValues as Ie, usePromise as Ce, getLocalCacheConfigParam as Gs, MEMORY as Hs, promiseCatch as ye, createAsyncQueue as $s, promiseFinally as ue, promiseAll as Ws, decorateEvent as Re, isObject as bt, walkObject as Nt, valueObject as ss, uuid as an, defineProperty as Ze, globalToString as ks, isString as Pe, RegExpCls as rs, regexpTest as fe, shift as Kn, delayWithBackoff as os, getConfig as Ve, AlovaError as $e, getOptions as Ys, JSONParse as Js, promiseReject as as, buildCompletedURL as Xs, isSpecialRequestBody as Zs, JSONStringify as tr } from "../../../@alova/shared/dist/alova-shared.esm.js";
+import { Method as me, queryCache as cn, promiseStatesHook as Rt, globalConfigMap as cs, setCache as we, invalidateCache as er, hitCacheBySource as nr } from "../alova.esm.js";
+const Oe = {
   authRole: null
-}, M = {
+}, de = {
   authRole: "login"
-}, p = {
+}, is = {
   authRole: "logout"
-}, G = {
+}, be = {
   authRole: "refreshToken"
-}, C = ({ meta: n }, s) => {
-  if (O(n)) {
-    for (const l in n)
-      if (Object.prototype.hasOwnProperty.call(n, l)) {
-        const e = s[l];
-        if (A(e, RegExp) ? e.test(n[l]) : n[l] === e)
-          return d;
-      }
-  }
-  return v;
-}, Q = (n, s) => L(V, (l) => {
-  h(s, {
-    method: n,
-    resolve: l
-  });
-}), N = (n, s, l, e) => {
-  if (C(n, s?.metaMatches || l))
-    return (u(s) ? s : O(s) && u(s.handler) ? s.handler : x)(e, n);
-}, W = async (n, s, l, e, t, a) => {
-  const o = w(e) >= 2;
-  let E = t?.isExpired(...e);
-  if (A(E, V) && (E = await E), E)
+}, gt = ({ meta: e }, t) => {
+  if (oe(e)) {
+    for (const n in e)
+      if (Object.prototype.hasOwnProperty.call(e, n)) {
+        const r = t[n];
+        if (k(r, RegExp) ? r.test(e[n]) : e[n] === r)
+          return D;
+      }
+  }
+  return w;
+}, mn = (e, t) => F(Ut, (n) => {
+  at(t, {
+    method: e,
+    resolve: n
+  });
+}), je = (e, t, n, r) => {
+  if (gt(e, t?.metaMatches || n))
+    return (Y(t) ? t : oe(t) && Y(t.handler) ? t.handler : Z)(r, e);
+}, ln = async (e, t, n, r, s, o) => {
+  const c = N(r) >= 2;
+  let l = s?.isExpired(...r);
+  if (k(l, Ut) && (l = await l), l)
     try {
-      if (d && (l(d), await t?.handler(...e), l(v), P(s, ({ resolve: i }) => i())), o) {
-        const { config: i } = n, c = i.transform;
-        i.transform = R;
-        const r = await n;
-        return i.transform = c, r;
+      let v = D;
+      if (c && o && (v = w, await mn(e, t)), v && (n(D), await s?.handler(...r), n(w), X(t, ({ resolve: d }) => d())), c) {
+        const { config: d } = e, a = d.transform;
+        d.transform = p;
+        const i = await e;
+        return d.transform = a, i;
       }
     } finally {
-      l(v), b(s, 0, w(s));
+      n(w), xt(t, 0, N(t));
     }
-}, $ = (n) => {
-  let s = R, l = R, e = R;
-  if (u(n))
-    s = n;
-  else if (O(n)) {
-    const { onSuccess: t, onError: a, onComplete: o } = n;
-    s = u(t) ? t : s, l = u(a) ? a : l, e = u(o) ? o : e;
+}, ls = (e) => {
+  let t = p, n = p, r = p;
+  if (Y(e))
+    t = e;
+  else if (oe(e)) {
+    const { onSuccess: s, onError: o, onComplete: c } = e;
+    t = Y(s) ? s : t, n = Y(o) ? o : n, r = Y(c) ? c : r;
   }
   return {
-    onSuccess: s,
-    onError: l,
-    onComplete: e
+    onSuccess: t,
+    onError: n,
+    onComplete: r
   };
-}, I = ({ visitorMeta: n, login: s, logout: l, refreshToken: e, assignToken: t = x }) => {
-  let a = v;
-  const o = [];
+}, Wr = ({ visitorMeta: e, login: t, logout: n, refreshToken: r, assignToken: s = Z }) => {
+  let o = w;
+  const c = [];
   return {
-    waitingList: o,
-    onAuthRequired: (i) => async (c) => {
-      const r = C(c, n || j), f = C(c, s?.metaMatches || M);
-      return !r && !f && !C(c, e?.metaMatches || G) && (a && await Q(c, o), await W(c, o, (D) => {
-        a = D;
-      }, [c], e)), !r && !f && await t(c), i?.(c);
-    },
-    onResponseRefreshToken: (i) => {
-      const c = $(i);
+    waitingList: c,
+    onAuthRequired: (d) => async (a) => {
+      const i = gt(a, e || Oe), f = gt(a, t?.metaMatches || de);
+      return !i && !f && !gt(a, r?.metaMatches || be) && (o && await mn(a, c), await ln(a, c, (u) => {
+        o = u;
+      }, [a], r)), !i && !f && await s(a), d?.(a);
+    },
+    onResponseRefreshToken: (d) => {
+      const a = ls(d);
       return {
-        ...c,
-        onSuccess: async (r, f) => (await N(f, s, M, r), await N(f, l, p, r), (c.onSuccess || F)(r, f))
+        ...a,
+        onSuccess: async (i, f) => (await je(f, t, de, i), await je(f, n, is, i), (a.onSuccess || se)(i, f))
+      };
+    }
+  };
+}, kr = ({ visitorMeta: e, login: t, logout: n, refreshTokenOnSuccess: r, refreshTokenOnError: s, assignToken: o = Z }) => {
+  let c = w;
+  const l = [];
+  return {
+    waitingList: l,
+    onAuthRequired: (a) => async (i) => {
+      const f = gt(i, e || Oe), u = gt(i, t?.metaMatches || de);
+      return !f && !u && !gt(i, r?.metaMatches || be) && !gt(i, s?.metaMatches || be) && c && await mn(i, l), !f && !u && await o(i), a?.(i);
+    },
+    onResponseRefreshToken: (a) => {
+      const i = ls(a);
+      return {
+        ...i,
+        onSuccess: async (f, u) => {
+          if (!gt(u, e || Oe) && !gt(u, t?.metaMatches || de) && !gt(u, r?.metaMatches || be)) {
+            const O = await ln(u, l, (I) => {
+              c = I;
+            }, [f, u], r, c);
+            if (O)
+              return O;
+          }
+          return await je(u, t, de, f), await je(u, n, is, f), (i.onSuccess || se)(f, u);
+        },
+        onError: async (f, u) => {
+          if (!gt(u, e || Oe) && !gt(u, t?.metaMatches || de) && !gt(u, s?.metaMatches || be)) {
+            const O = await ln(u, l, (I) => {
+              c = I;
+            }, [f, u], s, c);
+            if (O)
+              return O;
+          }
+          return (i.onError || Z)(f, u);
+        }
+      };
+    }
+  };
+}, Nn = (e) => {
+  throw e;
+};
+function sr(e = Z) {
+  let t = [];
+  return [(o) => (t.includes(o) || (t.push(o), e(t)), () => {
+    t = Dt(t, (c) => c !== o), e(t);
+  }), (...o) => {
+    if (t.length > 0)
+      return X(t, (c) => c(...o));
+  }, () => {
+    t = [], e(t);
+  }];
+}
+const rr = (e, t) => {
+  let n = Wt;
+  return function(...s) {
+    const o = e.bind(this, ...s), c = At(t) ? t : t(...s);
+    n && Bs(n), c > 0 ? n = jt(o, c) : o();
+  };
+}, qn = (e, t = []) => {
+  const n = Y(e) ? e(...t) : e;
+  return _t("scene")(k(n, me), "hook handler must be a method instance or a function that returns method instance"), n;
+}, or = (e, t) => {
+  const n = {};
+  for (const r in e)
+    n[r] = t(e[r], r, e);
+  return n;
+};
+var It;
+(function(e) {
+  e[e.USE_REQUEST = 1] = "USE_REQUEST", e[e.USE_WATCHER = 2] = "USE_WATCHER", e[e.USE_FETCHER = 3] = "USE_FETCHER";
+})(It || (It = {}));
+function Ft(e, t = {
+  trackedKeys: {},
+  bindError: w,
+  initialRequest: w,
+  ...Ks()
+}) {
+  const n = (a) => e.ref ? e.ref(a) : { current: a };
+  t = n(t).current;
+  const r = (a) => (e.export || se)(a, t), s = (a) => {
+    if (!Y(e.memorize))
+      return a;
+    const i = e.memorize(a);
+    return i.memorized = D, i;
+  }, { dehydrate: o } = e, c = (a, i, f) => a !== o(i, f, t) && t.trackedKeys[f] && e.update(a, i, f, t), l = (a) => vt(a, (i) => k(i, Le) ? i.e : i), v = [], d = {};
+  return {
+    create: (a, i) => (at(v, i), F(Bn, e.create(a, i, t), i, (f) => o(f, i, t), r, (f, u) => c(u, f, i))),
+    computed: (a, i, f) => (X(i, (u) => {
+      u.k && (d[u.k] = D);
+    }), F(Le, e.computed(a, l(i), f, t), f, (u) => o(u, f, t), r)),
+    effectRequest: (a) => e.effectRequest(a, t),
+    ref: n,
+    watch: (a, i) => e.watch(l(a), i, t),
+    onMounted: (a) => e.onMounted(a, t),
+    onUnmounted: (a) => e.onUnmounted(a, t),
+    memorize: s,
+    /**
+     * refering object that sharing some value with this object.
+     */
+    __referingObj: t,
+    /**
+     * expose provider for specified use hook.
+     * @param object object that contains state proxy, framework state, operating function and event binder.
+     * @returns provider component.
+     */
+    exposeProvider: (a) => {
+      const i = {}, f = {}, u = [];
+      for (const b in a) {
+        const _ = a[b];
+        if (Y(_) && !t.trackedKeys[b])
+          i[b] = b.startsWith("on") ? (...q) => (_(...q), Q) : _.memorized ? _ : s(_);
+        else {
+          !Tt(["uploading", "downloading"], b) && !b.startsWith("__") && at(u, b);
+          const q = k(_, Le);
+          q && (f[b] = _.s), Me.defineProperty(i, b, {
+            get: () => (t.trackedKeys[b] = D, q ? _.e : _),
+            // set need to set an function,
+            // otherwise it will throw `TypeError: Cannot set property __referingObj of #<Object> which has only a getter` when setting value
+            set: Z,
+            enumerable: D,
+            configurable: D
+          });
+        }
+      }
+      const { update: O, __proxyState: I } = i;
+      t.trackedKeys = {
+        ...d
+      }, t.bindError = w;
+      const { then: g } = i, H = {
+        // expose referingObject automatically.
+        __referingObj: t,
+        // the new updating function that can update the new states and nested hook states.
+        update: s((b) => {
+          yt(b).forEach((_) => {
+            Tt(v, _) ? c(b[_], f[_], _) : _ in i && Y(O) && O({
+              [_]: b[_]
+            });
+          });
+        }),
+        __proxyState: s((b) => Tt(v, b) && k(a[b], Le) ? (t.trackedKeys[b] = D, a[b]) : I(b)),
+        /**
+         * send and wait for responding with `await`
+         * this is always used in `nuxt3` and suspense in vue3
+         * @example
+         * ```js
+         * const { loading, data, error } = await useRequest(...);
+         * ```
+         */
+        then(b, _) {
+          X(u, (q) => {
+            t.trackedKeys[q] = D;
+          });
+          const V = () => {
+            pn(Q, "then"), b(Q);
+          };
+          Y(g) ? g(V, _) : V();
+        }
+      }, Q = Ge(i, H);
+      return Q;
+    },
+    /**
+     * transform state proxies to object.
+     * @param states proxy array of framework states
+     * @param filterKey filter key of state proxy
+     * @returns an object that contains the states of target form
+     */
+    objectify: (a, i) => a.reduce((f, u) => (f[u.k] = i ? u[i] : u, f), {}),
+    transformState2Proxy: (a, i) => F(Bn, a, i, (f) => o(f, i, t), r, (f, u) => c(u, f, i))
+  };
+}
+const ar = _t(""), cr = _t("useRequest"), ds = _t("useWatcher"), us = _t("useFetcher"), fs = (e) => ({
+  [It.USE_REQUEST]: cr,
+  [It.USE_WATCHER]: ds,
+  [It.USE_FETCHER]: us
+})[e], vs = (e, t) => e(k(t, me), "expected a method instance."), te = "success", ee = "error", Gt = "complete";
+var ir = (e, t, n, r) => ({
+  /** The method instance of the last request */
+  m: p,
+  /** sent method keys */
+  rf: {},
+  /** frontStates */
+  fs: {},
+  /** eventManager */
+  em: n,
+  /** hookType, useRequest=1, useWatcher=2, useFetcher=3 */
+  ht: e,
+  /** hook config */
+  c: t,
+  /** referingObject */
+  ro: r,
+  /** merged states */
+  ms: {}
+});
+class wt {
+  constructor(t, n) {
+    this.method = t, this.args = n;
+  }
+  clone() {
+    return { ...this };
+  }
+  static spawn(t, n) {
+    return F(wt, t, n);
+  }
+}
+class hs extends wt {
+  constructor(t, n, r) {
+    super(t.method, t.args), this.data = n, this.fromCache = r;
+  }
+}
+class En extends wt {
+  constructor(t, n) {
+    super(t.method, t.args), this.error = n;
+  }
+}
+class dn extends wt {
+  constructor(t, n, r, s, o) {
+    super(t.method, t.args), this.status = n, this.data = r, this.fromCache = n === "error" ? !1 : s, this.error = o;
+  }
+}
+class ps {
+  constructor(t, n, r) {
+    this.behavior = t, this.method = n, this.silentMethod = r;
+  }
+}
+class We extends ps {
+  constructor(t, n, r, s, o) {
+    super(t, n, r), this.queueName = s, this.retryTimes = o;
+  }
+}
+class lr extends We {
+  constructor(t, n, r, s, o, c, l) {
+    super(t, n, r, s, o), this.data = c, this.vDataResponse = l;
+  }
+}
+class dr extends We {
+  constructor(t, n, r, s, o, c, l) {
+    super(t, n, r, s, o), this.error = c, this.retryDelay = l;
+  }
+}
+class ur extends We {
+  constructor(t, n, r, s, o, c) {
+    super(t, n, r, s, o), this.error = c;
+  }
+}
+class xe extends ps {
+  constructor(t, n, r, s) {
+    super(t, n, r), this.args = s;
+  }
+}
+class fr extends xe {
+  constructor(t, n, r, s, o) {
+    super(t, n, r, s), this.data = o;
+  }
+}
+class ms extends xe {
+  constructor(t, n, r, s, o) {
+    super(t, n, r, s), this.error = o;
+  }
+}
+class vr extends xe {
+  constructor(t, n, r, s, o, c) {
+    super(t, n, r, s), this.retryTimes = o, this.retryDelay = c;
+  }
+}
+class hr extends xe {
+  constructor(t, n, r, s, o, c, l) {
+    super(t, n, r, s), this.status = o, this.data = c, this.error = l;
+  }
+}
+class pr extends wt {
+  constructor(t, n, r) {
+    super(t.method, t.args), this.retryTimes = n, this.retryDelay = r;
+  }
+}
+class mr extends En {
+  constructor(t, n, r) {
+    super(t, n), this.retryTimes = r;
+  }
+}
+const Er = (e, t) => t(), Be = {}, Es = (e, t) => {
+  const n = Be[e] || {};
+  return n[t] ? Array.from(n[t]) : [];
+}, Sr = (e, t, n) => {
+  const r = Be[e] = Be[e] || {};
+  r[t] || (r[t] = F(Set)), r[t].add(n);
+}, gr = (e, t, n) => {
+  const r = Be[e], s = r[t];
+  r && s && (n ? s.delete(n) : s.clear(), s.size === 0 && pn(r, t));
+};
+function un(e, t, n = []) {
+  const r = fs(e.ht);
+  let s = es(t, r, n);
+  const { fs: o, ht: c, c: l } = e, { loading: v, data: d, error: a } = o, i = c === It.USE_FETCHER, { force: f = w, middleware: u = Er } = l, O = He(s), { id: I } = O, g = Kt(s), { abortLast: H = D } = l, Q = !e.m;
+  return e.m = s, (async () => {
+    let b = Z, _ = w, V = Ot(p), q = Z, K = Z;
+    const j = await cn(s);
+    let R = () => !!j, x = w;
+    i || (Sr(I, g, e), b = () => gr(I, g, e));
+    const T = (M) => {
+      _ = D;
+      const { force: y = f, method: C = s } = M || {}, z = re(y, [
+        F(wt, s, n)
+      ]), $ = (Et) => ({ loaded: ct, total: Ct }) => {
+        o[Et].v = {
+          loaded: ct,
+          total: Ct
+        };
       };
+      s = C, e.rf[g] = b, x || (v.v = !!z || !j);
+      const { downloading: ot, uploading: ht } = e.ro.trackedKeys;
+      return q = ot ? s.onDownload($("downloading")) : q, K = ht ? s.onUpload($("uploading")) : K, V = s.send(z), R = () => s.fromCache || w, V;
+    }, J = {
+      method: s,
+      cachedResponse: j,
+      config: l,
+      abort: () => s.abort()
+    }, et = () => c !== It.USE_WATCHER || !H || e.m === s, h = (M = D) => {
+      M && Q && (v.v = w), x = M;
+    }, m = u(i ? {
+      ...J,
+      args: n,
+      fetch: (M, ...y) => (vs(r, M), un(e, M, y)),
+      proxyStates: Ns(o, "data"),
+      controlLoading: h
+    } : {
+      ...J,
+      args: n,
+      send: (...M) => un(e, t, M),
+      proxyStates: o,
+      controlLoading: h
+    }, T);
+    let A = p;
+    const P = wt.spawn(s, n);
+    try {
+      const M = await m, y = (C) => (i ? e.c.updateState !== w && X(Es(I, g), (z) => {
+        z.fs.data.v = C;
+      }) : et() && (d.v = C), et() && (a.v = p, !x && (v.v = w), e.em.emit(te, F(hs, P, C, R())), e.em.emit(Gt, F(dn, P, te, C, R(), p))), C);
+      A = // When no data is returned or undefined is returned in the middleware, get the real response data
+      // Otherwise, use the returned data and no longer wait for the response promise. At this time, you also need to call the response callback.
+      M !== p ? y(M) : _ ? (
+        // There are two possibilities when middlewareCompletePromise is resolve
+        // 1. The request is normal
+        // 2. The request is incorrect, but the error is captured by the middleware function. At this time, the success callback will also be called, that is, afterSuccess(undefinedValue)
+        await mt(V, y, () => y(p))
+      ) : (
+        // If is next called is not called, no data is returned
+        p
+      ), !_ && !x && (v.v = w);
+    } catch (M) {
+      throw et() && (a.v = M, !x && (v.v = w), e.em.emit(ee, F(En, P, M)), e.em.emit(Gt, F(dn, P, ee, p, R(), M))), M;
+    }
+    return q(), K(), A;
+  })();
+}
+const ie = (e) => e.current;
+function Sn(e, t, n, r, s = w, o, c = 0) {
+  var l;
+  n = { ...n };
+  let v = !!s, d = p;
+  if (s)
+    try {
+      const C = es(t, fs(e)), z = He(C), $ = z.l1Cache.get(qs(z.id, Kt(C)));
+      if ($ && !k($, Ut)) {
+        const [ht, Et] = $;
+        (!Et || Et > ns()) && (d = ht);
+      }
+      v = !!re((l = n.force) !== null && l !== void 0 ? l : w) || !d;
+    } catch {
     }
+  const { create: a, effectRequest: i, ref: f, objectify: u, exposeProvider: O, transformState2Proxy: I, __referingObj: g } = Ft(Rt(), n.__referingObj), H = {
+    total: 0,
+    loaded: 0
+  }, { managedStates: Q = {} } = n, b = or(Q, (C, z) => I(C, z)), _ = a(d ?? (Y(r) ? r() : r), "data"), V = a(v, "loading"), q = a(p, "error"), K = a({ ...H }, "downloading"), j = a({ ...H }, "uploading"), R = u([_, V, q, K, j]), x = qt(), T = ie(f(ir(e, n, x, g)));
+  T.fs = R, T.em = x, T.c = n, T.ms = { ...R, ...b };
+  const J = o !== p, et = (C = t, z) => un(T, C, z), h = f(p), m = f(w), A = ie(f(zs())), P = (C = g, z) => {
+    A(() => {
+      (!cs.ssr || ie(h)) && (g.initialRequest = m.current = D, mt(et(z), () => {
+        var $;
+        ($ = ie(h)) === null || $ === void 0 || $.resolve();
+      }, ($) => {
+        var ot;
+        if (!C.bindError && !C.trackedKeys.error && !ie(h))
+          throw $;
+        (ot = ie(h)) === null || ot === void 0 || ot.reject($);
+      }));
+    });
+  }, M = f(rr((C, z, $) => P(z, $), (C) => At(C) ? lt(c) ? c[C] : c : 0));
+  i({
+    handler: (
+      // When `watchingStates` is an array, it indicates the watching states (including an empty array). When it is undefined, it indicates the non-watching state.
+      J ? (C) => M.current(C, g, t) : () => P(g)
+    ),
+    removeStates: () => {
+      X(Ie(T.rf), (C) => C());
+    },
+    frontStates: { ...R, ...b },
+    watchingStates: o,
+    immediate: s ?? D
+  });
+  const y = O({
+    ...u([_, V, q, K, j]),
+    abort: () => T.m && T.m.abort(),
+    /**
+     * Manually initiate a request by executing this method
+     * @param sendCallingArgs Parameters passed in when calling the send function
+     * @param methodInstance method object
+     * @param isFetcher Whether to call isFetcher
+     * @returns Request promise
+     */
+    send: (C, z) => et(z, C),
+    onSuccess(C) {
+      x.on(te, C);
+    },
+    onError(C) {
+      g.bindError = D, x.on(ee, C);
+    },
+    onComplete(C) {
+      x.on(Gt, C);
+    },
+    /**
+     * send and wait for responding with `await`
+     * this is always used in `nuxt3` and `<suspense>` in vue3
+     * @example
+     * ```js
+     * const { loading, data, error } = await useRequest(...);
+     * ```
+     */
+    then(C, z) {
+      const { promise: $, resolve: ot, reject: ht } = Ce();
+      h.current = {
+        resolve: ot,
+        reject: ht
+      }, jt(() => {
+        !m.current && ot();
+      }, 10), mt($, () => {
+        C(y);
+      }, z);
+    }
+  });
+  return y;
+}
+function br(e = {}) {
+  const t = Sn(It.USE_FETCHER, Z, e), { send: n } = t;
+  return pn(t, "send"), Ge(t, {
+    /**
+     * Fetch data fetch will definitely send a request, and if the currently requested data has a corresponding management state, this state will be updated.
+     * @param matcher Method object
+     */
+    fetch: (r, ...s) => (vs(us, r), n(s, r))
+  });
+}
+function Ee(e, t = {}) {
+  const { immediate: n = D, initialData: r } = t, s = Sn(It.USE_REQUEST, e, t, r, !!n), { send: o } = s;
+  return Ge(s, {
+    send: (...c) => o(c)
+  });
+}
+function Ss(e, t, n = {}) {
+  ds(t && N(t) > 0, "expected at least one watching state");
+  const { immediate: r, debounce: s = 0, initialData: o } = n, c = Sn(
+    It.USE_WATCHER,
+    e,
+    n,
+    o,
+    !!r,
+    // !!immediate means not send request immediately
+    t,
+    s
+  ), { send: l } = c;
+  return Ge(c, {
+    send: (...v) => l(v)
+  });
+}
+var yr = (e) => {
+  let t = {};
+  return {
+    snapshots: () => t,
+    save(n, r = w) {
+      const s = Kt(n);
+      (!t[s] || r) && (t[s] = {
+        entity: n
+      });
+    },
+    get: (n) => t[Kt(k(n, me) ? n : e(n))],
+    remove(n) {
+      n ? delete t[n] : t = {};
+    }
+  };
+};
+const Xt = _t("usePagination"), zn = (e, t) => Xt(At(e) && e < N(t), "index must be a number that less than list length"), Gn = (e) => [
+  e[e.length - 2],
+  // refreshPage
+  e[e.length - 1],
+  // isRefresh
+  e.slice(0, e.length - 2)
+  // send args
+];
+var Yr = (e, t = {}) => {
+  const { create: n, computed: r, ref: s, watch: o, exposeProvider: c, objectify: l, __referingObj: v } = Ft(Rt()), { preloadPreviousPage: d = D, preloadNextPage: a = D, total: i = (E) => E.total, data: f = (E) => E.data, append: u = w, initialPage: O = 1, initialPageSize: I = 10, watchingStates: g = [], initialData: H, immediate: Q = D, middleware: b, force: _ = Z, actions: V = {}, ...q } = t, K = s(e), j = s(w), R = n(O, "page"), x = n(I, "pageSize"), T = n(H ? f(H) || [] : [], "data"), J = n(H ? i(H) : p, "total"), { snapshots: et, get: h, save: m, remove: A } = s(yr((E) => K.current(E, x.v))).current, P = (E) => f(E) || E, M = br({
+    __referingObj: v,
+    updateState: w,
+    force: ({ args: E }) => E[N(E) - 1]
+  }), { loading: y, fetch: C, abort: z, onSuccess: $ } = M, ot = s(y), ht = (E = R.v, S = []) => {
+    const U = e(E, x.v, ...S);
+    return m(U), U;
+  };
+  o(g, () => {
+    R.v = O, j.current = D;
+  });
+  const Et = s({}), ct = n("", "status"), Ct = n([], "removing"), L = n(p, "replacing"), B = r(() => {
+    const E = J.v;
+    return E !== p ? Math.ceil(E / x.v) : p;
+  }, [x, J], "pageCount"), W = (E) => (...S) => Et.current[E](...S), nt = Ss((...E) => {
+    const [S, , U] = Gn(E);
+    return ht(S, U);
+  }, [...g, R.e, x.e], {
+    __referingObj: v,
+    immediate: Q,
+    initialData: H,
+    managedStates: l([T, R, x, J], "s"),
+    middleware(E, S) {
+      return b ? b({
+        ...E,
+        delegatingActions: {
+          refresh: W("refresh"),
+          insert: W("insert"),
+          remove: W("remove"),
+          replace: W("replace"),
+          reload: W("reload"),
+          getState: (U) => ({
+            page: R,
+            pageSize: x,
+            data: T,
+            pageCount: B,
+            total: J,
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            isLastPage: Fe
+          })[U].v
+        }
+      }, S) : S();
+    },
+    force: (E) => E.args[1] || (Y(_) ? _(E) : _),
+    ...q
+  }), { send: ut } = nt, Lt = nt.__proxyState("data"), zt = async (E) => {
+    const { rawData: S = Lt.v, preloadPage: U, fetchMethod: G, forceRequest: tt = w, isNextPage: st = w } = E, it = B.v, ft = it ? U > it : st ? N(P(S)) < x.v : w;
+    if (!(U > 0 && !ft))
+      return w;
+    const { e: rt } = Gs(G), Mt = await cn(G);
+    return rt(Hs) <= ns() ? w : tt || !Mt;
+  }, Pt = async (E, S, U = []) => {
+    const G = R.v + 1, tt = ht(G, U);
+    a && await zt({
+      rawData: E,
+      preloadPage: G,
+      fetchMethod: tt,
+      isNextPage: D,
+      forceRequest: S
+    }) && ye(C(tt, ...U, S), Z);
+  }, Bt = async (E, S = []) => {
+    const U = R.v - 1, G = ht(U, S);
+    d && await zt({
+      rawData: E,
+      preloadPage: U,
+      fetchMethod: G
+    }) && ye(C(G, ...S, p), Z);
+  }, pt = () => {
+    const E = Lt.v;
+    if (!E)
+      return D;
+    const S = P(E), U = R.v, G = B.v, tt = lt(S) ? N(S) : 0;
+    return G ? U >= G : tt < x.v;
+  }, Fe = n(pt(), "isLastPage");
+  o([R, B, Lt, x], async () => {
+    jt(() => {
+      Fe.v = pt();
+    });
+  });
+  const Yt = async () => {
+    const E = h(R.v);
+    E && await we(E.entity, (S) => {
+      if (S) {
+        const U = P(S) || [];
+        return xt(U, 0, N(U), ...T.v), S;
+      }
+    });
+  };
+  $(({ method: E, data: S }) => {
+    const U = h(R.v);
+    if (U && Kt(U.entity) === Kt(E)) {
+      const G = P(S);
+      if (u) {
+        const tt = T.v, st = x.v, it = N(tt) % st;
+        if (it > 0) {
+          const ft = [...T.v];
+          xt(ft, (R.v - 1) * st, it, ...G), T.v = ft;
+        }
+      } else
+        T.v = G;
+    }
+  });
+  const Se = s(p), ae = s(p);
+  nt.onSuccess(({ data: E, args: S, method: U }) => {
+    const [G, tt, st] = Gn(S), { total: it } = h(U) || {}, ft = E;
+    J.v = it !== p ? it : i(ft), tt || (Bt(ft, st), Pt(ft, w, st));
+    const Jt = x.v, rt = P(ft);
+    if (Xt(lt(rt), "Got wrong array, did you return the correct array of list in `data` function"), u) {
+      if (j.current && (T.v = []), G === p)
+        T.v = [...T.v, ...rt];
+      else if (G) {
+        const Mt = [...T.v];
+        xt(Mt, (G - 1) * Jt, Jt, ...rt), T.v = Mt;
+      }
+    } else
+      T.v = rt;
+  }).onSuccess(({ data: E }) => {
+    var S;
+    (S = Se.current) === null || S === void 0 || S.call(Se, E);
+  }).onError(({ error: E }) => {
+    var S;
+    (S = ae.current) === null || S === void 0 || S.call(ae, E);
+  }).onComplete(() => {
+    j.current = w;
+  });
+  const ce = (E) => {
+    const S = T.v.indexOf(E);
+    return Xt(S >= 0, "item is not found in list"), S;
+  }, { addQueue: Je, onComplete: Ln } = s($s()).current, Xe = async (E = R.v) => {
+    let S = E, U = Ot();
+    if (u) {
+      if (!At(E)) {
+        const G = ce(E);
+        S = Math.floor(G / x.v) + 1;
+      }
+      Xt(S <= R.v, "refresh page can't greater than page"), U = ut(S, D);
+    } else
+      Xt(At(S), "unable to calculate refresh page by item in pagination mode"), U = S === R.v ? ut(p, D) : C(e(S, x.v), D);
+    return U;
+  }, Tn = async (E = w) => {
+    const S = R.v, U = et();
+    let G = Ie(U);
+    if (E)
+      A();
+    else {
+      const tt = vt(Dt([h(S - 1), h(S), h(S + 1)], Boolean), ({ entity: st }) => Kt(st));
+      G = vt(Dt(yt(U), (st) => !Tt(tt, st)), (st) => {
+        const it = U[st];
+        return delete U[st], it;
+      });
+    }
+    await er(vt(G, ({ entity: tt }) => tt));
+  }, On = async () => {
+    ot.current && z(), await Tn();
+    const E = h(R.v + 1);
+    if (E) {
+      const S = P(await cn(E.entity) || {}) || [];
+      Pt(p, N(S) < x.v);
+    }
+  }, Un = (E) => {
+    if (E === 0)
+      return;
+    const S = J.v;
+    if (At(S)) {
+      const U = Math.max(S + E, 0);
+      J.v = U;
+      const G = R.v;
+      X([h(G - 1), h(G), h(G + 1)], (tt) => {
+        tt && (tt.total = U);
+      });
+    }
+  }, Qn = (E, S = 0) => (Ln(On), Je(async () => {
+    const U = At(S) ? S : ce(S) + 1;
+    Xt(U >= 0, "illegal insert position"), Y(V.insert) && (ct.v = "inserting", await ue(V.insert(E, S), () => {
+      ct.v = "";
+    }));
+    let G = p;
+    const tt = [...T.v];
+    if (N(tt) % x.v === 0 && (G = tt.pop()), xt(tt, U, 0, E), T.v = tt, Un(1), await Yt(), G) {
+      const st = h(R.v + 1);
+      st && await we(st.entity, (it) => {
+        if (it) {
+          const ft = P(it) || [];
+          return ft.unshift(G), ft.pop(), it;
+        }
+      });
+    }
+  })), In = (...E) => (Ln(On), Je(async () => {
+    const S = vt(E, (rt) => {
+      const Mt = At(rt) ? rt : ce(rt);
+      return zn(Mt, T.v), Mt;
+    });
+    if (Y(V.remove)) {
+      ct.v = "removing", Ct.v = [...S];
+      const rt = Ws(vt(E, (Mt) => V.remove(Mt)));
+      await ue(rt, () => {
+        ct.v = "", Ct.v = [];
+      });
+    }
+    const U = R.v, G = U + 1, tt = h(G), st = [];
+    tt && await we(tt.entity, (rt) => {
+      if (rt) {
+        const Mt = P(rt);
+        return lt(Mt) && at(st, ...xt(Mt, 0, N(S))), rt;
+      }
+    });
+    const it = pt(), ft = N(st);
+    let Jt = !1;
+    if (ft > 0 || it) {
+      const rt = Dt(T.v, (Mt, js) => !Tt(S, js));
+      Jt = !u && it && N(rt) <= 0, !Jt && ft > 0 && at(rt, ...st), T.v = rt;
+    } else ft <= 0 && !it && Xe(U);
+    return Un(-N(S)), Yt().then(() => {
+      Jt && (R.v = U - 1);
+    });
+  })), Vn = (E, S) => Je(async () => {
+    Xt(S !== p, "expect specify the replace position");
+    const U = At(S) ? S : ce(S);
+    zn(U, T.v), Y(V.replace) && (ct.v = "replacing", L.v = U, await ue(V.replace(E, S), () => {
+      ct.v = "", L.v = p;
+    }));
+    const G = [...T.v];
+    xt(G, U, 1, E), T.v = G, await Yt();
+  }), jn = async () => {
+    await Tn(D), j.current = D, R.v === O ? ye(ut(), Z) : R.v = O;
+    const { resolve: E, reject: S, promise: U } = Ce();
+    return Se.current = E, ae.current = S, U;
+  };
+  return Et.current = {
+    refresh: Xe,
+    insert: Qn,
+    remove: In,
+    replace: Vn,
+    reload: jn
+  }, c({
+    ...nt,
+    ...l([T, R, B, x, J, Fe, ct, Ct, L]),
+    send: (...E) => ut(...E, p, p),
+    fetching: M.loading,
+    onFetchSuccess: M.onSuccess,
+    onFetchError: M.onError,
+    onFetchComplete: M.onComplete,
+    refresh: Xe,
+    insert: Qn,
+    remove: In,
+    replace: Vn,
+    reload: jn
+  });
+};
+const gs = (e, t) => _t(e)(lt(t) && N(t) > 0, "please use an array to represent serial requests"), bs = (e, t, n = []) => (e.shift(), ((r, s) => {
+  t?.(r, () => Ot(p)), r.controlLoading();
+  const o = r.proxyStates.loading;
+  o.v = D;
+  let c = s();
+  for (const l of e)
+    c = mt(c, (v) => {
+      const d = l(v, ...r.args);
+      return at(n, d), d.send();
+    });
+  return c.finally(() => {
+    o.v = w;
+  });
+}));
+var Jr = (e, t = {}) => {
+  gs("useSerialRequest", e);
+  const { ref: n, __referingObj: r } = Ft(Rt()), s = n([]).current, o = Ee(e[0], {
+    ...t,
+    __referingObj: r,
+    middleware: bs(e, t.middleware, s)
+  });
+  return o.onError = Re(o.onError, (c, l) => {
+    l.method = s[N(s) - 1], c(l);
+  }), o;
+}, Xr = (e, t, n = {}) => {
+  gs("useSerialWatcher", e);
+  const { ref: r, __referingObj: s } = Ft(Rt()), o = r([]).current, c = Ss(e[0], t, {
+    ...n,
+    __referingObj: s,
+    middleware: bs(e, n.middleware, o)
+  });
+  return c.onError = Re(c.onError, (l, v) => {
+    v.method = o[N(o) - 1], l(v);
+  }), c;
+};
+const gn = "valueOf", pe = "default", fn = "silent", Rr = "queue", wr = "static";
+let ne;
+const Hn = (e) => {
+  ne = e;
+};
+let Ke;
+const _r = (e) => {
+  Ke = e;
+};
+let bn = {};
+const Cr = (e = {}) => {
+  bn = e;
+};
+let ke = 0;
+const ys = (e) => {
+  ke = e;
+};
+let Rs = [];
+const Pr = (e = 0) => {
+  Rs = lt(e) ? e : [
+    {
+      queue: pe,
+      wait: e
+    }
+  ];
+}, ws = Symbol("GlobalSQBoot"), _s = Symbol("GlobalSQBefore"), Cs = Symbol("GlobalSQSuccess"), Ps = Symbol("GlobalSQError"), Ms = Symbol("GlobalSQFail"), Qt = qt(), yn = _t("useSQRequest");
+async function Ue(e, t) {
+  let n = w;
+  if (e) {
+    const { update: r } = Rt(), s = Kt(e), { id: o } = He(e), c = Es(o, s), l = Y(t) ? { data: t } : t, v = vt(c, async (d) => {
+      let a = p;
+      if (d) {
+        const { ms: i, ro: f } = d;
+        X(yt(l), (u) => {
+          ar(u in i, `state named \`${u}\` is not found`);
+          const O = i[u];
+          let I = l[u](O.v);
+          I = lt(I) ? [...I] : bt(I) ? { ...I } : I, u === "data" && (a = I), r(I, i[u].s, u, f);
+        });
+      }
+      a !== p && await we(e, a);
+    });
+    N(v) > 0 && (await Ut.all(v), n = D);
+  }
+  return n;
+}
+var Mr = {
+  forward: (e) => k(e, Date) ? e.getTime() : p,
+  backward: (e) => F(Date, e)
+}, xr = {
+  forward: (e) => k(e, RegExp) ? e.source : void 0,
+  backward: (e) => F(RegExp, e)
+};
+const Rn = (e = {}) => {
+  const t = {
+    date: Mr,
+    regexp: xr,
+    ...e
+  };
+  return {
+    serialize: (s) => {
+      if (bt(s)) {
+        const { data: o } = Nt({ data: s }, (c) => {
+          let l = p;
+          const v = yt(t).reduce((a, i) => {
+            if (!l) {
+              const f = t[i].forward(a);
+              f !== p && (l = i, a = f);
+            }
+            return a;
+          }, c);
+          return Me.prototype.toString.call(c) === "[object Object]" ? c = { ...c } : lt(c) && (c = [...c]), l !== p ? [l, v] : c;
+        });
+        s = o;
+      }
+      return s;
+    },
+    deserialize: (s) => bt(s) ? Nt({ data: s }, (o) => {
+      if (lt(o) && N(o) === 2) {
+        const c = t[o[0]];
+        o = c ? c.backward(o[1]) : o;
+      }
+      return o;
+    }, w).data : s
+  };
+}, Ae = Symbol("vdid"), xs = Symbol("original"), wn = /\[vd:([0-9a-z]+)\]/, As = (e) => {
+  const t = e?.[Ae];
+  t && ne && (ne[t] = p);
+}, kt = (e, t = D) => {
+  As(e);
+  const n = e?.[Ae];
+  return (n ? `[vd:${n}]` : p) || (t ? e : p);
+};
+function _n() {
+  return kt(this);
+}
+const Cn = function() {
+};
+Cn.prototype = Me.create(Wt, {
+  [gn]: ss(_n)
+});
+const Pn = function() {
+};
+Pn.prototype = Me.create(Wt, {
+  [gn]: ss(_n)
+});
+var Ds = (e, t = an()) => {
+  const n = (s, o = an()) => {
+    if (s === Wt)
+      s = F(Cn);
+    else if (s === p)
+      s = F(Pn);
+    else {
+      const c = Me(s);
+      Ze(c, gn, _n), Ze(c, xs, s), s = c;
+    }
+    return Ze(s, Ae, o), s;
+  }, r = n(e, t);
+  return (oe(r) || lt(r)) && Nt(r, (s) => n(s)), r;
+};
+const Fs = (e, t = D) => {
+  const n = (s) => (As(s), s?.[Ae] && (k(s, Pn) ? s = p : k(s, Cn) ? s = Wt : (k(s, Number) || k(s, String) || k(s, Boolean)) && (s = s[xs])), s), r = n(e);
+  return t && (bt(r) || lt(r)) && Nt(r, (s) => n(s)), r;
+};
+var Zr = (e) => Fs(e);
+const _e = "__$k", Ne = "__$v", Mn = () => (yn(!!Ke, "alova instance is not found, Do you forget to set `alova` or call `bootSilentFactory`?"), Ke.l2Cache);
+let ve = p;
+const he = "alova.SQ", xn = "alova.SM.", An = async (e, t) => {
+  const n = Mn();
+  bt(t) && (t = Nt(lt(t) ? [...t] : { ...t }, (r, s, o) => {
+    var c;
+    if (s === Ne && o[_e])
+      return r;
+    if (s === "context" && ((c = r?.constructor) === null || c === void 0 ? void 0 : c.name) === "Alova")
+      return p;
+    const l = r?.[Ae];
+    let v = Fs(r, w);
+    if (ks(v) === "[object Object]" ? (r = { ...r }, v = {}) : lt(r) && (r = [...r], v = []), l) {
+      const a = {
+        [_e]: l,
+        // For objects and arrays, all their internal properties will be put to the outside through `...value`, so the internal ones do not need to be traversed and converted.
+        // Therefore, empty the array or object to avoid repeated conversions and contamination of the original object.
+        [Ne]: v,
+        ...r
+      };
+      if (k(r, String))
+        for (let i = 0; i < N(r); i += 1)
+          a == null || delete a[i];
+      r = a;
+    }
+    return r;
+  })), ve = ve || Rn(bn), await n.set(e, ve.serialize(t));
+}, qe = async (e) => {
+  const t = await Mn().get(e);
+  return ve = ve || Rn(bn), bt(t) ? Nt(ve.deserialize(t), (n) => {
+    if (bt(n) && n?.[_e]) {
+      const r = n[_e], s = Ds(n[Ne], r);
+      X(yt(n), (o) => {
+        Tt([_e, Ne], o) || (s[o] = n[o]);
+      }), n = s;
+    }
+    return n;
+  }, w) : t;
+}, $n = async (e) => {
+  await Mn().remove(e);
+}, Ye = (e) => An(xn + e.id, e), Ar = async (e, t) => {
+  await Ye(e);
+  const n = await qe(he) || {}, r = n[t] = n[t] || [];
+  at(r, e.id), await An(he, n);
+}, vn = async (e, t, n) => {
+  const r = await qe(he) || {}, s = r[e] || [], o = s.findIndex((c) => c === t);
+  o >= 0 && (n ? (xt(s, o, 1, n.id), await Ye(n)) : xt(s, o, 1), await $n(xn + t), N(s) <= 0 && delete r[e], N(yt(r)) > 0 ? await An(he, r) : await $n(he));
+};
+let Vt = {};
+const Dr = (e) => {
+  X(yt(e), (t) => {
+    const n = Vt[t] = Vt[t] || [];
+    at(n, ...e[t]);
+  });
+}, hn = (e, t) => {
+  const n = (r) => {
+    const s = kt(r);
+    return s in t ? t[s] : Pe(r) ? r.replace(F(rs, wn.source, "g"), (o) => o in t ? t[o] : o) : r;
+  };
+  return bt(e) && !kt(e, w) ? Nt(e, n) : e = n(e), e;
+}, Fr = (e, t) => Ut.all(vt(t, async (n) => {
+  hn(n.entity, e), n.cache && await Ye(n);
+})), Ls = (e, t) => {
+  let n = {};
+  const r = kt(e, w);
+  if (r && (n[r] = t), bt(e))
+    for (const s in e)
+      n = {
+        ...n,
+        ...Ls(e[s], t?.[s])
+      };
+  return n;
+}, tn = (e, t) => {
+  t ? e.active = t : delete e.active;
+}, Lr = 1e3, Ts = (e, t) => {
+  const n = (s) => {
+    const o = e[0];
+    if (o) {
+      const c = Rs.find(({ queue: d }) => k(d, rs) ? fe(d, s) : d === s), l = () => e[0] && r(e[0]), v = c?.wait ? re(c.wait, [o, s]) : 0;
+      v && v > 0 ? jt(l, v) : l();
+    }
+  }, r = (s, o = 0) => {
+    tn(s, D);
+    const { cache: c, id: l, behavior: v, entity: d, retryError: a = /.*/, maxRetryTimes: i = 0, backoff: f = { delay: Lr }, resolveHandler: u = Z, rejectHandler: O = Z, emitter: I, handlerArgs: g = [], virtualResponse: H, force: Q } = s;
+    Qt.emit(_s, F(We, v, d, s, t, o)), mt(d.send(Q), async (b) => {
+      if (Kn(e), c && await vn(t, l), u(b), v === fn) {
+        const _ = Ls(H, b), { targetRefMethod: V, updateStates: q } = s;
+        if (k(V, me) && q && N(q) > 0) {
+          const K = {};
+          X(q, (R) => {
+            K[R] = (x) => hn(x, _);
+          }), Ue(V, K) || await we(V, (R) => hn(R, _));
+        }
+        await Fr(_, e), Qt.emit(Cs, F(lr, v, d, s, t, o, b, _));
+      }
+      tn(s, w), n(t);
+    }, (b) => {
+      if (v !== fn)
+        Kn(e), O(b);
+      else {
+        const _ = (x) => Qt.emit(Ps, F(dr, v, d, s, t, o, b, x)), { name: V = "", message: q = "" } = b || {};
+        let K, j;
+        k(a, RegExp) ? j = a : bt(a) && (K = a.name, j = a.message);
+        const R = K && fe(K, V) || j && fe(j, q);
+        if (o < i && R) {
+          const x = os(f, o + 1);
+          _(x), jt(
+            () => {
+              o += 1, r(s, o), I.emit("retry", F(vr, v, d, s, g, o, x));
+            },
+            // When there are still retry times, use timeout as the next request time.
+            x
+          );
+        } else
+          ys(2), _(), I.emit("fallback", F(ms, v, d, s, g, b)), Qt.emit(Ms, F(ur, v, d, s, t, o, b));
+      }
+      tn(s, w);
+    });
+  };
+  n(t);
+}, Tr = async (e, t, n = pe, r = () => []) => {
+  e.cache = t;
+  const s = Vt[n] = Vt[n] || [], o = N(s) <= 0, l = !(await Promise.all(r())).some((v) => v === w);
+  return l && (t && await Ar(e, n), at(s, e), o && ke === 1 && Ts(s, n)), l;
+}, Wn = (e) => {
+  let t = p, n = "", r = 0;
+  for (const s in Vt)
+    if (r = Vt[s].indexOf(e), r >= 0) {
+      t = Vt[s], n = s;
+      break;
+    }
+  return [t, n, r];
+};
+class Os {
+  constructor(t, n, r, s = an(), o, c, l, v, d, a, i, f) {
+    const u = this;
+    u.entity = t, u.behavior = n, u.id = s, u.emitter = r, u.force = !!o, u.retryError = c, u.maxRetryTimes = l, u.backoff = v, u.resolveHandler = d, u.rejectHandler = a, u.handlerArgs = i, u.vDatas = f;
+  }
+  /**
+   * Allow cache-time persistent updates to the current instance
+   */
+  async save() {
+    this.cache && await Ye(this);
+  }
+  /**
+   * Replace the current instance with a new silentMethod instance in the queue
+   * If there is a persistent cache, the cache will also be updated.
+   * @param newSilentMethod new silentMethod instance
+   */
+  async replace(t) {
+    const n = this;
+    yn(t.cache === n.cache, "the cache of new silentMethod must equal with this silentMethod");
+    const [r, s, o] = Wn(n);
+    r && (xt(r, o, 1, t), n.cache && await vn(s, n.id, t));
+  }
+  /**
+   * Remove the current instance. If there is persistent data, it will also be removed synchronously.
+   */
+  async remove() {
+    const t = this, [n, r, s] = Wn(t);
+    n && (xt(n, s, 1), t.cache && await vn(r, t.id));
+  }
+  /**
+   * Set the method instance corresponding to the delayed update status and the corresponding status name
+   * It will find the corresponding status data and update vData to the actual data after responding to this silentMethod
+   *
+   * @param method method instance
+   * @param updateStateName Updated status name, the default is data, you can also set multiple
+   */
+  setUpdateState(t, n = "data") {
+    t && (this.targetRefMethod = t, this.updateStates = lt(n) ? n : [n]);
+  }
+}
+var Or = (e) => {
+  const { id: t, behavior: n, entity: r, retryError: s, maxRetryTimes: o, backoff: c, resolveHandler: l, rejectHandler: v, handlerArgs: d, targetRefMethod: a, force: i } = e, f = (O) => {
+    const { type: I, url: g, config: H, data: Q } = O;
+    return F(me, I, Ke, g, H, Q);
+  }, u = F(Os, f(r), n, qt(), t, i, s, o, c, l, v, d);
+  return u.cache = D, a && (u.targetRefMethod = f(a)), X(yt(e), (O) => {
+    Tt([
+      "id",
+      "behavior",
+      "emitter",
+      "entity",
+      "retryError",
+      "maxRetryTimes",
+      "backoff",
+      "resolveHandler",
+      "rejectHandler",
+      "handlerArgs",
+      "targetRefMethod",
+      "force"
+    ], O) || (u[O] = e[O]);
+  }), u;
+}, Us = async () => {
+  const e = await qe(he) || {}, t = {}, n = [];
+  return X(yt(e), (r) => {
+    const s = t[r] = t[r] || [];
+    at(n, ...vt(e[r], async (o) => {
+      const c = await qe(xn + o);
+      c && at(s, Or(c));
+    }));
+  }), await Ut.all(n), t;
+};
+const to = (e) => Qt.on(ws, e), eo = (e) => Qt.on(Cs, e), no = (e) => Qt.on(Ps, e), so = (e) => Qt.on(Ms, e), ro = (e) => Qt.on(_s, e), oo = (e) => {
+  if (ke === 0) {
+    const { alova: t, delay: n = 500 } = e;
+    _r(t), Cr(e.serializers), Pr(e.requestWait), jt(async () => {
+      Dr(await Us()), X(yt(Vt), (r) => {
+        Ts(Vt[r], r);
+      }), ys(1), Qt.emit(ws, p);
+    }, n);
+  }
+};
+let Qe = p;
+var Ur = (e, t) => {
+  const { behavior: n = "queue", queue: r = pe, retryError: s, maxRetryTimes: o, backoff: c } = t || {}, l = qt();
+  let v, d, a = pe, i = w, f;
+  return {
+    c: (...g) => (yn(Y(e), "method handler must be a function. eg. useSQRequest(() => method)"), Hn({}), v = g, e(...g)),
+    m: ({ method: g, args: H, cachedResponse: Q, proxyStates: b, config: _ }, V) => {
+      const { silentDefaultResponse: q, vDataCaptured: K, force: j = w } = _, R = wt.spawn(g, H);
+      d = re(n, [R]), a = re(r, [R]), i = re(j, [R]);
+      const x = () => {
+        Hn(v = p);
+      };
+      if (Y(K)) {
+        let T = ne && N(yt(ne)) > 0;
+        if (!T) {
+          const { url: et, data: h } = g, { params: m, headers: A } = Ve(g);
+          Nt({ url: et, params: m, data: h, headers: A }, (P) => (!T && (kt(P, w) || fe(wn, P)) && (T = D), P));
+        }
+        const J = T ? K(g) : p;
+        if (J !== p)
+          return x(), Ot(J);
+      }
+      if (d !== wr) {
+        const T = () => {
+          const h = F(Ut, (m, A) => {
+            f = F(Os, g, d, l, p, !!i, s, o, c, m, A, v, ne && yt(ne)), x();
+          });
+          return mt(Ot(p), async () => {
+            const m = () => F(xe, d, g, f, H);
+            await Tr(
+              f,
+              // After the onFallback event is bound, even the silent behavior mode is no longer stored.
+              // onFallback will be called synchronously, so it needs to be determined asynchronously whether there are fallbackHandlers
+              N(l.eventMap.fallback || []) <= 0 && d === fn,
+              a,
+              // Execute the callback before putting it into the queue. If false is returned, it will prevent putting it into the queue.
+              () => l.emit("beforePushQueue", m())
+            ) && l.emit("pushedQueue", m());
+          }), h;
+        };
+        if (d === Rr) {
+          const h = i || !Q;
+          return h && (b.loading.v = D), h ? T() : mt(Ot(Q));
+        }
+        const J = T(), et = f.virtualResponse = Ds(Y(q) ? q() : p);
+        return mt(J, (h) => {
+          b.data.v = h;
+        }), Ot(et);
+      }
+      return x(), V();
+    },
+    d: (g) => {
+      g.onSuccess = Re(g.onSuccess, (H, Q) => {
+        Qe = f, H(F(fr, d, Q.method, f, Q.args, Q.data));
+      }), g.onError = Re(g.onError, (H, Q) => {
+        H(F(ms, d, Q.method, f, Q.args, Q.error));
+      }), g.onComplete = Re(g.onComplete, (H, Q) => {
+        H(F(hr, d, Q.method, f, Q.args, Q.status, Q.data, Q.error));
+      });
+    },
+    // event binding function
+    b: {
+      /**
+       * Bind fallback event
+       * @param handler Fallback event callback
+       */
+      onFallback: (g) => {
+        l.on("fallback", g);
+      },
+      /**
+       * Event before binding to queue
+       * @param handler Event callback before enqueuing
+       */
+      onBeforePushQueue: (g) => {
+        l.on("beforePushQueue", g);
+      },
+      /**
+       * Event after binding to queue
+       * @param handler Event callback after being queued
+       */
+      onPushedQueue: (g) => {
+        l.on("pushedQueue", g);
+      },
+      /**
+       * retry event
+       * @param handler Retry event callback
+       */
+      onRetry: (g) => {
+        l.on("retry", g);
+      }
+    }
+  };
+};
+function ao(e, t = {}) {
+  const { exposeProvider: n, __referingObj: r } = Ft(Rt()), { middleware: s = Z } = t, { c: o, m: c, b: l, d: v } = Ur(e, t), d = Ee(o, {
+    ...t,
+    __referingObj: r,
+    middleware: (a, i) => {
+      const f = c(a, i);
+      return s(a, () => f), f;
+    }
+  });
+  return v(d), n({
+    ...d,
+    ...l
+  });
+}
+var co = (e, t) => e === t ? D : kt(e) === kt(t);
+const Qr = async (e, t = pe, n = w) => {
+  const r = (s = []) => s.filter((o) => {
+    if (e === p)
+      return D;
+    const c = Ve(o.entity).name || "";
+    return (k(e, RegExp) ? fe(e, c) : c === e) && (n ? o.active : D);
+  });
+  return [
+    ...r(Vt[t]),
+    // If the silent factory is not currently started, you also need to match the silent methods in the persistent storage.
+    ...ke === 0 ? r((await Us())[t]) : []
+  ];
+}, io = async (e, t = pe, n = w) => (await Qr(e, t, n))[0];
+var lo = (e) => !!kt(e, w) || fe(wn, e);
+const uo = async (e, t) => (Qe && (Qe.setUpdateState(e, Y(Ue) ? p : yt(Ue)), await Qe.save()), Ue(e, t));
+class De {
+  constructor(t, n = {}) {
+    var r, s, o;
+    this.cancelBubble = w, this.currentTarget = Wt, this.defaultPrevented = w, this.eventPhase = 0, this.isTrusted = w, this.returnValue = D, this.srcElement = Wt, this.target = Wt, this.NONE = 0, this.CAPTURING_PHASE = 1, this.AT_TARGET = 2, this.BUBBLING_PHASE = 3, this.type = t, this.bubbles = (r = n.bubbles) !== null && r !== void 0 ? r : !1, this.cancelable = (s = n.cancelable) !== null && s !== void 0 ? s : !1, this.composed = (o = n.composed) !== null && o !== void 0 ? o : !1, this.timeStamp = Date.now();
+  }
+  // Event 标准方法
+  preventDefault() {
+    this.cancelable && (this.defaultPrevented = !0);
+  }
+  stopImmediatePropagation() {
+  }
+  stopPropagation() {
+    this.cancelBubble = !0;
+  }
+  composedPath() {
+    return [];
+  }
+  initEvent(t, n, r) {
+  }
+}
+De.NONE = 0;
+De.CAPTURING_PHASE = 1;
+De.AT_TARGET = 2;
+De.BUBBLING_PHASE = 3;
+const Ir = typeof Event < "u" ? Event : De;
+class en extends Ir {
+  constructor(t, n) {
+    super(t, {
+      bubbles: D,
+      cancelable: D,
+      composed: D
+    }), this.data = n.data, this.lastEventId = n.lastEventId, this.origin = n.origin || "", this.error = n.error;
+  }
+}
+class Dn extends wt {
+  constructor(t, n) {
+    super(t.method, t.args), this.eventSource = n;
+  }
+}
+class Vr extends Dn {
+  constructor(t, n) {
+    super(t, t.eventSource), this.error = n;
+  }
+}
+class jr extends Dn {
+  constructor(t, n) {
+    super(t, t.eventSource), this.data = n;
+  }
+}
+const kn = _t("EventSourceFetch");
+class dt {
+  /**
+   * Creates a new EventSourceFetch instance
+   *
+   * @param url The URL to connect to
+   * @param options Configuration options (includes all fetch options plus EventSource specific options)
+   */
+  constructor(t, n, r = {}) {
+    this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, this.onopen = null, this.onmessage = null, this.onerror = null, this._listeners = {}, this._reconnectTime = null, this._controller = null, this._lastEventId = "", this._origin = "", this.url = t, this.readyState = dt.CONNECTING, this._options = { ...r }, this._reconnectTime = n;
+    const s = F(URL, t, window.location.href);
+    this._origin = s.origin, t && jt(() => this._connect());
+  }
+  /**
+   * Adds an event listener for the specified event
+   *
+   * @param type Event type to listen for
+   * @param listener Function or object to call when event is received
+   * @param options EventListener options
+   */
+  addEventListener(t, n) {
+    this._listeners[t] = this._listeners[t] || [], this._listeners[t].find((s) => s === n || bt(s) && bt(n) && s?.handleEvent === n.handleEvent) || this._listeners[t].push(n);
+  }
+  /**
+   * Removes an event listener for the specified event
+   *
+   * @param type Event type to remove listener from
+   * @param listener Function to remove
+   * @param options EventListener options
+   */
+  removeEventListener(t, n) {
+    !n || !this._listeners[t] || (this._listeners[t] = Dt(this._listeners[t], (r) => r !== n && !(typeof r == "object" && typeof n == "object" && r?.handleEvent === n.handleEvent)));
+  }
+  /**
+   * Dispatches an event
+   *
+   * @param event Event to dispatch
+   * @returns Whether preventDefault was called
+   */
+  dispatchEvent(t) {
+    if (!(t instanceof en))
+      return D;
+    const n = this._listeners[t.type] || [];
+    for (const o of n)
+      Y(o) ? o(t) : o && Y(o.handleEvent) && o.handleEvent(t);
+    const r = `on${t.type}`, s = this[r];
+    return Y(s) && s(t), !t.defaultPrevented;
+  }
+  /**
+   * Closes the connection
+   */
+  close() {
+    this.readyState !== dt.CLOSED && (this.readyState = dt.CLOSED, this._dispatchEvent("close", ""), this._controller && (this._controller.abort(), this._controller = null));
+  }
+  /**
+   * Establishes connection to the event source
+   */
+  _connect() {
+    if (this.readyState === dt.CLOSED)
+      return;
+    this._controller = F(AbortController);
+    const t = this._options, n = t.headers || {}, r = ["Accept", "text/event-stream"], s = "Last-Event-ID", o = this._lastEventId;
+    if (lt(n))
+      at(n, r), o && at(n, [s, o]);
+    else if (k(n, Headers))
+      n.append(r[0], r[1]), o && n.append(s, o);
+    else if (bt(n)) {
+      const [l, v] = r;
+      n[l] = v, o && (n[s] = o);
+    }
+    const c = {
+      ...t,
+      headers: n,
+      signal: this._controller.signal
+    };
+    fetch(this.url, c).then((l) => {
+      kn(l.ok, `HTTP error: ${l.status}`), kn(l.body, "ReadableStream not supported");
+      const v = F(URL, l.url);
+      this._origin = v.origin, this.readyState = dt.OPEN, this._dispatchEvent("open", "");
+      const d = l.body.getReader(), a = new TextDecoder();
+      let i = "";
+      const f = ({ done: u, value: O }) => {
+        if (u)
+          return this.readyState !== dt.CLOSED && this._reconnect(), Ot();
+        i += a.decode(O, { stream: !0 });
+        const I = i.split(/\r\n|\r|\n/);
+        return i = I.pop() || "", this._processEventStream(I), d.read().then(f).catch((g) => (g.name !== "AbortError" && this.readyState !== dt.CLOSED && this._onError(g), Ot()));
+      };
+      return d.read().then(f).catch((u) => {
+        u.name !== "AbortError" && this.readyState !== dt.CLOSED && this._onError(u);
+      });
+    }).catch((l) => {
+      l.name !== "AbortError" && this.readyState !== dt.CLOSED && this._onError(l);
+    });
+  }
+  /**
+   * Processes received event stream lines
+   *
+   * @param lines Lines received from the event stream
+   */
+  _processEventStream(t) {
+    let n = "message", r = "", s = null, o = null;
+    const c = () => {
+      if (r) {
+        if (r.endsWith(`
+`) && (r = r.substring(0, r.length - 1)), s !== null && (this._lastEventId = s), o !== null && this._reconnectTime === null) {
+          const l = parseInt(o, 10);
+          Number.isNaN(l) || (this._reconnectTime = l);
+        }
+        this._dispatchEvent(n, r);
+      }
+      n = "message", r = "", s = null, o = null;
+    };
+    for (const l of t) {
+      if (l === "") {
+        c();
+        continue;
+      }
+      if (l.startsWith(":"))
+        continue;
+      let v, d;
+      const a = l.indexOf(":");
+      switch (a === -1 ? (v = l, d = "") : (v = l.slice(0, a), d = l.slice(a + (l[a + 1] === " " ? 2 : 1))), v) {
+        case "event":
+          n = d;
+          break;
+        case "data":
+          r = r ? `${r}
+${d}` : d;
+          break;
+        case "id":
+          if (d.includes("\0"))
+            continue;
+          s = d;
+          break;
+        case "retry":
+          o = d;
+          break;
+        default:
+          throw F($e, "EventSource", `EventSource: Unknown field "${v}", ignoring`);
+      }
+    }
+  }
+  /**
+   * Dispatches an event
+   *
+   * @param type Event type
+   * @param data Event data
+   */
+  _dispatchEvent(t, n) {
+    const r = F(en, t, {
+      type: t,
+      data: n,
+      lastEventId: this._lastEventId,
+      origin: this._origin
+    });
+    this.dispatchEvent(r);
+  }
+  /**
+   * Handles errors
+   *
+   * @param error Error object
+   */
+  _onError(t) {
+    const n = F(en, "error", {
+      type: "error",
+      data: "",
+      lastEventId: this._lastEventId,
+      origin: this._origin,
+      error: t
+    });
+    this.dispatchEvent(n), this.readyState !== dt.CLOSED && this._reconnect();
+  }
+  /**
+   * Attempts to reconnect after connection closed or error
+   */
+  _reconnect() {
+    var t;
+    if (this._reconnectTime !== null && this._reconnectTime <= 0) {
+      this.close();
+      return;
+    }
+    if (this.readyState !== dt.CLOSED) {
+      this.readyState = dt.CONNECTING;
+      const n = (t = this._reconnectTime) !== null && t !== void 0 ? t : 1e3;
+      jt(() => this._connect(), n);
+    }
+  }
+}
+dt.CONNECTING = 0;
+dt.OPEN = 1;
+dt.CLOSED = 2;
+const nn = Symbol("SSEOpen"), Te = Symbol("SSEMessage"), sn = Symbol("SSEError");
+var Zt;
+(function(e) {
+  e[e.CONNECTING = 0] = "CONNECTING", e[e.OPEN = 1] = "OPEN", e[e.CLOSED = 2] = "CLOSED";
+})(Zt || (Zt = {}));
+const Qs = "useSSE", Br = _t(Qs);
+var St;
+(function(e) {
+  e.Open = "open", e.Error = "error", e.Message = "message", e.Close = "close";
+})(St || (St = {}));
+var fo = (e, t = {}) => {
+  const {
+    initialData: n,
+    withCredentials: r,
+    interceptByGlobalResponded: s = D,
+    /** abortLast = trueValue, */
+    immediate: o = w,
+    responseType: c = "text",
+    reconnectionTime: l = null,
+    ...v
+  } = t, d = D, { create: a, ref: i, onMounted: f, onUnmounted: u, objectify: O, exposeProvider: I, memorize: g } = Ft(Rt()), H = i([]), Q = i(p), b = i(p), _ = a(n, "data"), V = a(Zt.CLOSED, "readyState"), q = a(p, "eventSource");
+  let K = qn(e), j;
+  const R = qt(), x = i(/* @__PURE__ */ new Map()), T = (L) => {
+    R.on(nn, L);
+  }, J = (L) => {
+    R.on(Te, L);
+  }, et = (L) => {
+    R.on(sn, L);
+  }, h = i(se), m = i(Nn), A = i(Z), P = (L) => {
+    const { responded: B } = Ys(L);
+    if (j = B, Y(j))
+      h.current = j;
+    else if (j && oe(j)) {
+      const { onSuccess: W, onError: nt, onComplete: ut } = j;
+      h.current = Y(W) ? W : h.current, m.current = Y(nt) ? nt : m.current, A.current = Y(ut) ? ut : A.current;
+    }
+  }, M = async (L) => {
+    const { headers: B, transform: W = se } = Ve(K), nt = await L, ut = await W(nt, B || {});
+    return _.v = ut, nr(K), ut;
+  }, y = async (L, B) => {
+    Br(Q.current, "EventSource is not initialized");
+    const W = Q.current, nt = F(Dn, wt.spawn(K, H.current), W);
+    if (L === St.Open)
+      return nt;
+    const ut = s ? h.current : se, Lt = s ? m.current : Nn, zt = s ? A.current : Z, Pt = Pe(B);
+    if (c === "json" && Pt)
+      try {
+        B = Js(B);
+      } catch (pt) {
+        throw F($e, Qs, pt.message);
+      }
+    const Bt = ue(mt(Pt ? Ot(B) : as(B), (pt) => M(ut(pt, K)), (pt) => M(Lt(pt, K))), () => {
+      zt(K);
+    });
+    return mt(
+      Bt,
+      // Get processed data (data after transform)
+      (pt) => F(jr, nt, pt),
+      // There is an error
+      (pt) => new Vr(nt, pt)
+    );
+  }, C = (L) => (B) => B.error === p ? L(B) : R.emit(sn, B), z = (L, B) => {
+    var W;
+    const nt = x.current;
+    if (!nt.has(L)) {
+      const Lt = sr((Pt) => {
+        var Bt;
+        Pt.length === 0 && ((Bt = Q.current) === null || Bt === void 0 || Bt.removeEventListener(L, Lt[1]), x.current.delete(L));
+      }), zt = Lt[1];
+      nt.set(L, Lt), (W = Q.current) === null || W === void 0 || W.addEventListener(L, (Pt) => {
+        mt(y(L, Pt.data), C(zt));
+      });
+    }
+    const [ut] = nt.get(L);
+    return ut(B);
+  }, $ = () => {
+    x.current.forEach(([L, B, W]) => {
+      W();
+    });
+  }, ot = g(() => {
+    var L;
+    V.v = Zt.OPEN, mt(y(St.Open), (B) => R.emit(nn, B)), (L = b.current) === null || L === void 0 || L.resolve();
+  }), ht = g((L) => {
+    var B;
+    V.v = Zt.CLOSED, mt(y(St.Error, L.error || F(Error, "SSE Error")), C((W) => R.emit(Te, W))), (B = b.current) === null || B === void 0 || B.resolve();
+  }), Et = g((L) => {
+    mt(y(St.Message, L.data), C((B) => R.emit(Te, B)));
+  }), ct = () => {
+    const L = Q.current;
+    L && (b.current && b.current.resolve(), L.close(), L.removeEventListener(St.Open, ot), L.removeEventListener(St.Error, ht), L.removeEventListener(St.Message, Et), L.removeEventListener(St.Close, ct), V.v = Zt.CLOSED, x.current.forEach(([B, W], nt) => {
+      L.removeEventListener(nt, W);
+    }));
+  }, Ct = (...L) => {
+    let B = Q.current, W = b.current;
+    B && d && ct(), W || (W = b.current = Ce(), W && ue(W.promise, () => {
+      W = p;
+    })), H.current = L, K = qn(e, L), P(K);
+    const { params: nt, headers: ut } = Ve(K), { baseURL: Lt, url: zt, data: Pt, type: Bt } = K, pt = Xs(Lt, zt, nt);
+    return B = F(dt, pt, l, {
+      credentials: r ? "include" : "same-origin",
+      method: Bt || "GET",
+      headers: ut,
+      body: ((Yt) => Pe(Yt) || Zs(Yt))(Pt) ? Pt : tr(Pt),
+      ...v
+    }), Q.current = B, q.v = B, V.v = Zt.CONNECTING, B.addEventListener(St.Open, ot), B.addEventListener(St.Error, ht), B.addEventListener(St.Message, Et), B.addEventListener(St.Close, ct), x.current.forEach(([Yt, Se], ae) => {
+      B?.addEventListener(ae, (ce) => {
+        mt(y(ae, ce.data), C(Se));
+      });
+    }), W.promise;
+  };
+  return u(() => {
+    ct(), R.off(nn), R.off(Te), R.off(sn), $();
+  }), f(() => {
+    var L;
+    o && (Ct(), (L = b.current) === null || L === void 0 || L.promise.catch(() => {
+    }));
+  }), I({
+    send: Ct,
+    close: ct,
+    on: z,
+    onMessage: J,
+    onError: et,
+    onOpen: T,
+    ...O([V, _, q])
+  });
+};
+const le = _t("useUploader");
+function ze(e, { limit: t = 0, localLink: n, replaceSrc: r, mode: s } = {}) {
+  const { create: o, computed: c, exposeProvider: l, ref: v } = Ft(Rt()), d = qt(), a = o([], "fileList"), i = c(() => a.v[0], [a], "file"), f = o(!1, "uploading"), u = o(0, "successCount"), O = o(0, "failCount"), I = c(() => ({
+    ...a.v.reduce((h, { progress: m, status: A }) => (A !== 0 && (h.total += m.total, h.uploaded += m.uploaded), h), {
+      uploaded: 0,
+      total: 0
+    })
+  }), [a], "progress"), g = c(() => {
+    var h;
+    return (h = a.v.find((m) => m.error)) === null || h === void 0 ? void 0 : h.error;
+  }, [a], "error"), H = async (h = {}, m = {}) => {
+    var A;
+    let P = h, M = m;
+    !h.file && !lt(h) && (M = h, P = []);
+    let y = lt(P) ? P : [P];
+    N(y) <= 0 && (y = await ze.selectFile(M)), le(t <= 0 || N(a.v) + N(y) <= t, `The number of files exceeds the limit of ${t}`);
+    const { converters: C } = ze, z = await Ut.all(vt(y, async (Et) => {
+      const ct = C.find(({ is: L }) => L(Et));
+      le(ct, `Invalid file type, only ${vt(C, ({ name: L }) => L).join(", ")} are supported, if other file needs, customize convert function with \`useUploader.convertFile.push({ is: ..., convert: ... })\``);
+      const Ct = await ct.convert(Et);
+      return le(Ct, "Failed to convert file"), {
+        src: Et.src || (n ? URL.createObjectURL(Ct) : void 0),
+        file: Ct,
+        status: 0,
+        progress: { uploaded: 0, total: Ct.size }
+      };
+    })), $ = (A = M.start) !== null && A !== void 0 ? A : N(a.v), ot = Dt(z, Boolean), ht = [...a.v];
+    return xt(ht, $, 0, ...ot), a.v = ht, N(z);
+  }, Q = (h, m = [1, 2], A = "upload") => {
+    const P = {
+      upload: "uploaded",
+      abort: "aborted"
+    }[A], M = a.v;
+    return N(h) > 0 ? vt(h, (y, C) => {
+      const z = At(y), $ = z ? M[y] : y, ot = z ? `index ${y}` : `position ${C}`;
+      return le($, `The file of ${ot} does not exist`), N(m) > 0 && le(!Tt(m, $.status) && bt($.file), `The file of ${ot} cannot be ${P}, which status is ${$.status}`), $;
+    }) : Dt(M, (y) => !Tt(m, y.status));
+  }, b = (h, m) => Dt(h, (A) => N(m) > 0 ? Tt(m, A.status) : D), _ = v([]), V = (h, m) => {
+    a.v.findIndex((P) => P.file === h) > -1 && at(_.current, { f: h, m });
+  }, q = (h) => {
+    _.current = Dt(_.current, ({ m }) => m !== h);
+  }, K = (...h) => {
+    const m = Q(h, [0, 2, 3], "abort"), A = [];
+    N(m) > 0 ? X(m, ({ file: M }) => {
+      const y = _.current.find(({ f: C }) => C === M);
+      y && at(A, y.m);
+    }) : at(A, ...vt(_.current, ({ m: M }) => M));
+    const P = [];
+    X(A, (M) => {
+      P.includes(M) || at(P, M);
+    }), X(P, (M) => M.abort());
+  }, j = (...h) => {
+    const m = Q(h, []);
+    N(m) > 0 ? (K(...b(m, [1])), a.v = Dt(a.v, (A) => !Tt(m, A)), u.v = N(b(a.v, [2])), O.v = N(b(a.v, [3]))) : (K(...b(a.v, [1])), a.v = []);
+  }, R = (h, m, A) => {
+    const P = wt.spawn(h, []);
+    return {
+      successEvent: F(hs, P, m, w),
+      errorEvent: F(En, P, A),
+      completeEvent: F(dn, P, A ? ee : te, m, w, A)
+    };
+  }, x = (h, m, A, P, M = 0) => {
+    if (h.status = m, m === 2) {
+      if (h.progress.uploaded = h.progress.total, r) {
+        const y = r(A, M);
+        y && (h.src = y);
+      }
+    } else m === 3 && (h.error = P);
+    a.v = [...a.v];
+  }, T = (h, m) => {
+    const A = e(m);
+    return A.onUpload((P) => {
+      X(h, (M) => {
+        M.progress.uploaded = P.loaded * (M.progress.total / P.total);
+      });
+    }), X(h, ({ file: P }) => V(P, A)), A.then((P) => {
+      X(h, (C, z) => x(C, 2, P, void 0, z)), u.v = N(b(a.v, [2]));
+      const { successEvent: M, completeEvent: y } = R(A, P);
+      return d.emit(te, M), d.emit(Gt, y), P;
+    }, (P) => {
+      X(h, (C) => x(C, 3, void 0, P)), O.v = N(b(a.v, [3]));
+      const { errorEvent: M, completeEvent: y } = R(A, void 0, P);
+      return d.emit(ee, M), d.emit(Gt, y), P;
+    }).finally(() => {
+      f.v = !1, q(A);
+    });
+  }, J = (h) => {
+    const m = vt(h, (A, P) => {
+      const M = e({ file: A.file, name: A.file.name });
+      return M.onUpload(({ loaded: y, total: C }) => {
+        X(h, (z) => {
+          z.progress.uploaded = y, z.progress.total = C;
+        });
+      }), V(A.file, M), M.then((y) => {
+        x(A, 2, y, p, P), u.v += 1;
+        const { successEvent: C, completeEvent: z } = R(M, y);
+        return d.emit(te, C), d.emit(Gt, z), y;
+      }, (y) => {
+        x(A, 3, p, y), O.v += 1;
+        const { errorEvent: C, completeEvent: z } = R(M, p, y);
+        return d.emit(ee, C), d.emit(Gt, z), y;
+      }).finally(() => {
+        q(M);
+      });
+    });
+    return ue(Ut.all(m), () => {
+      f.v = w;
+    });
+  };
+  return l({
+    fileList: a,
+    uploading: f,
+    file: i,
+    progress: I,
+    successCount: u,
+    failCount: O,
+    error: g,
+    appendFiles: H,
+    removeFiles: j,
+    upload: async (...h) => {
+      const m = Q(h);
+      X(m, (P) => {
+        P.status = 1;
+      });
+      const A = vt(m, ({ file: P }) => ({
+        file: P,
+        name: P.name
+      }));
+      return f.v = D, s === "batch" ? T(m, A) : J(m);
+    },
+    abort: K,
+    onSuccess: (h) => {
+      d.on(te, h);
+    },
+    onError: (h) => {
+      d.on(ee, h);
+    },
+    onComplete: (h) => {
+      d.on(Gt, h);
+    }
+  });
+}
+ze.selectFile = ({ multiple: e, accept: t } = {}) => {
+  const n = document.createElement("input");
+  return n.type = "file", n.multiple = !!e, t && (n.accept = t), n.click(), F(Promise, (r) => {
+    n.addEventListener("change", () => {
+      const s = vt(Array.from(n.files || []), (o) => ({
+        file: o,
+        name: o.name,
+        mimeType: o.type
+      }));
+      r(s);
+    });
+  });
+};
+const rn = "text/plain";
+ze.converters = [
+  {
+    name: "HTMLCanvasElement",
+    is: ({ file: e }) => k(e, HTMLCanvasElement),
+    async convert({ file: e, mimeType: t, name: n }) {
+      const r = await F(Ut, (s) => e?.toBlob(s));
+      if (r)
+        return F(File, [r], n || "image.png", {
+          type: t || r.type
+        });
+    }
+  },
+  {
+    name: "base64",
+    is: ({ file: e }) => Pe(e),
+    convert({ file: e = "", mimeType: t, name: n }) {
+      var r;
+      le(/data:.+;base64,/.test(e), "Invalid base64 string");
+      const s = e.split(","), o = (r = s[0].match(/:(.*?);/)) === null || r === void 0 ? void 0 : r[1], c = atob(s[1]), l = new Uint8Array(N(c));
+      return X(Array.from(c), (v, d) => {
+        l[d] = v.charCodeAt(0);
+      }), F(File, [l], n || "file", {
+        type: t || o || rn
+      });
+    }
+  },
+  {
+    name: "File",
+    is: ({ file: e }) => k(e, File),
+    convert({ file: e }) {
+      return e;
+    }
+  },
+  {
+    name: "Blob",
+    is: ({ file: e }) => k(e, Blob),
+    convert({ file: e, name: t, mimeType: n }) {
+      return F(File, [e], t || "file", {
+        type: n || e.type || rn
+      });
+    }
+  },
+  {
+    name: "ArrayBuffer",
+    is: ({ file: e }) => k(e, ArrayBuffer),
+    convert({ file: e, name: t, mimeType: n }) {
+      return F(File, [F(Blob, [e])], t || "file", {
+        type: n || rn
+      });
+    }
+  }
+];
+const Ht = (e, t = {}) => {
+  let n = D;
+  const { enableFocus: r = D, enableVisibility: s = D, enableNetwork: o = D, pollingTime: c = 0, throttle: l = 1e3 } = t, { onMounted: v, onUnmounted: d, __referingObj: a } = Ft(Rt()), i = Ee(e, {
+    ...t,
+    __referingObj: a
+  }), f = () => {
+    n && (i.send(), l > 0 && (n = w, setTimeout(() => {
+      n = D;
+    }, l)));
+  };
+  let u = Z, O = Z, I = Z, g = Z;
+  return v(() => {
+    cs.ssr || (u = o ? Ht.onNetwork(f, t) : u, O = r ? Ht.onFocus(f, t) : O, I = s ? Ht.onVisibility(f, t) : I, g = c > 0 ? Ht.onPolling(f, t) : g);
+  }), d(() => {
+    u(), O(), I(), g();
+  }), i;
+}, Fn = (e, t) => (window.addEventListener(e, t), () => window.removeEventListener(e, t));
+Ht.onNetwork = (e) => Fn("online", e);
+Ht.onFocus = (e) => Fn("focus", e);
+Ht.onVisibility = (e) => Fn("visibilitychange", () => document.visibilityState === "visible" && e());
+Ht.onPolling = (e, t) => {
+  const n = setInterval(e, t.pollingTime);
+  return () => clearInterval(n);
+};
+const Is = "useCaptcha", Kr = _t(Is);
+var vo = (e, t = {}) => {
+  const { initialCountdown: n, middleware: r } = t;
+  Kr(n === p || n > 0, "initialCountdown must be greater than 0");
+  const { create: s, ref: o, objectify: c, exposeProvider: l, __referingObj: v } = Ft(Rt()), d = s(0, "countdown"), a = Ee(e, {
+    ...t,
+    __referingObj: v,
+    immediate: w,
+    managedStates: c([d], "s"),
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    middleware: r ? (u, O) => r({ ...u, send: f }, O) : p
+  }), i = o(p), f = (...u) => F(Ut, (O, I) => {
+    d.v <= 0 ? a.send(...u).then((g) => {
+      d.v = t.initialCountdown || 60, i.current = setInterval(() => {
+        d.v -= 1, d.v <= 0 && clearInterval(i.current);
+      }, 1e3), O(g);
+    }).catch((g) => I(g)) : I(F($e, Is, "the countdown is not over yet"));
+  });
+  return l({
+    ...a,
+    send: f,
+    ...c([d])
+  });
+};
+const Yn = Symbol("FormRestore"), Nr = (e) => `alova/form-${k(e, me) ? Kt(e) : e}`, Jn = qt(), ge = {}, Xn = (e) => {
+  const t = (n) => lt(n) ? [...n] : oe(n) ? { ...n } : n;
+  return Nt(t(e), t);
+};
+var ho = (e, t = {}) => {
+  const { id: n } = t, r = n ? ge[n] : p, { id: s, initialForm: o, store: c, resetAfterSubmiting: l, immediate: v = w, middleware: d } = r?.config || t;
+  Rt();
+  const { create: a, ref: i, onMounted: f, onUnmounted: u, watch: O, objectify: I, exposeProvider: g, __referingObj: H } = Ft(Rt()), Q = oe(c), b = Q ? c.enable : c, _ = a(Xn(r?.form || o), "form"), V = e, q = qt(), K = i(p);
+  let j = r?.l2Cache;
+  b && !r?.l2Cache && (K.current = re(V, [_.v]), j = He(K.current).l2Cache);
+  const R = Nr(s || K.current || ""), x = i(w), T = i(Rn(Q ? c.serializers : p));
+  s && !ge[s] && (ge[s] = {
+    form: _.v,
+    l2Cache: j,
+    config: t
+  });
+  const J = Ee((...y) => V(_.v, ...y), {
+    ...t,
+    __referingObj: H,
+    // Middleware function, also supports subscriber middleware
+    middleware: d ? (y, C) => d({
+      ...y,
+      // eslint-disable-next-line
+      delegatingActions: { updateForm: h, reset: et }
+    }, C) : p,
+    // 1. When persistence is required, it will be triggered after data recovery
+    // 2. When there is a shared state, it means that it has been initialized before (regardless of whether there is an immediate request), and subsequent requests will no longer be automatically initiated. This is to be compatible with the issue of repeated requests when multiple forms initiate requests immediately.
+    immediate: b || r ? w : v
+  }), et = () => {
+    x.current = D;
+    const y = Xn(o);
+    y && (_.v = y), b && j?.remove(R);
+  }, h = (y) => {
+    _.v = {
+      ..._.v,
+      ...y
+    };
+  }, m = g({
+    // The first parameter is fixed to form data
+    ...J,
+    ...I([_]),
+    updateForm: h,
+    reset: et,
+    // Persistent data recovery event binding
+    onRestore(y) {
+      q.on(Yn, y);
+    }
+  }), A = i(Z), { send: P, onSuccess: M } = m;
+  return f(() => {
+    if (s && (A.current = Jn.on(s, (y) => {
+      _.v = y;
+    })), b && j && !r) {
+      const y = T.current.deserialize(j.get(R));
+      y && (_.v = y, q.emit(Yn, p)), v && P();
+    }
+  }), O([_], () => {
+    if (s && (Jn.emit(s, _.v), ge[s] && (ge[s].form = _.v)), x.current || !b) {
+      x.current = w;
+      return;
+    }
+    j?.set(R, T.current.serialize(_.v));
+  }), u(() => {
+    A.current();
+  }), M(() => {
+    l && et();
+  }), m;
+};
+const Zn = Symbol("RetriableRetry"), ts = Symbol("RetriableFail"), Vs = "useRetriableRequest", qr = _t(Vs);
+var po = (e, t = {}) => {
+  const { retry: n = 3, backoff: r = { delay: 1e3 }, middleware: s = Z } = t, { ref: o, exposeProvider: c, __referingObj: l } = Ft(Rt()), v = qt(), d = o(0), a = o(p), i = o(p), f = o(p), u = o(w), O = o(p), I = o(Ce()), g = (V, q, K) => {
+    jt(() => {
+      v.emit(ts, F(mr, wt.spawn(V, q), K, d.current)), a.current = p, d.current = 0;
+    });
+  }, H = Ee(e, {
+    ...t,
+    __referingObj: l,
+    middleware(V, q) {
+      s({
+        ...V,
+        delegatingActions: {
+          // eslint-disable-next-line @typescript-eslint/no-use-before-define
+          stop: Q
+        }
+      }, () => Ot());
+      const { proxyStates: K, args: j, send: R, method: x, controlLoading: T } = V;
+      T();
+      const { loading: J } = K, et = (m = w) => {
+        J.v = m;
+      }, h = (m) => {
+        et(), K.error.v = m, clearTimeout(O.current), g(x, j, m);
+      };
+      return J.v || ye(I.current.promise, (m) => {
+        h(m), I.current = Ce();
+      }), et(D), u.current = D, i.current = x, f.current = j, q().then(
+        (m) => (et(), m),
+        // Trigger retry mechanism when request fails
+        (m) => {
+          if (!a.current && (At(n) ? d.current < n : n(m, ...j))) {
+            d.current += 1;
+            const A = os(r, d.current);
+            O.current = jt(() => {
+              v.emit(Zn, F(pr, wt.spawn(x, j), d.current, A)), ye(R(...j), Z);
+            }, A);
+          } else
+            m = a.current || m, h(m);
+          return as(m);
+        }
+      ).finally(() => {
+        u.current = w;
+      });
+    }
+  }), Q = () => {
+    qr(H.__proxyState("loading").v, "there is no requests being retried"), a.current = F($e, Vs, "stop retry manually"), u.current ? H.abort() : I.current.reject(a.current);
+  };
+  return c({
+    ...H,
+    stop: Q,
+    onRetry: (V) => {
+      v.on(Zn, (q) => V(q));
+    },
+    onFail: (V) => {
+      v.on(ts, (q) => V(q));
+    }
+  });
+};
+let on = 0;
+const $t = {}, zr = (e) => !!e.send, Gr = _t("subscriber"), mo = (e) => {
+  const { ref: t, onUnmounted: n } = Ft(Rt()), r = t(on + 1);
+  return r.current > on && (on += 1), n(() => {
+    var s;
+    !((s = $t[e]) === null || s === void 0) && s[r.current] && delete $t[e][r.current];
+  }), (s, o) => {
+    const { abort: c, proxyStates: l, delegatingActions: v = {} } = s, d = (f) => {
+      for (const u in f)
+        l[u] && (l[u].v = f[u]);
+    }, a = $t[e] = $t[e] || [], i = zr(s) ? {
+      ...v,
+      send: s.send,
+      abort: c,
+      update: d
+    } : {
+      ...v,
+      fetch: s.fetch,
+      abort: c,
+      update: d
+    };
+    return a[r.current] = i, o();
   };
+}, Eo = (e, t, n = !1) => {
+  const r = [];
+  typeof e == "symbol" || Pe(e) || At(e) ? $t[e] && at(r, ...Ie($t[e])) : k(e, RegExp) && X(Dt(yt($t), (s) => e.test(s)), (s) => {
+    at(r, ...Ie($t[s]));
+  }), r.length === 0 && !n && Gr(!1, `no handler can be matched by using \`${e.toString()}\``), X(Dt(r, se), t);
 };
-var U;
-(function(n) {
-  n[n.USE_REQUEST = 1] = "USE_REQUEST", n[n.USE_WATCHER = 2] = "USE_WATCHER", n[n.USE_FETCHER = 3] = "USE_FETCHER";
-})(U || (U = {}));
-var T;
-(function(n) {
-  n[n.CONNECTING = 0] = "CONNECTING", n[n.OPEN = 1] = "OPEN", n[n.CLOSED = 2] = "CLOSED";
-})(T || (T = {}));
-var _;
-(function(n) {
-  n.Open = "open", n.Error = "error", n.Message = "message", n.Close = "close";
-})(_ || (_ = {}));
 export {
-  I as createClientTokenAuthentication
+  Eo as accessAction,
+  mo as actionDelegationMiddleware,
+  oo as bootSilentFactory,
+  Wr as createClientTokenAuthentication,
+  kr as createServerTokenAuthentication,
+  Zr as dehydrateVData,
+  co as equals,
+  Qr as filterSilentMethods,
+  io as getSilentMethod,
+  lo as isVData,
+  ro as onBeforeSilentSubmit,
+  to as onSilentSubmitBoot,
+  no as onSilentSubmitError,
+  so as onSilentSubmitFail,
+  eo as onSilentSubmitSuccess,
+  Vt as silentQueueMap,
+  Ft as statesHookHelper,
+  kt as stringifyVData,
+  Ue as updateState,
+  uo as updateStateEffect,
+  Ht as useAutoRequest,
+  vo as useCaptcha,
+  br as useFetcher,
+  ho as useForm,
+  Yr as usePagination,
+  Ee as useRequest,
+  po as useRetriableRequest,
+  ao as useSQRequest,
+  fo as useSSE,
+  Jr as useSerialRequest,
+  Xr as useSerialWatcher,
+  ze as useUploader,
+  Ss as useWatcher
 };