use-abcd 0.0.1

package/dist/useCrud.js

@@ -0,0 +1,2077 @@
+import { useRef as Et, useMemo as le, useCallback as U, useSyncExternalStore as ar, useEffect as cr } from "react";
+var Tt = typeof global == "object" && global && global.Object === Object && global, fr = typeof self == "object" && self && self.Object === Object && self, D = Tt || fr || Function("return this")(), B = D.Symbol, Pt = Object.prototype, ur = Pt.hasOwnProperty, lr = Pt.toString, ee = B ? B.toStringTag : void 0;
+function pr(e) {
+  var t = ur.call(e, ee), r = e[ee];
+  try {
+    e[ee] = void 0;
+    var n = !0;
+  } catch {
+  }
+  var i = lr.call(e);
+  return n && (t ? e[ee] = r : delete e[ee]), i;
+}
+var dr = Object.prototype, hr = dr.toString;
+function yr(e) {
+  return hr.call(e);
+}
+var br = "[object Null]", gr = "[object Undefined]", ke = B ? B.toStringTag : void 0;
+function X(e) {
+  return e == null ? e === void 0 ? gr : br : ke && ke in Object(e) ? pr(e) : yr(e);
+}
+function W(e) {
+  return e != null && typeof e == "object";
+}
+var mr = "[object Symbol]";
+function Le(e) {
+  return typeof e == "symbol" || W(e) && X(e) == mr;
+}
+function Rt(e, t) {
+  for (var r = -1, n = e == null ? 0 : e.length, i = Array(n); ++r < n; )
+    i[r] = t(e[r], r, e);
+  return i;
+}
+var T = Array.isArray, et = B ? B.prototype : void 0, tt = et ? et.toString : void 0;
+function Ct(e) {
+  if (typeof e == "string")
+    return e;
+  if (T(e))
+    return Rt(e, Ct) + "";
+  if (Le(e))
+    return tt ? tt.call(e) : "";
+  var t = e + "";
+  return t == "0" && 1 / e == -1 / 0 ? "-0" : t;
+}
+function ie(e) {
+  var t = typeof e;
+  return e != null && (t == "object" || t == "function");
+}
+function vr(e) {
+  return e;
+}
+var wr = "[object AsyncFunction]", _r = "[object Function]", Or = "[object GeneratorFunction]", Sr = "[object Proxy]";
+function xt(e) {
+  if (!ie(e))
+    return !1;
+  var t = X(e);
+  return t == _r || t == Or || t == wr || t == Sr;
+}
+var Oe = D["__core-js_shared__"], rt = (function() {
+  var e = /[^.]+$/.exec(Oe && Oe.keys && Oe.keys.IE_PROTO || "");
+  return e ? "Symbol(src)_1." + e : "";
+})();
+function Ar(e) {
+  return !!rt && rt in e;
+}
+var Mr = Function.prototype, Er = Mr.toString;
+function Y(e) {
+  if (e != null) {
+    try {
+      return Er.call(e);
+    } catch {
+    }
+    try {
+      return e + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var Tr = /[\\^$.*+?()[\]{}|]/g, Pr = /^\[object .+?Constructor\]$/, Rr = Function.prototype, Cr = Object.prototype, xr = Rr.toString, $r = Cr.hasOwnProperty, jr = RegExp(
+  "^" + xr.call($r).replace(Tr, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function Ir(e) {
+  if (!ie(e) || Ar(e))
+    return !1;
+  var t = xt(e) ? jr : Pr;
+  return t.test(Y(e));
+}
+function zr(e, t) {
+  return e?.[t];
+}
+function J(e, t) {
+  var r = zr(e, t);
+  return Ir(r) ? r : void 0;
+}
+var Ee = J(D, "WeakMap"), nt = (function() {
+  try {
+    var e = J(Object, "defineProperty");
+    return e({}, "", {}), e;
+  } catch {
+  }
+})(), Dr = 9007199254740991, Fr = /^(?:0|[1-9]\d*)$/;
+function Ne(e, t) {
+  var r = typeof e;
+  return t = t ?? Dr, !!t && (r == "number" || r != "symbol" && Fr.test(e)) && e > -1 && e % 1 == 0 && e < t;
+}
+function Lr(e, t, r) {
+  t == "__proto__" && nt ? nt(e, t, {
+    configurable: !0,
+    enumerable: !0,
+    value: r,
+    writable: !0
+  }) : e[t] = r;
+}
+function Ue(e, t) {
+  return e === t || e !== e && t !== t;
+}
+var Nr = Object.prototype, Ur = Nr.hasOwnProperty;
+function Kr(e, t, r) {
+  var n = e[t];
+  (!(Ur.call(e, t) && Ue(n, r)) || r === void 0 && !(t in e)) && Lr(e, t, r);
+}
+var Br = 9007199254740991;
+function Ke(e) {
+  return typeof e == "number" && e > -1 && e % 1 == 0 && e <= Br;
+}
+function me(e) {
+  return e != null && Ke(e.length) && !xt(e);
+}
+var Gr = Object.prototype;
+function Hr(e) {
+  var t = e && e.constructor, r = typeof t == "function" && t.prototype || Gr;
+  return e === r;
+}
+function Wr(e, t) {
+  for (var r = -1, n = Array(e); ++r < e; )
+    n[r] = t(r);
+  return n;
+}
+var Vr = "[object Arguments]";
+function it(e) {
+  return W(e) && X(e) == Vr;
+}
+var $t = Object.prototype, qr = $t.hasOwnProperty, Xr = $t.propertyIsEnumerable, jt = it(/* @__PURE__ */ (function() {
+  return arguments;
+})()) ? it : function(e) {
+  return W(e) && qr.call(e, "callee") && !Xr.call(e, "callee");
+};
+function Yr() {
+  return !1;
+}
+var It = typeof exports == "object" && exports && !exports.nodeType && exports, st = It && typeof module == "object" && module && !module.nodeType && module, Jr = st && st.exports === It, ot = Jr ? D.Buffer : void 0, Zr = ot ? ot.isBuffer : void 0, Te = Zr || Yr, Qr = "[object Arguments]", kr = "[object Array]", en = "[object Boolean]", tn = "[object Date]", rn = "[object Error]", nn = "[object Function]", sn = "[object Map]", on = "[object Number]", an = "[object Object]", cn = "[object RegExp]", fn = "[object Set]", un = "[object String]", ln = "[object WeakMap]", pn = "[object ArrayBuffer]", dn = "[object DataView]", hn = "[object Float32Array]", yn = "[object Float64Array]", bn = "[object Int8Array]", gn = "[object Int16Array]", mn = "[object Int32Array]", vn = "[object Uint8Array]", wn = "[object Uint8ClampedArray]", _n = "[object Uint16Array]", On = "[object Uint32Array]", y = {};
+y[hn] = y[yn] = y[bn] = y[gn] = y[mn] = y[vn] = y[wn] = y[_n] = y[On] = !0;
+y[Qr] = y[kr] = y[pn] = y[en] = y[dn] = y[tn] = y[rn] = y[nn] = y[sn] = y[on] = y[an] = y[cn] = y[fn] = y[un] = y[ln] = !1;
+function Sn(e) {
+  return W(e) && Ke(e.length) && !!y[X(e)];
+}
+function An(e) {
+  return function(t) {
+    return e(t);
+  };
+}
+var zt = typeof exports == "object" && exports && !exports.nodeType && exports, re = zt && typeof module == "object" && module && !module.nodeType && module, Mn = re && re.exports === zt, Se = Mn && Tt.process, at = (function() {
+  try {
+    var e = re && re.require && re.require("util").types;
+    return e || Se && Se.binding && Se.binding("util");
+  } catch {
+  }
+})(), ct = at && at.isTypedArray, Dt = ct ? An(ct) : Sn, En = Object.prototype, Tn = En.hasOwnProperty;
+function Pn(e, t) {
+  var r = T(e), n = !r && jt(e), i = !r && !n && Te(e), s = !r && !n && !i && Dt(e), o = r || n || i || s, c = o ? Wr(e.length, String) : [], a = c.length;
+  for (var f in e)
+    Tn.call(e, f) && !(o && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (f == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    i && (f == "offset" || f == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    s && (f == "buffer" || f == "byteLength" || f == "byteOffset") || // Skip index properties.
+    Ne(f, a))) && c.push(f);
+  return c;
+}
+function Rn(e, t) {
+  return function(r) {
+    return e(t(r));
+  };
+}
+var Cn = Rn(Object.keys, Object), xn = Object.prototype, $n = xn.hasOwnProperty;
+function Ft(e) {
+  if (!Hr(e))
+    return Cn(e);
+  var t = [];
+  for (var r in Object(e))
+    $n.call(e, r) && r != "constructor" && t.push(r);
+  return t;
+}
+function Be(e) {
+  return me(e) ? Pn(e) : Ft(e);
+}
+var jn = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, In = /^\w*$/;
+function Ge(e, t) {
+  if (T(e))
+    return !1;
+  var r = typeof e;
+  return r == "number" || r == "symbol" || r == "boolean" || e == null || Le(e) ? !0 : In.test(e) || !jn.test(e) || t != null && e in Object(t);
+}
+var se = J(Object, "create");
+function zn() {
+  this.__data__ = se ? se(null) : {}, this.size = 0;
+}
+function Dn(e) {
+  var t = this.has(e) && delete this.__data__[e];
+  return this.size -= t ? 1 : 0, t;
+}
+var Fn = "__lodash_hash_undefined__", Ln = Object.prototype, Nn = Ln.hasOwnProperty;
+function Un(e) {
+  var t = this.__data__;
+  if (se) {
+    var r = t[e];
+    return r === Fn ? void 0 : r;
+  }
+  return Nn.call(t, e) ? t[e] : void 0;
+}
+var Kn = Object.prototype, Bn = Kn.hasOwnProperty;
+function Gn(e) {
+  var t = this.__data__;
+  return se ? t[e] !== void 0 : Bn.call(t, e);
+}
+var Hn = "__lodash_hash_undefined__";
+function Wn(e, t) {
+  var r = this.__data__;
+  return this.size += this.has(e) ? 0 : 1, r[e] = se && t === void 0 ? Hn : t, this;
+}
+function V(e) {
+  var t = -1, r = e == null ? 0 : e.length;
+  for (this.clear(); ++t < r; ) {
+    var n = e[t];
+    this.set(n[0], n[1]);
+  }
+}
+V.prototype.clear = zn;
+V.prototype.delete = Dn;
+V.prototype.get = Un;
+V.prototype.has = Gn;
+V.prototype.set = Wn;
+function Vn() {
+  this.__data__ = [], this.size = 0;
+}
+function ve(e, t) {
+  for (var r = e.length; r--; )
+    if (Ue(e[r][0], t))
+      return r;
+  return -1;
+}
+var qn = Array.prototype, Xn = qn.splice;
+function Yn(e) {
+  var t = this.__data__, r = ve(t, e);
+  if (r < 0)
+    return !1;
+  var n = t.length - 1;
+  return r == n ? t.pop() : Xn.call(t, r, 1), --this.size, !0;
+}
+function Jn(e) {
+  var t = this.__data__, r = ve(t, e);
+  return r < 0 ? void 0 : t[r][1];
+}
+function Zn(e) {
+  return ve(this.__data__, e) > -1;
+}
+function Qn(e, t) {
+  var r = this.__data__, n = ve(r, e);
+  return n < 0 ? (++this.size, r.push([e, t])) : r[n][1] = t, this;
+}
+function F(e) {
+  var t = -1, r = e == null ? 0 : e.length;
+  for (this.clear(); ++t < r; ) {
+    var n = e[t];
+    this.set(n[0], n[1]);
+  }
+}
+F.prototype.clear = Vn;
+F.prototype.delete = Yn;
+F.prototype.get = Jn;
+F.prototype.has = Zn;
+F.prototype.set = Qn;
+var oe = J(D, "Map");
+function kn() {
+  this.size = 0, this.__data__ = {
+    hash: new V(),
+    map: new (oe || F)(),
+    string: new V()
+  };
+}
+function ei(e) {
+  var t = typeof e;
+  return t == "string" || t == "number" || t == "symbol" || t == "boolean" ? e !== "__proto__" : e === null;
+}
+function we(e, t) {
+  var r = e.__data__;
+  return ei(t) ? r[typeof t == "string" ? "string" : "hash"] : r.map;
+}
+function ti(e) {
+  var t = we(this, e).delete(e);
+  return this.size -= t ? 1 : 0, t;
+}
+function ri(e) {
+  return we(this, e).get(e);
+}
+function ni(e) {
+  return we(this, e).has(e);
+}
+function ii(e, t) {
+  var r = we(this, e), n = r.size;
+  return r.set(e, t), this.size += r.size == n ? 0 : 1, this;
+}
+function L(e) {
+  var t = -1, r = e == null ? 0 : e.length;
+  for (this.clear(); ++t < r; ) {
+    var n = e[t];
+    this.set(n[0], n[1]);
+  }
+}
+L.prototype.clear = kn;
+L.prototype.delete = ti;
+L.prototype.get = ri;
+L.prototype.has = ni;
+L.prototype.set = ii;
+var si = "Expected a function";
+function He(e, t) {
+  if (typeof e != "function" || t != null && typeof t != "function")
+    throw new TypeError(si);
+  var r = function() {
+    var n = arguments, i = t ? t.apply(this, n) : n[0], s = r.cache;
+    if (s.has(i))
+      return s.get(i);
+    var o = e.apply(this, n);
+    return r.cache = s.set(i, o) || s, o;
+  };
+  return r.cache = new (He.Cache || L)(), r;
+}
+He.Cache = L;
+var oi = 500;
+function ai(e) {
+  var t = He(e, function(n) {
+    return r.size === oi && r.clear(), n;
+  }), r = t.cache;
+  return t;
+}
+var ci = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, fi = /\\(\\)?/g, ui = ai(function(e) {
+  var t = [];
+  return e.charCodeAt(0) === 46 && t.push(""), e.replace(ci, function(r, n, i, s) {
+    t.push(i ? s.replace(fi, "$1") : n || r);
+  }), t;
+});
+function li(e) {
+  return e == null ? "" : Ct(e);
+}
+function We(e, t) {
+  return T(e) ? e : Ge(e, t) ? [e] : ui(li(e));
+}
+function ce(e) {
+  if (typeof e == "string" || Le(e))
+    return e;
+  var t = e + "";
+  return t == "0" && 1 / e == -1 / 0 ? "-0" : t;
+}
+function Lt(e, t) {
+  t = We(t, e);
+  for (var r = 0, n = t.length; e != null && r < n; )
+    e = e[ce(t[r++])];
+  return r && r == n ? e : void 0;
+}
+function pi(e, t, r) {
+  var n = e == null ? void 0 : Lt(e, t);
+  return n === void 0 ? r : n;
+}
+function di(e, t) {
+  for (var r = -1, n = t.length, i = e.length; ++r < n; )
+    e[i + r] = t[r];
+  return e;
+}
+var hi = "\\ud800-\\udfff", yi = "\\u0300-\\u036f", bi = "\\ufe20-\\ufe2f", gi = "\\u20d0-\\u20ff", mi = yi + bi + gi, vi = "\\ufe0e\\ufe0f", wi = "\\u200d", _i = RegExp("[" + wi + hi + mi + vi + "]");
+function Oi(e) {
+  return _i.test(e);
+}
+function Si() {
+  this.__data__ = new F(), this.size = 0;
+}
+function Ai(e) {
+  var t = this.__data__, r = t.delete(e);
+  return this.size = t.size, r;
+}
+function Mi(e) {
+  return this.__data__.get(e);
+}
+function Ei(e) {
+  return this.__data__.has(e);
+}
+var Ti = 200;
+function Pi(e, t) {
+  var r = this.__data__;
+  if (r instanceof F) {
+    var n = r.__data__;
+    if (!oe || n.length < Ti - 1)
+      return n.push([e, t]), this.size = ++r.size, this;
+    r = this.__data__ = new L(n);
+  }
+  return r.set(e, t), this.size = r.size, this;
+}
+function j(e) {
+  var t = this.__data__ = new F(e);
+  this.size = t.size;
+}
+j.prototype.clear = Si;
+j.prototype.delete = Ai;
+j.prototype.get = Mi;
+j.prototype.has = Ei;
+j.prototype.set = Pi;
+function Ri(e, t) {
+  for (var r = -1, n = e == null ? 0 : e.length, i = 0, s = []; ++r < n; ) {
+    var o = e[r];
+    t(o, r, e) && (s[i++] = o);
+  }
+  return s;
+}
+function Ci() {
+  return [];
+}
+var xi = Object.prototype, $i = xi.propertyIsEnumerable, ft = Object.getOwnPropertySymbols, ji = ft ? function(e) {
+  return e == null ? [] : (e = Object(e), Ri(ft(e), function(t) {
+    return $i.call(e, t);
+  }));
+} : Ci;
+function Ii(e, t, r) {
+  var n = t(e);
+  return T(e) ? n : di(n, r(e));
+}
+function ut(e) {
+  return Ii(e, Be, ji);
+}
+var Pe = J(D, "DataView"), Re = J(D, "Promise"), Ce = J(D, "Set"), lt = "[object Map]", zi = "[object Object]", pt = "[object Promise]", dt = "[object Set]", ht = "[object WeakMap]", yt = "[object DataView]", Di = Y(Pe), Fi = Y(oe), Li = Y(Re), Ni = Y(Ce), Ui = Y(Ee), $ = X;
+(Pe && $(new Pe(new ArrayBuffer(1))) != yt || oe && $(new oe()) != lt || Re && $(Re.resolve()) != pt || Ce && $(new Ce()) != dt || Ee && $(new Ee()) != ht) && ($ = function(e) {
+  var t = X(e), r = t == zi ? e.constructor : void 0, n = r ? Y(r) : "";
+  if (n)
+    switch (n) {
+      case Di:
+        return yt;
+      case Fi:
+        return lt;
+      case Li:
+        return pt;
+      case Ni:
+        return dt;
+      case Ui:
+        return ht;
+    }
+  return t;
+});
+var bt = D.Uint8Array, Ki = "__lodash_hash_undefined__";
+function Bi(e) {
+  return this.__data__.set(e, Ki), this;
+}
+function Gi(e) {
+  return this.__data__.has(e);
+}
+function he(e) {
+  var t = -1, r = e == null ? 0 : e.length;
+  for (this.__data__ = new L(); ++t < r; )
+    this.add(e[t]);
+}
+he.prototype.add = he.prototype.push = Bi;
+he.prototype.has = Gi;
+function Nt(e, t) {
+  for (var r = -1, n = e == null ? 0 : e.length; ++r < n; )
+    if (t(e[r], r, e))
+      return !0;
+  return !1;
+}
+function Hi(e, t) {
+  return e.has(t);
+}
+var Wi = 1, Vi = 2;
+function Ut(e, t, r, n, i, s) {
+  var o = r & Wi, c = e.length, a = t.length;
+  if (c != a && !(o && a > c))
+    return !1;
+  var f = s.get(e), u = s.get(t);
+  if (f && u)
+    return f == t && u == e;
+  var l = -1, p = !0, b = r & Vi ? new he() : void 0;
+  for (s.set(e, t), s.set(t, e); ++l < c; ) {
+    var v = e[l], S = t[l];
+    if (n)
+      var _ = o ? n(S, v, l, t, e, s) : n(v, S, l, e, t, s);
+    if (_ !== void 0) {
+      if (_)
+        continue;
+      p = !1;
+      break;
+    }
+    if (b) {
+      if (!Nt(t, function(w, g) {
+        if (!Hi(b, g) && (v === w || i(v, w, r, n, s)))
+          return b.push(g);
+      })) {
+        p = !1;
+        break;
+      }
+    } else if (!(v === S || i(v, S, r, n, s))) {
+      p = !1;
+      break;
+    }
+  }
+  return s.delete(e), s.delete(t), p;
+}
+function qi(e) {
+  var t = -1, r = Array(e.size);
+  return e.forEach(function(n, i) {
+    r[++t] = [i, n];
+  }), r;
+}
+function Xi(e) {
+  var t = -1, r = Array(e.size);
+  return e.forEach(function(n) {
+    r[++t] = n;
+  }), r;
+}
+var Yi = 1, Ji = 2, Zi = "[object Boolean]", Qi = "[object Date]", ki = "[object Error]", es = "[object Map]", ts = "[object Number]", rs = "[object RegExp]", ns = "[object Set]", is = "[object String]", ss = "[object Symbol]", os = "[object ArrayBuffer]", as = "[object DataView]", gt = B ? B.prototype : void 0, Ae = gt ? gt.valueOf : void 0;
+function cs(e, t, r, n, i, s, o) {
+  switch (r) {
+    case as:
+      if (e.byteLength != t.byteLength || e.byteOffset != t.byteOffset)
+        return !1;
+      e = e.buffer, t = t.buffer;
+    case os:
+      return !(e.byteLength != t.byteLength || !s(new bt(e), new bt(t)));
+    case Zi:
+    case Qi:
+    case ts:
+      return Ue(+e, +t);
+    case ki:
+      return e.name == t.name && e.message == t.message;
+    case rs:
+    case is:
+      return e == t + "";
+    case es:
+      var c = qi;
+    case ns:
+      var a = n & Yi;
+      if (c || (c = Xi), e.size != t.size && !a)
+        return !1;
+      var f = o.get(e);
+      if (f)
+        return f == t;
+      n |= Ji, o.set(e, t);
+      var u = Ut(c(e), c(t), n, i, s, o);
+      return o.delete(e), u;
+    case ss:
+      if (Ae)
+        return Ae.call(e) == Ae.call(t);
+  }
+  return !1;
+}
+var fs = 1, us = Object.prototype, ls = us.hasOwnProperty;
+function ps(e, t, r, n, i, s) {
+  var o = r & fs, c = ut(e), a = c.length, f = ut(t), u = f.length;
+  if (a != u && !o)
+    return !1;
+  for (var l = a; l--; ) {
+    var p = c[l];
+    if (!(o ? p in t : ls.call(t, p)))
+      return !1;
+  }
+  var b = s.get(e), v = s.get(t);
+  if (b && v)
+    return b == t && v == e;
+  var S = !0;
+  s.set(e, t), s.set(t, e);
+  for (var _ = o; ++l < a; ) {
+    p = c[l];
+    var w = e[p], g = t[p];
+    if (n)
+      var A = o ? n(g, w, p, t, e, s) : n(w, g, p, e, t, s);
+    if (!(A === void 0 ? w === g || i(w, g, r, n, s) : A)) {
+      S = !1;
+      break;
+    }
+    _ || (_ = p == "constructor");
+  }
+  if (S && !_) {
+    var G = e.constructor, h = t.constructor;
+    G != h && "constructor" in e && "constructor" in t && !(typeof G == "function" && G instanceof G && typeof h == "function" && h instanceof h) && (S = !1);
+  }
+  return s.delete(e), s.delete(t), S;
+}
+var ds = 1, mt = "[object Arguments]", vt = "[object Array]", ue = "[object Object]", hs = Object.prototype, wt = hs.hasOwnProperty;
+function ys(e, t, r, n, i, s) {
+  var o = T(e), c = T(t), a = o ? vt : $(e), f = c ? vt : $(t);
+  a = a == mt ? ue : a, f = f == mt ? ue : f;
+  var u = a == ue, l = f == ue, p = a == f;
+  if (p && Te(e)) {
+    if (!Te(t))
+      return !1;
+    o = !0, u = !1;
+  }
+  if (p && !u)
+    return s || (s = new j()), o || Dt(e) ? Ut(e, t, r, n, i, s) : cs(e, t, a, r, n, i, s);
+  if (!(r & ds)) {
+    var b = u && wt.call(e, "__wrapped__"), v = l && wt.call(t, "__wrapped__");
+    if (b || v) {
+      var S = b ? e.value() : e, _ = v ? t.value() : t;
+      return s || (s = new j()), i(S, _, r, n, s);
+    }
+  }
+  return p ? (s || (s = new j()), ps(e, t, r, n, i, s)) : !1;
+}
+function _e(e, t, r, n, i) {
+  return e === t ? !0 : e == null || t == null || !W(e) && !W(t) ? e !== e && t !== t : ys(e, t, r, n, _e, i);
+}
+var bs = 1, gs = 2;
+function ms(e, t, r, n) {
+  var i = r.length, s = i;
+  if (e == null)
+    return !s;
+  for (e = Object(e); i--; ) {
+    var o = r[i];
+    if (o[2] ? o[1] !== e[o[0]] : !(o[0] in e))
+      return !1;
+  }
+  for (; ++i < s; ) {
+    o = r[i];
+    var c = o[0], a = e[c], f = o[1];
+    if (o[2]) {
+      if (a === void 0 && !(c in e))
+        return !1;
+    } else {
+      var u = new j(), l;
+      if (!(l === void 0 ? _e(f, a, bs | gs, n, u) : l))
+        return !1;
+    }
+  }
+  return !0;
+}
+function Kt(e) {
+  return e === e && !ie(e);
+}
+function vs(e) {
+  for (var t = Be(e), r = t.length; r--; ) {
+    var n = t[r], i = e[n];
+    t[r] = [n, i, Kt(i)];
+  }
+  return t;
+}
+function Bt(e, t) {
+  return function(r) {
+    return r == null ? !1 : r[e] === t && (t !== void 0 || e in Object(r));
+  };
+}
+function ws(e) {
+  var t = vs(e);
+  return t.length == 1 && t[0][2] ? Bt(t[0][0], t[0][1]) : function(r) {
+    return r === e || ms(r, e, t);
+  };
+}
+function _s(e, t) {
+  return e != null && t in Object(e);
+}
+function Os(e, t, r) {
+  t = We(t, e);
+  for (var n = -1, i = t.length, s = !1; ++n < i; ) {
+    var o = ce(t[n]);
+    if (!(s = e != null && r(e, o)))
+      break;
+    e = e[o];
+  }
+  return s || ++n != i ? s : (i = e == null ? 0 : e.length, !!i && Ke(i) && Ne(o, i) && (T(e) || jt(e)));
+}
+function Ss(e, t) {
+  return e != null && Os(e, t, _s);
+}
+var As = 1, Ms = 2;
+function Es(e, t) {
+  return Ge(e) && Kt(t) ? Bt(ce(e), t) : function(r) {
+    var n = pi(r, e);
+    return n === void 0 && n === t ? Ss(r, e) : _e(t, n, As | Ms);
+  };
+}
+function Gt(e) {
+  return function(t) {
+    return t?.[e];
+  };
+}
+function Ts(e) {
+  return function(t) {
+    return Lt(t, e);
+  };
+}
+function Ps(e) {
+  return Ge(e) ? Gt(ce(e)) : Ts(e);
+}
+function Ht(e) {
+  return typeof e == "function" ? e : e == null ? vr : typeof e == "object" ? T(e) ? Es(e[0], e[1]) : ws(e) : Ps(e);
+}
+function Rs(e) {
+  return function(t, r, n) {
+    for (var i = -1, s = Object(t), o = n(t), c = o.length; c--; ) {
+      var a = o[++i];
+      if (r(s[a], a, s) === !1)
+        break;
+    }
+    return t;
+  };
+}
+var Cs = Rs();
+function xs(e, t) {
+  return e && Cs(e, t, Be);
+}
+function $s(e, t) {
+  return function(r, n) {
+    if (r == null)
+      return r;
+    if (!me(r))
+      return e(r, n);
+    for (var i = r.length, s = -1, o = Object(r); ++s < i && n(o[s], s, o) !== !1; )
+      ;
+    return r;
+  };
+}
+var Wt = $s(xs);
+function js(e, t) {
+  var r = -1, n = me(e) ? Array(e.length) : [];
+  return Wt(e, function(i, s, o) {
+    n[++r] = t(i, s, o);
+  }), n;
+}
+function Is(e, t) {
+  var r = T(e) ? Rt : js;
+  return r(e, Ht(t));
+}
+var zs = "[object String]";
+function Ds(e) {
+  return typeof e == "string" || !T(e) && W(e) && X(e) == zs;
+}
+function Fs(e, t) {
+  return _e(e, t);
+}
+function Ls(e, t, r, n) {
+  if (!ie(e))
+    return e;
+  t = We(t, e);
+  for (var i = -1, s = t.length, o = s - 1, c = e; c != null && ++i < s; ) {
+    var a = ce(t[i]), f = r;
+    if (a === "__proto__" || a === "constructor" || a === "prototype")
+      return e;
+    if (i != o) {
+      var u = c[a];
+      f = void 0, f === void 0 && (f = ie(u) ? u : Ne(t[i + 1]) ? [] : {});
+    }
+    Kr(c, a, f), c = c[a];
+  }
+  return e;
+}
+var Ns = Gt("length"), Vt = "\\ud800-\\udfff", Us = "\\u0300-\\u036f", Ks = "\\ufe20-\\ufe2f", Bs = "\\u20d0-\\u20ff", Gs = Us + Ks + Bs, Hs = "\\ufe0e\\ufe0f", Ws = "[" + Vt + "]", xe = "[" + Gs + "]", $e = "\\ud83c[\\udffb-\\udfff]", Vs = "(?:" + xe + "|" + $e + ")", qt = "[^" + Vt + "]", Xt = "(?:\\ud83c[\\udde6-\\uddff]){2}", Yt = "[\\ud800-\\udbff][\\udc00-\\udfff]", qs = "\\u200d", Jt = Vs + "?", Zt = "[" + Hs + "]?", Xs = "(?:" + qs + "(?:" + [qt, Xt, Yt].join("|") + ")" + Zt + Jt + ")*", Ys = Zt + Jt + Xs, Js = "(?:" + [qt + xe + "?", xe, Xt, Yt, Ws].join("|") + ")", _t = RegExp($e + "(?=" + $e + ")|" + Js + Ys, "g");
+function Zs(e) {
+  for (var t = _t.lastIndex = 0; _t.test(e); )
+    ++t;
+  return t;
+}
+function Qs(e) {
+  return Oi(e) ? Zs(e) : Ns(e);
+}
+function ks(e, t, r) {
+  return e == null ? e : Ls(e, t, r);
+}
+var eo = "[object Map]", to = "[object Set]";
+function ro(e) {
+  if (e == null)
+    return 0;
+  if (me(e))
+    return Ds(e) ? Qs(e) : e.length;
+  var t = $(e);
+  return t == eo || t == to ? e.size : Ft(e).length;
+}
+function no(e, t) {
+  var r;
+  return Wt(e, function(n, i, s) {
+    return r = t(n, i, s), !r;
+  }), !!r;
+}
+function io(e, t, r) {
+  var n = T(e) ? Nt : no;
+  return n(e, Ht(t));
+}
+const m = {
+  Remove: "remove",
+  Replace: "replace",
+  Add: "add"
+}, Qt = Symbol.for("__MUTATIVE_PROXY_DRAFT__"), so = Symbol("__MUTATIVE_RAW_RETURN_SYMBOL__"), pe = Symbol.iterator, E = {
+  mutable: "mutable",
+  immutable: "immutable"
+}, Ve = {};
+function ne(e, t) {
+  return e instanceof Map ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function Ot(e, t) {
+  if (t in e) {
+    let r = Reflect.getPrototypeOf(e);
+    for (; r; ) {
+      const n = Reflect.getOwnPropertyDescriptor(r, t);
+      if (n)
+        return n;
+      r = Reflect.getPrototypeOf(r);
+    }
+  }
+}
+function qe(e) {
+  return Object.getPrototypeOf(e) === Set.prototype;
+}
+function Xe(e) {
+  return Object.getPrototypeOf(e) === Map.prototype;
+}
+function M(e) {
+  var t;
+  return (t = e.copy) !== null && t !== void 0 ? t : e.original;
+}
+function q(e) {
+  return !!d(e);
+}
+function d(e) {
+  return typeof e != "object" ? null : e?.[Qt];
+}
+function Ye(e) {
+  var t;
+  const r = d(e);
+  return r ? (t = r.copy) !== null && t !== void 0 ? t : r.original : e;
+}
+function R(e, t) {
+  if (!e || typeof e != "object")
+    return !1;
+  let r;
+  return Object.getPrototypeOf(e) === Object.prototype || Array.isArray(e) || e instanceof Map || e instanceof Set || !!t?.mark && ((r = t.mark(e, E)) === E.immutable || typeof r == "function");
+}
+function kt(e, t = []) {
+  if (Object.hasOwnProperty.call(e, "key")) {
+    const r = e.parent.copy, n = d(z(r, e.key));
+    if (n !== null && n?.original !== e.original)
+      return null;
+    const i = e.parent.type === 3, s = i ? Array.from(e.parent.setMap.keys()).indexOf(e.key) : e.key;
+    if (!(i && r.size > s || ne(r, s)))
+      return null;
+    t.push(s);
+  }
+  if (e.parent)
+    return kt(e.parent, t);
+  t.reverse();
+  try {
+    oo(e.copy, t);
+  } catch {
+    return null;
+  }
+  return t;
+}
+function Z(e) {
+  return Array.isArray(e) ? 1 : e instanceof Map ? 2 : e instanceof Set ? 3 : 0;
+}
+function z(e, t) {
+  return Z(e) === 2 ? e.get(t) : e[t];
+}
+function fe(e, t, r) {
+  Z(e) === 2 ? e.set(t, r) : e[t] = r;
+}
+function Me(e, t) {
+  const r = d(e);
+  return (r ? M(r) : e)[t];
+}
+function I(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function je(e) {
+  if (e)
+    for (; e.finalities.revoke.length > 0; )
+      e.finalities.revoke.pop()();
+}
+function H(e, t) {
+  return t ? e : [""].concat(e).map((r) => {
+    const n = `${r}`;
+    return n.indexOf("/") === -1 && n.indexOf("~") === -1 ? n : n.replace(/~/g, "~0").replace(/\//g, "~1");
+  }).join("/");
+}
+function oo(e, t) {
+  for (let r = 0; r < t.length - 1; r += 1) {
+    const n = t[r];
+    if (e = z(Z(e) === 3 ? Array.from(e) : e, n), typeof e != "object")
+      throw new Error(`Cannot resolve patch at '${t.join("/")}'.`);
+  }
+  return e;
+}
+function ao(e) {
+  const t = Object.create(Object.getPrototypeOf(e));
+  return Reflect.ownKeys(e).forEach((r) => {
+    let n = Reflect.getOwnPropertyDescriptor(e, r);
+    if (n.enumerable && n.configurable && n.writable) {
+      t[r] = e[r];
+      return;
+    }
+    n.writable || (n.writable = !0, n.configurable = !0), (n.get || n.set) && (n = {
+      configurable: !0,
+      writable: !0,
+      enumerable: n.enumerable,
+      value: e[r]
+    }), Reflect.defineProperty(t, r, n);
+  }), t;
+}
+const co = Object.prototype.propertyIsEnumerable;
+function er(e, t) {
+  let r;
+  if (Array.isArray(e))
+    return Array.prototype.concat.call(e);
+  if (e instanceof Set) {
+    if (!qe(e)) {
+      const n = Object.getPrototypeOf(e).constructor;
+      return new n(e.values());
+    }
+    return Set.prototype.difference ? Set.prototype.difference.call(e, /* @__PURE__ */ new Set()) : new Set(e.values());
+  } else if (e instanceof Map) {
+    if (!Xe(e)) {
+      const n = Object.getPrototypeOf(e).constructor;
+      return new n(e);
+    }
+    return new Map(e);
+  } else if (t?.mark && (r = t.mark(e, E), r !== void 0) && r !== E.mutable) {
+    if (r === E.immutable)
+      return ao(e);
+    if (typeof r == "function") {
+      if (t.enablePatches || t.enableAutoFreeze)
+        throw new Error("You can't use mark and patches or auto freeze together.");
+      return r();
+    }
+    throw new Error(`Unsupported mark result: ${r}`);
+  } else if (typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype) {
+    const n = {};
+    return Object.keys(e).forEach((i) => {
+      n[i] = e[i];
+    }), Object.getOwnPropertySymbols(e).forEach((i) => {
+      co.call(e, i) && (n[i] = e[i]);
+    }), n;
+  } else
+    throw new Error("Please check mark() to ensure that it is a stable marker draftable function.");
+}
+function O(e) {
+  e.copy || (e.copy = er(e.original, e.options));
+}
+function te(e) {
+  if (!R(e))
+    return Ye(e);
+  if (Array.isArray(e))
+    return e.map(te);
+  if (e instanceof Map) {
+    const r = Array.from(e.entries()).map(([n, i]) => [
+      n,
+      te(i)
+    ]);
+    if (!Xe(e)) {
+      const n = Object.getPrototypeOf(e).constructor;
+      return new n(r);
+    }
+    return new Map(r);
+  }
+  if (e instanceof Set) {
+    const r = Array.from(e).map(te);
+    if (!qe(e)) {
+      const n = Object.getPrototypeOf(e).constructor;
+      return new n(r);
+    }
+    return new Set(r);
+  }
+  const t = Object.create(Object.getPrototypeOf(e));
+  for (const r in e)
+    t[r] = te(e[r]);
+  return t;
+}
+function de(e) {
+  return q(e) ? te(e) : e;
+}
+function C(e) {
+  var t;
+  e.assignedMap = (t = e.assignedMap) !== null && t !== void 0 ? t : /* @__PURE__ */ new Map(), e.operated || (e.operated = !0, e.parent && C(e.parent));
+}
+function St() {
+  throw new Error("Cannot modify frozen object");
+}
+function Q(e, t, r, n, i) {
+  {
+    r = r ?? /* @__PURE__ */ new WeakMap(), n = n ?? [], i = i ?? [];
+    const o = r.has(e) ? r.get(e) : e;
+    if (n.length > 0) {
+      const c = n.indexOf(o);
+      if (o && typeof o == "object" && c !== -1)
+        throw n[0] === o ? new Error("Forbids circular reference") : new Error(`Forbids circular reference: ~/${i.slice(0, c).map((a, f) => {
+          if (typeof a == "symbol")
+            return `[${a.toString()}]`;
+          const u = n[f];
+          return typeof a == "object" && (u instanceof Map || u instanceof Set) ? Array.from(u.keys()).indexOf(a) : a;
+        }).join("/")}`);
+      n.push(o), i.push(t);
+    } else
+      n.push(o);
+  }
+  if (Object.isFrozen(e) || q(e)) {
+    n.pop(), i.pop();
+    return;
+  }
+  switch (Z(e)) {
+    case 2:
+      for (const [c, a] of e)
+        Q(c, c, r, n, i), Q(a, c, r, n, i);
+      e.set = e.clear = e.delete = St;
+      break;
+    case 3:
+      for (const c of e)
+        Q(c, c, r, n, i);
+      e.add = e.clear = e.delete = St;
+      break;
+    case 1:
+      Object.freeze(e);
+      let o = 0;
+      for (const c of e)
+        Q(c, o, r, n, i), o += 1;
+      break;
+    default:
+      Object.freeze(e), Object.keys(e).forEach((c) => {
+        const a = e[c];
+        Q(a, c, r, n, i);
+      });
+  }
+  n.pop(), i.pop();
+}
+function Je(e, t) {
+  const r = Z(e);
+  if (r === 0)
+    Reflect.ownKeys(e).forEach((n) => {
+      t(n, e[n], e);
+    });
+  else if (r === 1) {
+    let n = 0;
+    for (const i of e)
+      t(n, i, e), n += 1;
+  } else
+    e.forEach((n, i) => t(i, n, e));
+}
+function tr(e, t, r) {
+  if (q(e) || !R(e, r) || t.has(e) || Object.isFrozen(e))
+    return;
+  const n = e instanceof Set, i = n ? /* @__PURE__ */ new Map() : void 0;
+  if (t.add(e), Je(e, (s, o) => {
+    var c;
+    if (q(o)) {
+      const a = d(o);
+      O(a);
+      const f = !((c = a.assignedMap) === null || c === void 0) && c.size || a.operated ? a.copy : a.original;
+      fe(n ? i : e, s, f);
+    } else
+      tr(o, t, r);
+  }), i) {
+    const s = e, o = Array.from(s);
+    s.clear(), o.forEach((c) => {
+      s.add(i.has(c) ? i.get(c) : c);
+    });
+  }
+}
+function fo(e, t) {
+  const r = e.type === 3 ? e.setMap : e.copy;
+  e.finalities.revoke.length > 1 && e.assignedMap.get(t) && r && tr(z(r, t), e.finalities.handledSet, e.options);
+}
+function Ie(e) {
+  e.type === 3 && e.copy && (e.copy.clear(), e.setMap.forEach((t) => {
+    e.copy.add(Ye(t));
+  }));
+}
+function ze(e, t, r, n) {
+  if (e.operated && e.assignedMap && e.assignedMap.size > 0 && !e.finalized) {
+    if (r && n) {
+      const s = kt(e);
+      s && t(e, s, r, n);
+    }
+    e.finalized = !0;
+  }
+}
+function Ze(e, t, r, n) {
+  const i = d(r);
+  i && (i.callbacks || (i.callbacks = []), i.callbacks.push((s, o) => {
+    var c;
+    const a = e.type === 3 ? e.setMap : e.copy;
+    if (I(z(a, t), r)) {
+      let f = i.original;
+      i.copy && (f = i.copy), Ie(e), ze(e, n, s, o), e.options.enableAutoFreeze && (e.options.updatedValues = (c = e.options.updatedValues) !== null && c !== void 0 ? c : /* @__PURE__ */ new WeakMap(), e.options.updatedValues.set(f, i.original)), fe(a, t, f);
+    }
+  }), e.options.enableAutoFreeze && i.finalities !== e.finalities && (e.options.enableAutoFreeze = !1)), R(r, e.options) && e.finalities.draft.push(() => {
+    const s = e.type === 3 ? e.setMap : e.copy;
+    I(z(s, t), r) && fo(e, t);
+  });
+}
+function uo(e, t, r, n, i) {
+  let { original: s, assignedMap: o, options: c } = e, a = e.copy;
+  a.length < s.length && ([s, a] = [a, s], [r, n] = [n, r]);
+  for (let f = 0; f < s.length; f += 1)
+    if (o.get(f.toString()) && a[f] !== s[f]) {
+      const u = t.concat([f]), l = H(u, i);
+      r.push({
+        op: m.Replace,
+        path: l,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: de(a[f])
+      }), n.push({
+        op: m.Replace,
+        path: l,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: de(s[f])
+      });
+    }
+  for (let f = s.length; f < a.length; f += 1) {
+    const u = t.concat([f]), l = H(u, i);
+    r.push({
+      op: m.Add,
+      path: l,
+      // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+      value: de(a[f])
+    });
+  }
+  if (s.length < a.length) {
+    const { arrayLengthAssignment: f = !0 } = c.enablePatches;
+    if (f) {
+      const u = t.concat(["length"]), l = H(u, i);
+      n.push({
+        op: m.Replace,
+        path: l,
+        value: s.length
+      });
+    } else
+      for (let u = a.length; s.length < u; u -= 1) {
+        const l = t.concat([u - 1]), p = H(l, i);
+        n.push({
+          op: m.Remove,
+          path: p
+        });
+      }
+  }
+}
+function lo({ original: e, copy: t, assignedMap: r }, n, i, s, o) {
+  r.forEach((c, a) => {
+    const f = z(e, a), u = de(z(t, a)), l = c ? ne(e, a) ? m.Replace : m.Add : m.Remove;
+    if (I(f, u) && l === m.Replace)
+      return;
+    const p = n.concat(a), b = H(p, o);
+    i.push(l === m.Remove ? { op: l, path: b } : { op: l, path: b, value: u }), s.push(l === m.Add ? { op: m.Remove, path: b } : l === m.Remove ? { op: m.Add, path: b, value: f } : { op: m.Replace, path: b, value: f });
+  });
+}
+function po({ original: e, copy: t }, r, n, i, s) {
+  let o = 0;
+  e.forEach((c) => {
+    if (!t.has(c)) {
+      const a = r.concat([o]), f = H(a, s);
+      n.push({
+        op: m.Remove,
+        path: f,
+        value: c
+      }), i.unshift({
+        op: m.Add,
+        path: f,
+        value: c
+      });
+    }
+    o += 1;
+  }), o = 0, t.forEach((c) => {
+    if (!e.has(c)) {
+      const a = r.concat([o]), f = H(a, s);
+      n.push({
+        op: m.Add,
+        path: f,
+        value: c
+      }), i.unshift({
+        op: m.Remove,
+        path: f,
+        value: c
+      });
+    }
+    o += 1;
+  });
+}
+function ae(e, t, r, n) {
+  const { pathAsArray: i = !0 } = e.options.enablePatches;
+  switch (e.type) {
+    case 0:
+    case 2:
+      return lo(e, t, r, n, i);
+    case 1:
+      return uo(e, t, r, n, i);
+    case 3:
+      return po(e, t, r, n, i);
+  }
+}
+const ye = (e, t, r = !1) => {
+  if (typeof e == "object" && e !== null && (!R(e, t) || r))
+    throw new Error("Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.");
+}, De = {
+  get size() {
+    return M(d(this)).size;
+  },
+  has(e) {
+    return M(d(this)).has(e);
+  },
+  set(e, t) {
+    const r = d(this), n = M(r);
+    return (!n.has(e) || !I(n.get(e), t)) && (O(r), C(r), r.assignedMap.set(e, !0), r.copy.set(e, t), Ze(r, e, t, ae)), this;
+  },
+  delete(e) {
+    if (!this.has(e))
+      return !1;
+    const t = d(this);
+    return O(t), C(t), t.original.has(e) ? t.assignedMap.set(e, !1) : t.assignedMap.delete(e), t.copy.delete(e), !0;
+  },
+  clear() {
+    const e = d(this);
+    if (this.size) {
+      O(e), C(e), e.assignedMap = /* @__PURE__ */ new Map();
+      for (const [t] of e.original)
+        e.assignedMap.set(t, !1);
+      e.copy.clear();
+    }
+  },
+  forEach(e, t) {
+    const r = d(this);
+    M(r).forEach((n, i) => {
+      e.call(t, this.get(i), i, this);
+    });
+  },
+  get(e) {
+    var t, r;
+    const n = d(this), i = M(n).get(e), s = ((r = (t = n.options).mark) === null || r === void 0 ? void 0 : r.call(t, i, E)) === E.mutable;
+    if (n.options.strict && ye(i, n.options, s), s || n.finalized || !R(i, n.options) || i !== n.original.get(e))
+      return i;
+    const o = Ve.createDraft({
+      original: i,
+      parentDraft: n,
+      key: e,
+      finalities: n.finalities,
+      options: n.options
+    });
+    return O(n), n.copy.set(e, o), o;
+  },
+  keys() {
+    return M(d(this)).keys();
+  },
+  values() {
+    const e = this.keys();
+    return {
+      [pe]: () => this.values(),
+      next: () => {
+        const t = e.next();
+        return t.done ? t : {
+          done: !1,
+          value: this.get(t.value)
+        };
+      }
+    };
+  },
+  entries() {
+    const e = this.keys();
+    return {
+      [pe]: () => this.entries(),
+      next: () => {
+        const t = e.next();
+        if (t.done)
+          return t;
+        const r = this.get(t.value);
+        return {
+          done: !1,
+          value: [t.value, r]
+        };
+      }
+    };
+  },
+  [pe]() {
+    return this.entries();
+  }
+}, ho = Reflect.ownKeys(De), At = (e, t, { isValuesIterator: r }) => () => {
+  var n, i;
+  const s = t.next();
+  if (s.done)
+    return s;
+  const o = s.value;
+  let c = e.setMap.get(o);
+  const a = d(c), f = ((i = (n = e.options).mark) === null || i === void 0 ? void 0 : i.call(n, c, E)) === E.mutable;
+  if (e.options.strict && ye(o, e.options, f), !f && !a && R(o, e.options) && !e.finalized && e.original.has(o)) {
+    const u = Ve.createDraft({
+      original: o,
+      parentDraft: e,
+      key: o,
+      finalities: e.finalities,
+      options: e.options
+    });
+    e.setMap.set(o, u), c = u;
+  } else a && (c = a.proxy);
+  return {
+    done: !1,
+    value: r ? c : [c, c]
+  };
+}, be = {
+  get size() {
+    return d(this).setMap.size;
+  },
+  has(e) {
+    const t = d(this);
+    if (t.setMap.has(e))
+      return !0;
+    O(t);
+    const r = d(e);
+    return !!(r && t.setMap.has(r.original));
+  },
+  add(e) {
+    const t = d(this);
+    return this.has(e) || (O(t), C(t), t.assignedMap.set(e, !0), t.setMap.set(e, e), Ze(t, e, e, ae)), this;
+  },
+  delete(e) {
+    if (!this.has(e))
+      return !1;
+    const t = d(this);
+    O(t), C(t);
+    const r = d(e);
+    return r && t.setMap.has(r.original) ? (t.assignedMap.set(r.original, !1), t.setMap.delete(r.original)) : (!r && t.setMap.has(e) ? t.assignedMap.set(e, !1) : t.assignedMap.delete(e), t.setMap.delete(e));
+  },
+  clear() {
+    if (!this.size)
+      return;
+    const e = d(this);
+    O(e), C(e);
+    for (const t of e.original)
+      e.assignedMap.set(t, !1);
+    e.setMap.clear();
+  },
+  values() {
+    const e = d(this);
+    O(e);
+    const t = e.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.values(),
+      next: At(e, t, { isValuesIterator: !0 })
+    };
+  },
+  entries() {
+    const e = d(this);
+    O(e);
+    const t = e.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.entries(),
+      next: At(e, t, {
+        isValuesIterator: !1
+      })
+    };
+  },
+  keys() {
+    return this.values();
+  },
+  [pe]() {
+    return this.values();
+  },
+  forEach(e, t) {
+    const r = this.values();
+    let n = r.next();
+    for (; !n.done; )
+      e.call(t, n.value, n.value, this), n = r.next();
+  }
+};
+Set.prototype.difference && Object.assign(be, {
+  intersection(e) {
+    return Set.prototype.intersection.call(new Set(this.values()), e);
+  },
+  union(e) {
+    return Set.prototype.union.call(new Set(this.values()), e);
+  },
+  difference(e) {
+    return Set.prototype.difference.call(new Set(this.values()), e);
+  },
+  symmetricDifference(e) {
+    return Set.prototype.symmetricDifference.call(new Set(this.values()), e);
+  },
+  isSubsetOf(e) {
+    return Set.prototype.isSubsetOf.call(new Set(this.values()), e);
+  },
+  isSupersetOf(e) {
+    return Set.prototype.isSupersetOf.call(new Set(this.values()), e);
+  },
+  isDisjointFrom(e) {
+    return Set.prototype.isDisjointFrom.call(new Set(this.values()), e);
+  }
+});
+const yo = Reflect.ownKeys(be), rr = /* @__PURE__ */ new WeakSet(), nr = {
+  get(e, t, r) {
+    var n, i;
+    const s = (n = e.copy) === null || n === void 0 ? void 0 : n[t];
+    if (s && rr.has(s))
+      return s;
+    if (t === Qt)
+      return e;
+    let o;
+    if (e.options.mark) {
+      const f = t === "size" && (e.original instanceof Map || e.original instanceof Set) ? Reflect.get(e.original, t) : Reflect.get(e.original, t, r);
+      if (o = e.options.mark(f, E), o === E.mutable)
+        return e.options.strict && ye(f, e.options, !0), f;
+    }
+    const c = M(e);
+    if (c instanceof Map && ho.includes(t)) {
+      if (t === "size")
+        return Object.getOwnPropertyDescriptor(De, "size").get.call(e.proxy);
+      const f = De[t];
+      if (f)
+        return f.bind(e.proxy);
+    }
+    if (c instanceof Set && yo.includes(t)) {
+      if (t === "size")
+        return Object.getOwnPropertyDescriptor(be, "size").get.call(e.proxy);
+      const f = be[t];
+      if (f)
+        return f.bind(e.proxy);
+    }
+    if (!ne(c, t)) {
+      const f = Ot(c, t);
+      return f ? "value" in f ? f.value : (
+        // !case: support for getter
+        (i = f.get) === null || i === void 0 ? void 0 : i.call(e.proxy)
+      ) : void 0;
+    }
+    const a = c[t];
+    if (e.options.strict && ye(a, e.options), e.finalized || !R(a, e.options))
+      return a;
+    if (a === Me(e.original, t)) {
+      if (O(e), e.copy[t] = Qe({
+        original: e.original[t],
+        parentDraft: e,
+        key: e.type === 1 ? Number(t) : t,
+        finalities: e.finalities,
+        options: e.options
+      }), typeof o == "function") {
+        const f = d(e.copy[t]);
+        return O(f), C(f), f.copy;
+      }
+      return e.copy[t];
+    }
+    return a;
+  },
+  set(e, t, r) {
+    var n;
+    if (e.type === 3 || e.type === 2)
+      throw new Error("Map/Set draft does not support any property assignment.");
+    let i;
+    if (e.type === 1 && t !== "length" && !(Number.isInteger(i = Number(t)) && i >= 0 && (t === 0 || i === 0 || String(i) === String(t))))
+      throw new Error("Only supports setting array indices and the 'length' property.");
+    const s = Ot(M(e), t);
+    if (s?.set)
+      return s.set.call(e.proxy, r), !0;
+    const o = Me(M(e), t), c = d(o);
+    return c && I(c.original, r) ? (e.copy[t] = r, e.assignedMap = (n = e.assignedMap) !== null && n !== void 0 ? n : /* @__PURE__ */ new Map(), e.assignedMap.set(t, !1), !0) : (I(r, o) && (r !== void 0 || ne(e.original, t)) || (O(e), C(e), ne(e.original, t) && I(r, e.original[t]) ? e.assignedMap.delete(t) : e.assignedMap.set(t, !0), e.copy[t] = r, Ze(e, t, r, ae)), !0);
+  },
+  has(e, t) {
+    return t in M(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(M(e));
+  },
+  getOwnPropertyDescriptor(e, t) {
+    const r = M(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      writable: !0,
+      configurable: e.type !== 1 || t !== "length",
+      enumerable: n.enumerable,
+      value: r[t]
+    };
+  },
+  getPrototypeOf(e) {
+    return Reflect.getPrototypeOf(e.original);
+  },
+  setPrototypeOf() {
+    throw new Error("Cannot call 'setPrototypeOf()' on drafts");
+  },
+  defineProperty() {
+    throw new Error("Cannot call 'defineProperty()' on drafts");
+  },
+  deleteProperty(e, t) {
+    var r;
+    return e.type === 1 ? nr.set.call(this, e, t, void 0, e.proxy) : (Me(e.original, t) !== void 0 || t in e.original ? (O(e), C(e), e.assignedMap.set(t, !1)) : (e.assignedMap = (r = e.assignedMap) !== null && r !== void 0 ? r : /* @__PURE__ */ new Map(), e.assignedMap.delete(t)), e.copy && delete e.copy[t], !0);
+  }
+};
+function Qe(e) {
+  const { original: t, parentDraft: r, key: n, finalities: i, options: s } = e, o = Z(t), c = {
+    type: o,
+    finalized: !1,
+    parent: r,
+    original: t,
+    copy: null,
+    proxy: null,
+    finalities: i,
+    options: s,
+    // Mapping of draft Set items to their corresponding draft values.
+    setMap: o === 3 ? new Map(t.entries()) : void 0
+  };
+  (n || "key" in e) && (c.key = n);
+  const { proxy: a, revoke: f } = Proxy.revocable(o === 1 ? Object.assign([], c) : c, nr);
+  if (i.revoke.push(f), rr.add(a), c.proxy = a, r) {
+    const u = r;
+    u.finalities.draft.push((l, p) => {
+      var b, v;
+      const S = d(a);
+      let _ = u.type === 3 ? u.setMap : u.copy;
+      const w = z(_, n), g = d(w);
+      if (g) {
+        let A = g.original;
+        g.operated && (A = Ye(w)), Ie(g), ze(g, ae, l, p), u.options.enableAutoFreeze && (u.options.updatedValues = (b = u.options.updatedValues) !== null && b !== void 0 ? b : /* @__PURE__ */ new WeakMap(), u.options.updatedValues.set(A, g.original)), fe(_, n, A);
+      }
+      (v = S.callbacks) === null || v === void 0 || v.forEach((A) => {
+        A(l, p);
+      });
+    });
+  } else {
+    const u = d(a);
+    u.finalities.draft.push((l, p) => {
+      Ie(u), ze(u, ae, l, p);
+    });
+  }
+  return a;
+}
+Ve.createDraft = Qe;
+function bo(e, t, r, n, i) {
+  var s;
+  const o = d(e), c = (s = o?.original) !== null && s !== void 0 ? s : e, a = !!t.length;
+  if (o?.operated)
+    for (; o.finalities.draft.length > 0; )
+      o.finalities.draft.pop()(r, n);
+  const f = a ? t[0] : o ? o.operated ? o.copy : o.original : e;
+  return o && je(o), i && Q(f, f, o?.options.updatedValues), [
+    f,
+    r && a ? [{ op: m.Replace, path: [], value: t[0] }] : r,
+    n && a ? [{ op: m.Replace, path: [], value: c }] : n
+  ];
+}
+function go(e, t) {
+  var r;
+  const n = {
+    draft: [],
+    revoke: [],
+    handledSet: /* @__PURE__ */ new WeakSet()
+  };
+  let i, s;
+  t.enablePatches && (i = [], s = []);
+  const c = ((r = t.mark) === null || r === void 0 ? void 0 : r.call(t, e, E)) === E.mutable || !R(e, t) ? e : Qe({
+    original: e,
+    parentDraft: null,
+    finalities: n,
+    options: t
+  });
+  return [
+    c,
+    (a = []) => {
+      const [f, u, l] = bo(c, a, i, s, t.enableAutoFreeze);
+      return t.enablePatches ? [f, u, l] : f;
+    }
+  ];
+}
+function Fe(e) {
+  const { rootDraft: t, value: r, useRawReturn: n = !1, isRoot: i = !0 } = e;
+  Je(r, (s, o, c) => {
+    const a = d(o);
+    if (a && t && a.finalities === t.finalities) {
+      e.isContainDraft = !0;
+      const f = a.original;
+      if (c instanceof Set) {
+        const u = Array.from(c);
+        c.clear(), u.forEach((l) => c.add(s === l ? f : l));
+      } else
+        fe(c, s, f);
+    } else typeof o == "object" && o !== null && (e.value = o, e.isRoot = !1, Fe(e));
+  }), i && (e.isContainDraft || console.warn("The return value does not contain any draft, please use 'rawReturn()' to wrap the return value to improve performance."), n && console.warn("The return value contains drafts, please don't use 'rawReturn()' to wrap the return value."));
+}
+function ir(e) {
+  var t;
+  const r = d(e);
+  if (!R(e, r?.options))
+    return e;
+  const n = Z(e);
+  if (r && !r.operated)
+    return r.original;
+  let i;
+  function s() {
+    i = n === 2 ? Xe(e) ? new Map(e) : new (Object.getPrototypeOf(e)).constructor(e) : n === 3 ? Array.from(r.setMap.values()) : er(e, r?.options);
+  }
+  if (r) {
+    r.finalized = !0;
+    try {
+      s();
+    } finally {
+      r.finalized = !1;
+    }
+  } else
+    i = e;
+  if (Je(i, (o, c) => {
+    if (r && I(z(r.original, o), c))
+      return;
+    const a = ir(c);
+    a !== c && (i === e && s(), fe(i, o, a));
+  }), n === 3) {
+    const o = (t = r?.original) !== null && t !== void 0 ? t : i;
+    return qe(o) ? new Set(i) : new (Object.getPrototypeOf(o)).constructor(i);
+  }
+  return i;
+}
+function Mt(e) {
+  if (!q(e))
+    throw new Error(`current() is only used for Draft, parameter: ${e}`);
+  return ir(e);
+}
+const mo = (e) => function t(r, n, i) {
+  var s, o, c;
+  if (typeof r == "function" && typeof n != "function")
+    return function(h, ...x) {
+      return t(h, (N) => r.call(this, N, ...x), n);
+    };
+  const a = r, f = n;
+  let u = i;
+  if (typeof n != "function" && (u = n), u !== void 0 && Object.prototype.toString.call(u) !== "[object Object]")
+    throw new Error(`Invalid options: ${u}, 'options' should be an object.`);
+  u = Object.assign(Object.assign({}, e), u);
+  const l = q(a) ? Mt(a) : a, p = Array.isArray(u.mark) ? ((h, x) => {
+    for (const N of u.mark) {
+      if (typeof N != "function")
+        throw new Error(`Invalid mark: ${N}, 'mark' should be a function.`);
+      const k = N(h, x);
+      if (k)
+        return k;
+    }
+  }) : u.mark, b = (s = u.enablePatches) !== null && s !== void 0 ? s : !1, v = (o = u.strict) !== null && o !== void 0 ? o : !1, _ = {
+    enableAutoFreeze: (c = u.enableAutoFreeze) !== null && c !== void 0 ? c : !1,
+    mark: p,
+    strict: v,
+    enablePatches: b
+  };
+  if (!R(l, _) && typeof l == "object" && l !== null)
+    throw new Error("Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.");
+  const [w, g] = go(l, _);
+  if (typeof n != "function") {
+    if (!R(l, _))
+      throw new Error("Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.");
+    return [w, g];
+  }
+  let A;
+  try {
+    A = f(w);
+  } catch (h) {
+    throw je(d(w)), h;
+  }
+  const G = (h) => {
+    const x = d(w);
+    if (!q(h)) {
+      if (h !== void 0 && !I(h, w) && x?.operated)
+        throw new Error("Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.");
+      const k = h?.[so];
+      if (k) {
+        const or = k[0];
+        return _.strict && typeof h == "object" && h !== null && Fe({
+          rootDraft: x,
+          value: h,
+          useRawReturn: !0
+        }), g([or]);
+      }
+      if (h !== void 0)
+        return typeof h == "object" && h !== null && Fe({ rootDraft: x, value: h }), g([h]);
+    }
+    if (h === w || h === void 0)
+      return g([]);
+    const N = d(h);
+    if (_ === N.options) {
+      if (N.operated)
+        throw new Error("Cannot return a modified child draft.");
+      return g([Mt(h)]);
+    }
+    return g([h]);
+  };
+  return A instanceof Promise ? A.then(G, (h) => {
+    throw je(d(w)), h;
+  }) : G(A);
+}, P = mo();
+Object.prototype.constructor.toString();
+const vo = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+let wo = (e = 21) => {
+  let t = "", r = crypto.getRandomValues(new Uint8Array(e |= 0));
+  for (; e--; )
+    t += vo[r[e] & 63];
+  return t;
+};
+function ge(e = "log", ...t) {
+}
+class _o {
+  age = 0;
+  capacity = 0;
+  storage = /* @__PURE__ */ new Map();
+  constructor(t = 0, r = 0) {
+    this.age = t, this.capacity = r;
+  }
+  invalidate() {
+    this.storage.clear();
+  }
+  reset(t, r) {
+    this.invalidate(), this.age = t, this.capacity = r;
+  }
+  get(t) {
+    if (this.capacity === 0) return;
+    const r = this.storage.get(t);
+    if (r)
+      if (Date.now() - r.ts > this.age) {
+        this.storage.delete(t);
+        return;
+      } else
+        return r.data;
+  }
+  put(t, r) {
+    if (this.capacity > 0 && this.storage.set(t, { data: r, ts: Date.now() }), this.storage.size > this.capacity) {
+      const n = [...this.storage.keys()].at(0);
+      this.storage.delete(n);
+    }
+  }
+  remove(t) {
+    this.storage.delete(t);
+  }
+  withCache = async (t, r) => {
+    const n = this.get(t);
+    return n || r().then((i) => (this.put(t, i), i));
+  };
+}
+function Oo(e, t) {
+  return new Promise((r, n) => {
+    function i() {
+      ge("delay", "Fetch operation canceled due to debounce re-entry"), n("DEBOUNCE_CANCELLED");
+    }
+    t.addEventListener("abort", i), setTimeout(() => {
+      t.removeEventListener("abort", i), r("");
+    }, e);
+  });
+}
+class K {
+  id = "<none>";
+  batched = !1;
+  state = {
+    items: /* @__PURE__ */ new Map(),
+    fetchState: {
+      isLoading: !1,
+      errors: [],
+      metadata: {}
+    }
+  };
+  options = { initialData: [] };
+  subscribers = /* @__PURE__ */ new Set();
+  controllers = /* @__PURE__ */ new Map();
+  fetchController = new AbortController();
+  fetchCache = new _o();
+  constructor(t, r = { initialData: [] }) {
+    this.id = t, this.options = r;
+    const { initialData: n = [], caching: i } = r;
+    this.setItems(n), this.fetchCache.reset(i?.age || 0, i?.capacity || 0);
+  }
+  getCacheKey(t) {
+    return `[${this.id}, ${JSON.stringify(t)}]`;
+  }
+  batch = (t) => {
+    this.batched = !0, t(), this.batched = !1, this.notify();
+  };
+  setItems = (t) => {
+    const r = /* @__PURE__ */ new Map();
+    t.forEach((n) => {
+      r.set(n.id, {
+        data: n,
+        state: "idle",
+        optimistic: !1,
+        errors: []
+      });
+    }), this.state = P(this.state, (n) => {
+      n.items = r;
+    }), this.notify();
+  };
+  setMetadata = (t) => {
+    this.state = P(this.state, (r) => {
+      r.fetchState.metadata = t;
+    }), this.notify();
+  };
+  remove = (t) => {
+    this.state = P(this.state, (r) => {
+      r.items.delete(t);
+    }), this.notify();
+  };
+  updateItem = (t) => {
+    this.state = P(this.state, (r) => {
+      const n = r.items.get(t.id);
+      n && (ks(n, "data", t), this.notify());
+    });
+  };
+  clearFetchCache = (t) => {
+    this.fetchCache.remove(this.getCacheKey(t));
+  };
+  startFetch = () => {
+    this.fetchController.abort(), this.state = P(this.state, (t) => {
+      t.fetchState.isLoading = !0;
+    }), this.fetchController = new AbortController(), this.notify();
+  };
+  endFetch = (t = []) => {
+    this.state = P(this.state, (r) => {
+      r.fetchState.isLoading = !1, r.fetchState.errors = t;
+    }), this.notify();
+  };
+  executeFetch = async (t, r) => {
+    const n = this.getCacheKey(t);
+    this.startFetch();
+    try {
+      let i = null;
+      r ? i = await this.fetchCache.withCache(n, async () => (await Oo(this.options.debounce || 0, this.fetchController.signal), ge("fetch execution", "Executing fetch function"), r({
+        signal: this.fetchController.signal,
+        context: t
+      }))) : i = { items: [], metadata: {} }, this.batch(() => {
+        this.setItems(i.items), this.setMetadata(i.metadata), this.endFetch();
+      });
+    } catch (i) {
+      if (i === "DEBOUNCE_CANCELLED")
+        return;
+      if (i.name === "AbortError") {
+        ge("fetch exception", "Fetch operation was cancelled by client"), this.endFetch();
+        return;
+      }
+      this.batch(() => {
+        this.endFetch([i.message]), this.setItems([]);
+      });
+    }
+  };
+  executeRemove = async (t, r, n) => {
+    const i = this.startTransition({
+      id: t.id,
+      input: t,
+      state: "delete"
+    });
+    if (n)
+      try {
+        await n(t, { signal: i.signal, context: r }), this.remove(t.id), this.startTransition({ id: t.id, state: "idle" });
+      } catch (s) {
+        if (s.name === "AbortError")
+          throw this.controllers.delete(t.id), this.state = P(this.state, (o) => {
+            const c = o.items.get(t.id);
+            c && (c.state = "idle", c.input = void 0, c.errors = []);
+          }), this.notify(), s;
+        this.startTransition({
+          id: t.id,
+          input: t,
+          state: "delete",
+          errors: [s.message]
+        });
+      }
+    else
+      this.remove(t.id), this.startTransition({ id: t.id, state: "idle" });
+    this.fetchCache.remove(this.getCacheKey(r));
+  };
+  executeUpdate = async (t, r, n, i, s = !1) => {
+    const o = t.id;
+    if (this.state.items.has(o)) {
+      const c = this.state.items.get(o), a = P(c.data, n), f = this.startTransition({
+        id: o,
+        input: a,
+        state: "update",
+        isOptimistic: s
+      });
+      if (s && this.updateItem(a), i)
+        try {
+          await i(a, { signal: f.signal, context: r }), this.updateItem(a), this.startTransition({ id: o, state: "idle" });
+        } catch (u) {
+          if (u.name === "AbortError") {
+            this.updateItem(c.data), this.startTransition({ id: a.id, state: "idle" });
+            return;
+          }
+          this.startTransition({
+            id: o,
+            input: a,
+            state: "error",
+            errors: [u.message]
+          });
+        }
+      else
+        this.updateItem(a), this.startTransition({ id: o, state: "idle" });
+      this.fetchCache.remove(this.getCacheKey(r));
+    }
+  };
+  executeCreate = async (t, r, n) => {
+    const i = `create_${wo(8)}`, s = { ...r, id: i }, o = (a) => {
+      this.state = P(this.state, (f) => {
+        const u = {
+          data: { ...r, id: a || i },
+          errors: [],
+          optimistic: !0,
+          // always true for create
+          state: "create",
+          input: s
+        };
+        f.items.set(a || i, u);
+      }), this.notify();
+    };
+    o();
+    const c = this.startTransition({
+      id: i,
+      input: s,
+      state: "create",
+      isOptimistic: !0,
+      errors: []
+    });
+    if (n)
+      try {
+        const { id: a } = await n(r, {
+          signal: c.signal,
+          context: t
+        });
+        if (this.state.items.has(i)) {
+          const f = /* @__PURE__ */ new Map();
+          this.state.items.forEach((u, l) => {
+            l === i ? (f.delete(i), f.set(a, {
+              ...u,
+              data: { ...u.data, id: a }
+            })) : f.set(l, u);
+          }), this.state = P(this.state, (u) => {
+            u.items = f;
+          }), this.startTransition({ id: a, state: "idle" });
+        } else
+          o(a), this.startTransition({ id: a, state: "idle" });
+      } catch (a) {
+        if (a.name === "AbortError") {
+          this.remove(i), this.startTransition({ id: r.id, state: "idle" });
+          return;
+        }
+        this.startTransition({
+          id: i,
+          input: s,
+          state: "create",
+          errors: [a.message]
+        });
+      }
+    else
+      o(), this.startTransition({ id: i, state: "idle" });
+    this.fetchCache.remove(this.getCacheKey(t));
+  };
+  startTransition = ({
+    id: t,
+    input: r = void 0,
+    state: n,
+    isOptimistic: i = !1,
+    errors: s = []
+  }) => {
+    const o = new AbortController();
+    return this.state.items.has(t) && (this.controllers.get(t)?.abort(), this.controllers.set(t, o), this.state = P(this.state, (c) => {
+      const a = c.items.get(t);
+      a.state = n, a.optimistic = i, a.errors = n === "idle" ? [] : s, a.input = n == "idle" ? void 0 : r;
+    }), this.notify()), o;
+  };
+  cancelFetch = () => {
+    this.fetchController.abort();
+  };
+  cancelOperation = (t) => {
+    this.controllers.get(t)?.abort();
+  };
+  notify = () => {
+    this.subscribers.forEach((t) => {
+      t();
+    });
+  };
+  getSnapshot = () => this.state;
+  subscribe = (t) => (this.subscribers.add(t), () => {
+    this.subscribers.delete(t);
+  });
+  static instances = /* @__PURE__ */ new Map();
+  static createStore(t) {
+    const { id: r, caching: n = { age: 0, capacity: 0 }, debounce: i = 0, initialData: s = [] } = t;
+    return K.instances.has(r) || K.instances.set(r, new K(r, { initialData: s, caching: n, debounce: i })), K.instances.get(r);
+  }
+}
+const sr = (e) => {
+  const t = Et(e);
+  return le(() => (Fs(e, t.current) || (t.current = e), t.current), [e]);
+};
+function So(e) {
+  const t = Et(e), r = sr(e.context), n = U(() => {
+    const l = K.instances.get(e.id);
+    return l || console.error("Store not found, are you sure you used useCrud with config id = ", e.id), l;
+  }, [e.id]), i = U(() => {
+    n()?.executeFetch(r, t.current.fetch);
+  }, [r, n]), s = U(() => {
+    const l = n();
+    l.clearFetchCache(r), l.executeFetch(r, t.current.fetch);
+  }, [r, n]), o = U(
+    (l) => {
+      n().executeCreate(r, l, t.current.create);
+    },
+    [r, n]
+  ), c = U(
+    (l, p, b = !1) => {
+      n().executeUpdate(l, r, p, t.current.update, b);
+    },
+    [r, n]
+  ), a = U(
+    (l) => {
+      n().executeRemove(l, r, t.current.remove);
+    },
+    [r, n]
+  ), f = U(() => {
+    n().cancelFetch();
+  }, [n]), u = U(
+    (l) => {
+      n().cancelOperation(l);
+    },
+    [n]
+  );
+  return {
+    fetch: i,
+    refetch: s,
+    create: o,
+    update: c,
+    remove: a,
+    cancelFetch: f,
+    cancelOperation: u
+  };
+}
+function Mo(e) {
+  const t = le(
+    () => K.createStore({
+      id: e.id,
+      initialData: [],
+      caching: e.caching,
+      debounce: e.debounce
+    }),
+    [e]
+  ), { fetch: r, create: n, update: i, remove: s, cancelOperation: o, cancelFetch: c } = So(e), a = ar(t.subscribe, t.getSnapshot, e.getServerSnapshot), f = sr(e.context);
+  cr(() => {
+    r();
+  }, [e.id, f]);
+  const u = le(() => Is([...a.items.values()], (p) => ({
+    ...p,
+    id: p.data.id
+  })), [a.items]), l = le(
+    () => ({
+      itemsById: a.items,
+      items: u,
+      metadata: a.fetchState.metadata,
+      isLoading: a.fetchState.isLoading,
+      hasError: ro(a.fetchState.errors) > 0 || io(u, (p) => p.errors.length > 0),
+      errors: a.fetchState.errors,
+      create: n,
+      update: i,
+      remove: s,
+      cancelFetch: c,
+      cancelOperation: o
+    }),
+    [
+      a.items,
+      a.fetchState.metadata,
+      a.fetchState.isLoading,
+      a.fetchState.errors,
+      u,
+      n,
+      i,
+      s,
+      c,
+      o
+    ]
+  );
+  return ge("snapshot", l), l;
+}
+export {
+  _o as FetchCache,
+  ge as customLog,
+  Mo as useCrud,
+  So as useCrudOperations,
+  sr as useMemoDeepEquals
+};