use-abcd 0.2.1 → 1.0.1

package/dist/index.js

@@ -0,0 +1,2263 @@
+import { useSyncExternalStore as ue, useCallback as Xe } from "react";
+import { c as io } from "./chunks/types-Dy4rYb2N.js";
+import { c as oo, b as ao, a as co, f as uo, d as fo, s as lo } from "./chunks/client-VrsFvEIA.js";
+const g = {
+  Remove: "remove",
+  Replace: "replace",
+  Add: "add"
+}, Ot = Symbol.for("__MUTATIVE_PROXY_DRAFT__"), Xt = Symbol("__MUTATIVE_RAW_RETURN_SYMBOL__"), fe = Symbol.iterator, C = {
+  mutable: "mutable",
+  immutable: "immutable"
+}, De = {};
+function te(e, t) {
+  return e instanceof Map ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function Ye(e, t) {
+  if (t in e) {
+    let n = Reflect.getPrototypeOf(e);
+    for (; n; ) {
+      const r = Reflect.getOwnPropertyDescriptor(n, t);
+      if (r)
+        return r;
+      n = Reflect.getPrototypeOf(n);
+    }
+  }
+}
+function He(e) {
+  return Object.getPrototypeOf(e) === Set.prototype;
+}
+function Ne(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 !!h(e);
+}
+function h(e) {
+  return typeof e != "object" ? null : e?.[Ot];
+}
+function Le(e) {
+  var t;
+  const n = h(e);
+  return n ? (t = n.copy) !== null && t !== void 0 ? t : n.original : e;
+}
+function E(e, t) {
+  if (!e || typeof e != "object")
+    return !1;
+  let n;
+  return Object.getPrototypeOf(e) === Object.prototype || Array.isArray(e) || e instanceof Map || e instanceof Set || !!t?.mark && ((n = t.mark(e, C)) === C.immutable || typeof n == "function");
+}
+function At(e, t = []) {
+  if (Object.hasOwnProperty.call(e, "key")) {
+    const n = e.parent.copy, r = h(F(n, e.key));
+    if (r !== null && r?.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 && n.size > s || te(n, s)))
+      return null;
+    t.push(s);
+  }
+  if (e.parent)
+    return At(e.parent, t);
+  t.reverse();
+  try {
+    Yt(e.copy, t);
+  } catch {
+    return null;
+  }
+  return t;
+}
+function Q(e) {
+  return Array.isArray(e) ? 1 : e instanceof Map ? 2 : e instanceof Set ? 3 : 0;
+}
+function F(e, t) {
+  return Q(e) === 2 ? e.get(t) : e[t];
+}
+function ae(e, t, n) {
+  Q(e) === 2 ? e.set(t, n) : e[t] = n;
+}
+function Oe(e, t) {
+  const n = h(e);
+  return (n ? M(n) : e)[t];
+}
+function j(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function Pe(e) {
+  if (e)
+    for (; e.finalities.revoke.length > 0; )
+      e.finalities.revoke.pop()();
+}
+function B(e, t) {
+  return t ? e : [""].concat(e).map((n) => {
+    const r = `${n}`;
+    return r.indexOf("/") === -1 && r.indexOf("~") === -1 ? r : r.replace(/~/g, "~0").replace(/\//g, "~1");
+  }).join("/");
+}
+function Yt(e, t) {
+  for (let n = 0; n < t.length - 1; n += 1) {
+    const r = t[n];
+    if (e = F(Q(e) === 3 ? Array.from(e) : e, r), typeof e != "object")
+      throw new Error(`Cannot resolve patch at '${t.join("/")}'.`);
+  }
+  return e;
+}
+function Vt(e) {
+  const t = Object.create(Object.getPrototypeOf(e));
+  return Reflect.ownKeys(e).forEach((n) => {
+    let r = Reflect.getOwnPropertyDescriptor(e, n);
+    if (r.enumerable && r.configurable && r.writable) {
+      t[n] = e[n];
+      return;
+    }
+    r.writable || (r.writable = !0, r.configurable = !0), (r.get || r.set) && (r = {
+      configurable: !0,
+      writable: !0,
+      enumerable: r.enumerable,
+      value: e[n]
+    }), Reflect.defineProperty(t, n, r);
+  }), t;
+}
+const Zt = Object.prototype.propertyIsEnumerable;
+function Mt(e, t) {
+  let n;
+  if (Array.isArray(e))
+    return Array.prototype.concat.call(e);
+  if (e instanceof Set) {
+    if (!He(e)) {
+      const r = Object.getPrototypeOf(e).constructor;
+      return new r(e.values());
+    }
+    return Set.prototype.difference ? Set.prototype.difference.call(e, /* @__PURE__ */ new Set()) : new Set(e.values());
+  } else if (e instanceof Map) {
+    if (!Ne(e)) {
+      const r = Object.getPrototypeOf(e).constructor;
+      return new r(e);
+    }
+    return new Map(e);
+  } else if (t?.mark && (n = t.mark(e, C), n !== void 0) && n !== C.mutable) {
+    if (n === C.immutable)
+      return Vt(e);
+    if (typeof n == "function") {
+      if (t.enablePatches || t.enableAutoFreeze)
+        throw new Error("You can't use mark and patches or auto freeze together.");
+      return n();
+    }
+    throw new Error(`Unsupported mark result: ${n}`);
+  } else if (typeof e == "object" && Object.getPrototypeOf(e) === Object.prototype) {
+    const r = {};
+    return Object.keys(e).forEach((i) => {
+      r[i] = e[i];
+    }), Object.getOwnPropertySymbols(e).forEach((i) => {
+      Zt.call(e, i) && (r[i] = e[i]);
+    }), r;
+  } else
+    throw new Error("Please check mark() to ensure that it is a stable marker draftable function.");
+}
+function S(e) {
+  e.copy || (e.copy = Mt(e.original, e.options));
+}
+function ee(e) {
+  if (!E(e))
+    return Le(e);
+  if (Array.isArray(e))
+    return e.map(ee);
+  if (e instanceof Map) {
+    const n = Array.from(e.entries()).map(([r, i]) => [
+      r,
+      ee(i)
+    ]);
+    if (!Ne(e)) {
+      const r = Object.getPrototypeOf(e).constructor;
+      return new r(n);
+    }
+    return new Map(n);
+  }
+  if (e instanceof Set) {
+    const n = Array.from(e).map(ee);
+    if (!He(e)) {
+      const r = Object.getPrototypeOf(e).constructor;
+      return new r(n);
+    }
+    return new Set(n);
+  }
+  const t = Object.create(Object.getPrototypeOf(e));
+  for (const n in e)
+    t[n] = ee(e[n]);
+  return t;
+}
+function le(e) {
+  return q(e) ? ee(e) : e;
+}
+function x(e) {
+  var t;
+  e.assignedMap = (t = e.assignedMap) !== null && t !== void 0 ? t : /* @__PURE__ */ new Map(), e.operated || (e.operated = !0, e.parent && x(e.parent));
+}
+function Ve() {
+  throw new Error("Cannot modify frozen object");
+}
+function X(e, t, n, r, i) {
+  {
+    n = n ?? /* @__PURE__ */ new WeakMap(), r = r ?? [], i = i ?? [];
+    const o = n.has(e) ? n.get(e) : e;
+    if (r.length > 0) {
+      const a = r.indexOf(o);
+      if (o && typeof o == "object" && a !== -1)
+        throw r[0] === o ? new Error("Forbids circular reference") : new Error(`Forbids circular reference: ~/${i.slice(0, a).map((c, u) => {
+          if (typeof c == "symbol")
+            return `[${c.toString()}]`;
+          const f = r[u];
+          return typeof c == "object" && (f instanceof Map || f instanceof Set) ? Array.from(f.keys()).indexOf(c) : c;
+        }).join("/")}`);
+      r.push(o), i.push(t);
+    } else
+      r.push(o);
+  }
+  if (Object.isFrozen(e) || q(e)) {
+    r.pop(), i.pop();
+    return;
+  }
+  switch (Q(e)) {
+    case 2:
+      for (const [a, c] of e)
+        X(a, a, n, r, i), X(c, a, n, r, i);
+      e.set = e.clear = e.delete = Ve;
+      break;
+    case 3:
+      for (const a of e)
+        X(a, a, n, r, i);
+      e.add = e.clear = e.delete = Ve;
+      break;
+    case 1:
+      Object.freeze(e);
+      let o = 0;
+      for (const a of e)
+        X(a, o, n, r, i), o += 1;
+      break;
+    default:
+      Object.freeze(e), Object.keys(e).forEach((a) => {
+        const c = e[a];
+        X(c, a, n, r, i);
+      });
+  }
+  r.pop(), i.pop();
+}
+function qe(e, t) {
+  const n = Q(e);
+  if (n === 0)
+    Reflect.ownKeys(e).forEach((r) => {
+      t(r, e[r], e);
+    });
+  else if (n === 1) {
+    let r = 0;
+    for (const i of e)
+      t(r, i, e), r += 1;
+  } else
+    e.forEach((r, i) => t(i, r, e));
+}
+function Ct(e, t, n) {
+  if (q(e) || !E(e, n) || t.has(e) || Object.isFrozen(e))
+    return;
+  const r = e instanceof Set, i = r ? /* @__PURE__ */ new Map() : void 0;
+  if (t.add(e), qe(e, (s, o) => {
+    var a;
+    if (q(o)) {
+      const c = h(o);
+      S(c);
+      const u = !((a = c.assignedMap) === null || a === void 0) && a.size || c.operated ? c.copy : c.original;
+      ae(r ? i : e, s, u);
+    } else
+      Ct(o, t, n);
+  }), i) {
+    const s = e, o = Array.from(s);
+    s.clear(), o.forEach((a) => {
+      s.add(i.has(a) ? i.get(a) : a);
+    });
+  }
+}
+function Jt(e, t) {
+  const n = e.type === 3 ? e.setMap : e.copy;
+  e.finalities.revoke.length > 1 && e.assignedMap.get(t) && n && Ct(F(n, t), e.finalities.handledSet, e.options);
+}
+function Te(e) {
+  e.type === 3 && e.copy && (e.copy.clear(), e.setMap.forEach((t) => {
+    e.copy.add(Le(t));
+  }));
+}
+function Ee(e, t, n, r) {
+  if (e.operated && e.assignedMap && e.assignedMap.size > 0 && !e.finalized) {
+    if (n && r) {
+      const s = At(e);
+      s && t(e, s, n, r);
+    }
+    e.finalized = !0;
+  }
+}
+function Ge(e, t, n, r) {
+  const i = h(n);
+  i && (i.callbacks || (i.callbacks = []), i.callbacks.push((s, o) => {
+    var a;
+    const c = e.type === 3 ? e.setMap : e.copy;
+    if (j(F(c, t), n)) {
+      let u = i.original;
+      i.copy && (u = i.copy), Te(e), Ee(e, r, s, o), e.options.enableAutoFreeze && (e.options.updatedValues = (a = e.options.updatedValues) !== null && a !== void 0 ? a : /* @__PURE__ */ new WeakMap(), e.options.updatedValues.set(u, i.original)), ae(c, t, u);
+    }
+  }), e.options.enableAutoFreeze && i.finalities !== e.finalities && (e.options.enableAutoFreeze = !1)), E(n, e.options) && e.finalities.draft.push(() => {
+    const s = e.type === 3 ? e.setMap : e.copy;
+    j(F(s, t), n) && Jt(e, t);
+  });
+}
+function kt(e, t, n, r, i) {
+  let { original: s, assignedMap: o, options: a } = e, c = e.copy;
+  c.length < s.length && ([s, c] = [c, s], [n, r] = [r, n]);
+  for (let u = 0; u < s.length; u += 1)
+    if (o.get(u.toString()) && c[u] !== s[u]) {
+      const f = t.concat([u]), l = B(f, i);
+      n.push({
+        op: g.Replace,
+        path: l,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: le(c[u])
+      }), r.push({
+        op: g.Replace,
+        path: l,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: le(s[u])
+      });
+    }
+  for (let u = s.length; u < c.length; u += 1) {
+    const f = t.concat([u]), l = B(f, i);
+    n.push({
+      op: g.Add,
+      path: l,
+      // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+      value: le(c[u])
+    });
+  }
+  if (s.length < c.length) {
+    const { arrayLengthAssignment: u = !0 } = a.enablePatches;
+    if (u) {
+      const f = t.concat(["length"]), l = B(f, i);
+      r.push({
+        op: g.Replace,
+        path: l,
+        value: s.length
+      });
+    } else
+      for (let f = c.length; s.length < f; f -= 1) {
+        const l = t.concat([f - 1]), d = B(l, i);
+        r.push({
+          op: g.Remove,
+          path: d
+        });
+      }
+  }
+}
+function en({ original: e, copy: t, assignedMap: n }, r, i, s, o) {
+  n.forEach((a, c) => {
+    const u = F(e, c), f = le(F(t, c)), l = a ? te(e, c) ? g.Replace : g.Add : g.Remove;
+    if (j(u, f) && l === g.Replace)
+      return;
+    const d = r.concat(c), y = B(d, o);
+    i.push(l === g.Remove ? { op: l, path: y } : { op: l, path: y, value: f }), s.push(l === g.Add ? { op: g.Remove, path: y } : l === g.Remove ? { op: g.Add, path: y, value: u } : { op: g.Replace, path: y, value: u });
+  });
+}
+function tn({ original: e, copy: t }, n, r, i, s) {
+  let o = 0;
+  e.forEach((a) => {
+    if (!t.has(a)) {
+      const c = n.concat([o]), u = B(c, s);
+      r.push({
+        op: g.Remove,
+        path: u,
+        value: a
+      }), i.unshift({
+        op: g.Add,
+        path: u,
+        value: a
+      });
+    }
+    o += 1;
+  }), o = 0, t.forEach((a) => {
+    if (!e.has(a)) {
+      const c = n.concat([o]), u = B(c, s);
+      r.push({
+        op: g.Add,
+        path: u,
+        value: a
+      }), i.unshift({
+        op: g.Remove,
+        path: u,
+        value: a
+      });
+    }
+    o += 1;
+  });
+}
+function re(e, t, n, r) {
+  const { pathAsArray: i = !0 } = e.options.enablePatches;
+  switch (e.type) {
+    case 0:
+    case 2:
+      return en(e, t, n, r, i);
+    case 1:
+      return kt(e, t, n, r, i);
+    case 3:
+      return tn(e, t, n, r, i);
+  }
+}
+const he = (e, t, n = !1) => {
+  if (typeof e == "object" && e !== null && (!E(e, t) || n))
+    throw new Error("Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.");
+}, xe = {
+  get size() {
+    return M(h(this)).size;
+  },
+  has(e) {
+    return M(h(this)).has(e);
+  },
+  set(e, t) {
+    const n = h(this), r = M(n);
+    return (!r.has(e) || !j(r.get(e), t)) && (S(n), x(n), n.assignedMap.set(e, !0), n.copy.set(e, t), Ge(n, e, t, re)), this;
+  },
+  delete(e) {
+    if (!this.has(e))
+      return !1;
+    const t = h(this);
+    return S(t), x(t), t.original.has(e) ? t.assignedMap.set(e, !1) : t.assignedMap.delete(e), t.copy.delete(e), !0;
+  },
+  clear() {
+    const e = h(this);
+    if (this.size) {
+      S(e), x(e), e.assignedMap = /* @__PURE__ */ new Map();
+      for (const [t] of e.original)
+        e.assignedMap.set(t, !1);
+      e.copy.clear();
+    }
+  },
+  forEach(e, t) {
+    const n = h(this);
+    M(n).forEach((r, i) => {
+      e.call(t, this.get(i), i, this);
+    });
+  },
+  get(e) {
+    var t, n;
+    const r = h(this), i = M(r).get(e), s = ((n = (t = r.options).mark) === null || n === void 0 ? void 0 : n.call(t, i, C)) === C.mutable;
+    if (r.options.strict && he(i, r.options, s), s || r.finalized || !E(i, r.options) || i !== r.original.get(e))
+      return i;
+    const o = De.createDraft({
+      original: i,
+      parentDraft: r,
+      key: e,
+      finalities: r.finalities,
+      options: r.options
+    });
+    return S(r), r.copy.set(e, o), o;
+  },
+  keys() {
+    return M(h(this)).keys();
+  },
+  values() {
+    const e = this.keys();
+    return {
+      [fe]: () => this.values(),
+      next: () => {
+        const t = e.next();
+        return t.done ? t : {
+          done: !1,
+          value: this.get(t.value)
+        };
+      }
+    };
+  },
+  entries() {
+    const e = this.keys();
+    return {
+      [fe]: () => this.entries(),
+      next: () => {
+        const t = e.next();
+        if (t.done)
+          return t;
+        const n = this.get(t.value);
+        return {
+          done: !1,
+          value: [t.value, n]
+        };
+      }
+    };
+  },
+  [fe]() {
+    return this.entries();
+  }
+}, nn = Reflect.ownKeys(xe), Ze = (e, t, { isValuesIterator: n }) => () => {
+  var r, i;
+  const s = t.next();
+  if (s.done)
+    return s;
+  const o = s.value;
+  let a = e.setMap.get(o);
+  const c = h(a), u = ((i = (r = e.options).mark) === null || i === void 0 ? void 0 : i.call(r, a, C)) === C.mutable;
+  if (e.options.strict && he(o, e.options, u), !u && !c && E(o, e.options) && !e.finalized && e.original.has(o)) {
+    const f = De.createDraft({
+      original: o,
+      parentDraft: e,
+      key: o,
+      finalities: e.finalities,
+      options: e.options
+    });
+    e.setMap.set(o, f), a = f;
+  } else c && (a = c.proxy);
+  return {
+    done: !1,
+    value: n ? a : [a, a]
+  };
+}, pe = {
+  get size() {
+    return h(this).setMap.size;
+  },
+  has(e) {
+    const t = h(this);
+    if (t.setMap.has(e))
+      return !0;
+    S(t);
+    const n = h(e);
+    return !!(n && t.setMap.has(n.original));
+  },
+  add(e) {
+    const t = h(this);
+    return this.has(e) || (S(t), x(t), t.assignedMap.set(e, !0), t.setMap.set(e, e), Ge(t, e, e, re)), this;
+  },
+  delete(e) {
+    if (!this.has(e))
+      return !1;
+    const t = h(this);
+    S(t), x(t);
+    const n = h(e);
+    return n && t.setMap.has(n.original) ? (t.assignedMap.set(n.original, !1), t.setMap.delete(n.original)) : (!n && t.setMap.has(e) ? t.assignedMap.set(e, !1) : t.assignedMap.delete(e), t.setMap.delete(e));
+  },
+  clear() {
+    if (!this.size)
+      return;
+    const e = h(this);
+    S(e), x(e);
+    for (const t of e.original)
+      e.assignedMap.set(t, !1);
+    e.setMap.clear();
+  },
+  values() {
+    const e = h(this);
+    S(e);
+    const t = e.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.values(),
+      next: Ze(e, t, { isValuesIterator: !0 })
+    };
+  },
+  entries() {
+    const e = h(this);
+    S(e);
+    const t = e.setMap.keys();
+    return {
+      [Symbol.iterator]: () => this.entries(),
+      next: Ze(e, t, {
+        isValuesIterator: !1
+      })
+    };
+  },
+  keys() {
+    return this.values();
+  },
+  [fe]() {
+    return this.values();
+  },
+  forEach(e, t) {
+    const n = this.values();
+    let r = n.next();
+    for (; !r.done; )
+      e.call(t, r.value, r.value, this), r = n.next();
+  }
+};
+Set.prototype.difference && Object.assign(pe, {
+  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 rn = Reflect.ownKeys(pe), Pt = {
+  get(e, t, n) {
+    var r, i;
+    const s = (r = e.copy) === null || r === void 0 ? void 0 : r[t];
+    if (s && e.finalities.draftsCache.has(s))
+      return s;
+    if (t === Ot)
+      return e;
+    let o;
+    if (e.options.mark) {
+      const u = t === "size" && (e.original instanceof Map || e.original instanceof Set) ? Reflect.get(e.original, t) : Reflect.get(e.original, t, n);
+      if (o = e.options.mark(u, C), o === C.mutable)
+        return e.options.strict && he(u, e.options, !0), u;
+    }
+    const a = M(e);
+    if (a instanceof Map && nn.includes(t))
+      return t === "size" ? Object.getOwnPropertyDescriptor(xe, "size").get.call(e.proxy) : xe[t].bind(e.proxy);
+    if (a instanceof Set && rn.includes(t))
+      return t === "size" ? Object.getOwnPropertyDescriptor(pe, "size").get.call(e.proxy) : pe[t].bind(e.proxy);
+    if (!te(a, t)) {
+      const u = Ye(a, t);
+      return u ? "value" in u ? u.value : (
+        // !case: support for getter
+        (i = u.get) === null || i === void 0 ? void 0 : i.call(e.proxy)
+      ) : void 0;
+    }
+    const c = a[t];
+    if (e.options.strict && he(c, e.options), e.finalized || !E(c, e.options))
+      return c;
+    if (c === Oe(e.original, t)) {
+      if (S(e), e.copy[t] = Ue({
+        original: e.original[t],
+        parentDraft: e,
+        key: e.type === 1 ? Number(t) : t,
+        finalities: e.finalities,
+        options: e.options
+      }), typeof o == "function") {
+        const u = h(e.copy[t]);
+        return S(u), x(u), u.copy;
+      }
+      return e.copy[t];
+    }
+    return q(c) && e.finalities.draftsCache.add(c), c;
+  },
+  set(e, t, n) {
+    var r;
+    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 = Ye(M(e), t);
+    if (s?.set)
+      return s.set.call(e.proxy, n), !0;
+    const o = Oe(M(e), t), a = h(o);
+    return a && j(a.original, n) ? (e.copy[t] = n, e.assignedMap = (r = e.assignedMap) !== null && r !== void 0 ? r : /* @__PURE__ */ new Map(), e.assignedMap.set(t, !1), !0) : (j(n, o) && (n !== void 0 || te(e.original, t)) || (S(e), x(e), te(e.original, t) && j(n, e.original[t]) ? e.assignedMap.delete(t) : e.assignedMap.set(t, !0), e.copy[t] = n, Ge(e, t, n, re)), !0);
+  },
+  has(e, t) {
+    return t in M(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(M(e));
+  },
+  getOwnPropertyDescriptor(e, t) {
+    const n = M(e), r = Reflect.getOwnPropertyDescriptor(n, t);
+    return r && {
+      writable: !0,
+      configurable: e.type !== 1 || t !== "length",
+      enumerable: r.enumerable,
+      value: n[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 n;
+    return e.type === 1 ? Pt.set.call(this, e, t, void 0, e.proxy) : (Oe(e.original, t) !== void 0 || t in e.original ? (S(e), x(e), e.assignedMap.set(t, !1)) : (e.assignedMap = (n = e.assignedMap) !== null && n !== void 0 ? n : /* @__PURE__ */ new Map(), e.assignedMap.delete(t)), e.copy && delete e.copy[t], !0);
+  }
+};
+function Ue(e) {
+  const { original: t, parentDraft: n, key: r, finalities: i, options: s } = e, o = Q(t), a = {
+    type: o,
+    finalized: !1,
+    parent: n,
+    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
+  };
+  (r || "key" in e) && (a.key = r);
+  const { proxy: c, revoke: u } = Proxy.revocable(o === 1 ? Object.assign([], a) : a, Pt);
+  if (i.revoke.push(u), a.proxy = c, n) {
+    const f = n;
+    f.finalities.draft.push((l, d) => {
+      var y, m;
+      const O = h(c);
+      let v = f.type === 3 ? f.setMap : f.copy;
+      const w = F(v, r), b = h(w);
+      if (b) {
+        let A = b.original;
+        b.operated && (A = Le(w)), Te(b), Ee(b, re, l, d), f.options.enableAutoFreeze && (f.options.updatedValues = (y = f.options.updatedValues) !== null && y !== void 0 ? y : /* @__PURE__ */ new WeakMap(), f.options.updatedValues.set(A, b.original)), ae(v, r, A);
+      }
+      (m = O.callbacks) === null || m === void 0 || m.forEach((A) => {
+        A(l, d);
+      });
+    });
+  } else {
+    const f = h(c);
+    f.finalities.draft.push((l, d) => {
+      Te(f), Ee(f, re, l, d);
+    });
+  }
+  return c;
+}
+De.createDraft = Ue;
+function sn(e, t, n, r, i) {
+  var s;
+  const o = h(e), a = (s = o?.original) !== null && s !== void 0 ? s : e, c = !!t.length;
+  if (o?.operated)
+    for (; o.finalities.draft.length > 0; )
+      o.finalities.draft.pop()(n, r);
+  const u = c ? t[0] : o ? o.operated ? o.copy : o.original : e;
+  return o && Pe(o), i && X(u, u, o?.options.updatedValues), [
+    u,
+    n && c ? [{ op: g.Replace, path: [], value: t[0] }] : n,
+    r && c ? [{ op: g.Replace, path: [], value: a }] : r
+  ];
+}
+function on(e, t) {
+  var n;
+  const r = {
+    draft: [],
+    revoke: [],
+    handledSet: /* @__PURE__ */ new WeakSet(),
+    draftsCache: /* @__PURE__ */ new WeakSet()
+  };
+  let i, s;
+  t.enablePatches && (i = [], s = []);
+  const a = ((n = t.mark) === null || n === void 0 ? void 0 : n.call(t, e, C)) === C.mutable || !E(e, t) ? e : Ue({
+    original: e,
+    parentDraft: null,
+    finalities: r,
+    options: t
+  });
+  return [
+    a,
+    (c = []) => {
+      const [u, f, l] = sn(a, c, i, s, t.enableAutoFreeze);
+      return t.enablePatches ? [u, f, l] : u;
+    }
+  ];
+}
+function Re(e) {
+  const { rootDraft: t, value: n, useRawReturn: r = !1, isRoot: i = !0 } = e;
+  qe(n, (s, o, a) => {
+    const c = h(o);
+    if (c && t && c.finalities === t.finalities) {
+      e.isContainDraft = !0;
+      const u = c.original;
+      if (a instanceof Set) {
+        const f = Array.from(a);
+        a.clear(), f.forEach((l) => a.add(s === l ? u : l));
+      } else
+        ae(a, s, u);
+    } else typeof o == "object" && o !== null && (e.value = o, e.isRoot = !1, Re(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."), r && console.warn("The return value contains drafts, please don't use 'rawReturn()' to wrap the return value."));
+}
+function Tt(e) {
+  var t;
+  const n = h(e);
+  if (!E(e, n?.options))
+    return e;
+  const r = Q(e);
+  if (n && !n.operated)
+    return n.original;
+  let i;
+  function s() {
+    i = r === 2 ? Ne(e) ? new Map(e) : new (Object.getPrototypeOf(e)).constructor(e) : r === 3 ? Array.from(n.setMap.values()) : Mt(e, n?.options);
+  }
+  if (n) {
+    n.finalized = !0;
+    try {
+      s();
+    } finally {
+      n.finalized = !1;
+    }
+  } else
+    i = e;
+  if (qe(i, (o, a) => {
+    if (n && j(F(n.original, o), a))
+      return;
+    const c = Tt(a);
+    c !== a && (i === e && s(), ae(i, o, c));
+  }), r === 3) {
+    const o = (t = n?.original) !== null && t !== void 0 ? t : i;
+    return He(o) ? new Set(i) : new (Object.getPrototypeOf(o)).constructor(i);
+  }
+  return i;
+}
+function Je(e) {
+  if (!q(e))
+    throw new Error(`current() is only used for Draft, parameter: ${e}`);
+  return Tt(e);
+}
+const an = (e) => function t(n, r, i) {
+  var s, o, a;
+  if (typeof n == "function" && typeof r != "function")
+    return function(p, ...I) {
+      return t(p, (N) => n.call(this, N, ...I), r);
+    };
+  const c = n, u = r;
+  let f = i;
+  if (typeof r != "function" && (f = r), f !== void 0 && Object.prototype.toString.call(f) !== "[object Object]")
+    throw new Error(`Invalid options: ${f}, 'options' should be an object.`);
+  f = Object.assign(Object.assign({}, e), f);
+  const l = q(c) ? Je(c) : c, d = Array.isArray(f.mark) ? ((p, I) => {
+    for (const N of f.mark) {
+      if (typeof N != "function")
+        throw new Error(`Invalid mark: ${N}, 'mark' should be a function.`);
+      const J = N(p, I);
+      if (J)
+        return J;
+    }
+  }) : f.mark, y = (s = f.enablePatches) !== null && s !== void 0 ? s : !1, m = (o = f.strict) !== null && o !== void 0 ? o : !1, v = {
+    enableAutoFreeze: (a = f.enableAutoFreeze) !== null && a !== void 0 ? a : !1,
+    mark: d,
+    strict: m,
+    enablePatches: y
+  };
+  if (!E(l, v) && 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, b] = on(l, v);
+  if (typeof r != "function") {
+    if (!E(l, v))
+      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, b];
+  }
+  let A;
+  try {
+    A = u(w);
+  } catch (p) {
+    throw Pe(h(w)), p;
+  }
+  const G = (p) => {
+    const I = h(w);
+    if (!q(p)) {
+      if (p !== void 0 && !j(p, w) && I?.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 J = p?.[Xt];
+      if (J) {
+        const Wt = J[0];
+        return v.strict && typeof p == "object" && p !== null && Re({
+          rootDraft: I,
+          value: p,
+          useRawReturn: !0
+        }), b([Wt]);
+      }
+      if (p !== void 0)
+        return typeof p == "object" && p !== null && Re({ rootDraft: I, value: p }), b([p]);
+    }
+    if (p === w || p === void 0)
+      return b([]);
+    const N = h(p);
+    if (v === N.options) {
+      if (N.operated)
+        throw new Error("Cannot return a modified child draft.");
+      return b([Je(p)]);
+    }
+    return b([p]);
+  };
+  return A instanceof Promise ? A.then(G, (p) => {
+    throw Pe(h(w)), p;
+  }) : G(A);
+}, T = an();
+Object.prototype.constructor.toString();
+var Et = typeof global == "object" && global && global.Object === Object && global, cn = typeof self == "object" && self && self.Object === Object && self, z = Et || cn || Function("return this")(), R = z.Symbol, xt = Object.prototype, un = xt.hasOwnProperty, fn = xt.toString, k = R ? R.toStringTag : void 0;
+function ln(e) {
+  var t = un.call(e, k), n = e[k];
+  try {
+    e[k] = void 0;
+    var r = !0;
+  } catch {
+  }
+  var i = fn.call(e);
+  return r && (t ? e[k] = n : delete e[k]), i;
+}
+var hn = Object.prototype, pn = hn.toString;
+function dn(e) {
+  return pn.call(e);
+}
+var _n = "[object Null]", yn = "[object Undefined]", ke = R ? R.toStringTag : void 0;
+function V(e) {
+  return e == null ? e === void 0 ? yn : _n : ke && ke in Object(e) ? ln(e) : dn(e);
+}
+function Y(e) {
+  return e != null && typeof e == "object";
+}
+var bn = "[object Symbol]";
+function _e(e) {
+  return typeof e == "symbol" || Y(e) && V(e) == bn;
+}
+function Rt(e, t) {
+  for (var n = -1, r = e == null ? 0 : e.length, i = Array(r); ++n < r; )
+    i[n] = t(e[n], n, e);
+  return i;
+}
+var P = Array.isArray, et = R ? R.prototype : void 0, tt = et ? et.toString : void 0;
+function It(e) {
+  if (typeof e == "string")
+    return e;
+  if (P(e))
+    return Rt(e, It) + "";
+  if (_e(e))
+    return tt ? tt.call(e) : "";
+  var t = e + "";
+  return t == "0" && 1 / e == -1 / 0 ? "-0" : t;
+}
+var gn = /\s/;
+function mn(e) {
+  for (var t = e.length; t-- && gn.test(e.charAt(t)); )
+    ;
+  return t;
+}
+var wn = /^\s+/;
+function vn(e) {
+  return e && e.slice(0, mn(e) + 1).replace(wn, "");
+}
+function ie(e) {
+  var t = typeof e;
+  return e != null && (t == "object" || t == "function");
+}
+var nt = NaN, Sn = /^[-+]0x[0-9a-f]+$/i, On = /^0b[01]+$/i, An = /^0o[0-7]+$/i, Mn = parseInt;
+function Cn(e) {
+  if (typeof e == "number")
+    return e;
+  if (_e(e))
+    return nt;
+  if (ie(e)) {
+    var t = typeof e.valueOf == "function" ? e.valueOf() : e;
+    e = ie(t) ? t + "" : t;
+  }
+  if (typeof e != "string")
+    return e === 0 ? e : +e;
+  e = vn(e);
+  var n = On.test(e);
+  return n || An.test(e) ? Mn(e.slice(2), n ? 2 : 8) : Sn.test(e) ? nt : +e;
+}
+var rt = 1 / 0, Pn = 17976931348623157e292;
+function Tn(e) {
+  if (!e)
+    return e === 0 ? e : 0;
+  if (e = Cn(e), e === rt || e === -rt) {
+    var t = e < 0 ? -1 : 1;
+    return t * Pn;
+  }
+  return e === e ? e : 0;
+}
+function En(e) {
+  var t = Tn(e), n = t % 1;
+  return t === t ? n ? t - n : t : 0;
+}
+function xn(e) {
+  return e;
+}
+var Rn = "[object AsyncFunction]", In = "[object Function]", jn = "[object GeneratorFunction]", $n = "[object Proxy]";
+function jt(e) {
+  if (!ie(e))
+    return !1;
+  var t = V(e);
+  return t == In || t == jn || t == Rn || t == $n;
+}
+var Ae = z["__core-js_shared__"], it = (function() {
+  var e = /[^.]+$/.exec(Ae && Ae.keys && Ae.keys.IE_PROTO || "");
+  return e ? "Symbol(src)_1." + e : "";
+})();
+function Fn(e) {
+  return !!it && it in e;
+}
+var zn = Function.prototype, Dn = zn.toString;
+function W(e) {
+  if (e != null) {
+    try {
+      return Dn.call(e);
+    } catch {
+    }
+    try {
+      return e + "";
+    } catch {
+    }
+  }
+  return "";
+}
+var Hn = /[\\^$.*+?()[\]{}|]/g, Nn = /^\[object .+?Constructor\]$/, Ln = Function.prototype, qn = Object.prototype, Gn = Ln.toString, Un = qn.hasOwnProperty, Bn = RegExp(
+  "^" + Gn.call(Un).replace(Hn, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function Kn(e) {
+  if (!ie(e) || Fn(e))
+    return !1;
+  var t = jt(e) ? Bn : Nn;
+  return t.test(W(e));
+}
+function Qn(e, t) {
+  return e?.[t];
+}
+function Z(e, t) {
+  var n = Qn(e, t);
+  return Kn(n) ? n : void 0;
+}
+var Ie = Z(z, "WeakMap");
+function Wn(e, t, n, r) {
+  for (var i = e.length, s = n + -1; ++s < i; )
+    if (t(e[s], s, e))
+      return s;
+  return -1;
+}
+var Xn = 9007199254740991, Yn = /^(?:0|[1-9]\d*)$/;
+function $t(e, t) {
+  var n = typeof e;
+  return t = t ?? Xn, !!t && (n == "number" || n != "symbol" && Yn.test(e)) && e > -1 && e % 1 == 0 && e < t;
+}
+function Ft(e, t) {
+  return e === t || e !== e && t !== t;
+}
+var Vn = 9007199254740991;
+function Be(e) {
+  return typeof e == "number" && e > -1 && e % 1 == 0 && e <= Vn;
+}
+function ye(e) {
+  return e != null && Be(e.length) && !jt(e);
+}
+var Zn = Object.prototype;
+function Jn(e) {
+  var t = e && e.constructor, n = typeof t == "function" && t.prototype || Zn;
+  return e === n;
+}
+function kn(e, t) {
+  for (var n = -1, r = Array(e); ++n < e; )
+    r[n] = t(n);
+  return r;
+}
+var er = "[object Arguments]";
+function st(e) {
+  return Y(e) && V(e) == er;
+}
+var zt = Object.prototype, tr = zt.hasOwnProperty, nr = zt.propertyIsEnumerable, Ke = st(/* @__PURE__ */ (function() {
+  return arguments;
+})()) ? st : function(e) {
+  return Y(e) && tr.call(e, "callee") && !nr.call(e, "callee");
+};
+function rr() {
+  return !1;
+}
+var Dt = typeof exports == "object" && exports && !exports.nodeType && exports, ot = Dt && typeof module == "object" && module && !module.nodeType && module, ir = ot && ot.exports === Dt, at = ir ? z.Buffer : void 0, sr = at ? at.isBuffer : void 0, je = sr || rr, or = "[object Arguments]", ar = "[object Array]", cr = "[object Boolean]", ur = "[object Date]", fr = "[object Error]", lr = "[object Function]", hr = "[object Map]", pr = "[object Number]", dr = "[object Object]", _r = "[object RegExp]", yr = "[object Set]", br = "[object String]", gr = "[object WeakMap]", mr = "[object ArrayBuffer]", wr = "[object DataView]", vr = "[object Float32Array]", Sr = "[object Float64Array]", Or = "[object Int8Array]", Ar = "[object Int16Array]", Mr = "[object Int32Array]", Cr = "[object Uint8Array]", Pr = "[object Uint8ClampedArray]", Tr = "[object Uint16Array]", Er = "[object Uint32Array]", _ = {};
+_[vr] = _[Sr] = _[Or] = _[Ar] = _[Mr] = _[Cr] = _[Pr] = _[Tr] = _[Er] = !0;
+_[or] = _[ar] = _[mr] = _[cr] = _[wr] = _[ur] = _[fr] = _[lr] = _[hr] = _[pr] = _[dr] = _[_r] = _[yr] = _[br] = _[gr] = !1;
+function xr(e) {
+  return Y(e) && Be(e.length) && !!_[V(e)];
+}
+function Rr(e) {
+  return function(t) {
+    return e(t);
+  };
+}
+var Ht = typeof exports == "object" && exports && !exports.nodeType && exports, ne = Ht && typeof module == "object" && module && !module.nodeType && module, Ir = ne && ne.exports === Ht, Me = Ir && Et.process, ct = (function() {
+  try {
+    var e = ne && ne.require && ne.require("util").types;
+    return e || Me && Me.binding && Me.binding("util");
+  } catch {
+  }
+})(), ut = ct && ct.isTypedArray, Nt = ut ? Rr(ut) : xr, jr = Object.prototype, $r = jr.hasOwnProperty;
+function Fr(e, t) {
+  var n = P(e), r = !n && Ke(e), i = !n && !r && je(e), s = !n && !r && !i && Nt(e), o = n || r || i || s, a = o ? kn(e.length, String) : [], c = a.length;
+  for (var u in e)
+    $r.call(e, u) && !(o && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (u == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    i && (u == "offset" || u == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    s && (u == "buffer" || u == "byteLength" || u == "byteOffset") || // Skip index properties.
+    $t(u, c))) && a.push(u);
+  return a;
+}
+function zr(e, t) {
+  return function(n) {
+    return e(t(n));
+  };
+}
+var Dr = zr(Object.keys, Object), Hr = Object.prototype, Nr = Hr.hasOwnProperty;
+function Lr(e) {
+  if (!Jn(e))
+    return Dr(e);
+  var t = [];
+  for (var n in Object(e))
+    Nr.call(e, n) && n != "constructor" && t.push(n);
+  return t;
+}
+function be(e) {
+  return ye(e) ? Fr(e) : Lr(e);
+}
+var qr = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, Gr = /^\w*$/;
+function Qe(e, t) {
+  if (P(e))
+    return !1;
+  var n = typeof e;
+  return n == "number" || n == "symbol" || n == "boolean" || e == null || _e(e) ? !0 : Gr.test(e) || !qr.test(e) || t != null && e in Object(t);
+}
+var se = Z(Object, "create");
+function Ur() {
+  this.__data__ = se ? se(null) : {}, this.size = 0;
+}
+function Br(e) {
+  var t = this.has(e) && delete this.__data__[e];
+  return this.size -= t ? 1 : 0, t;
+}
+var Kr = "__lodash_hash_undefined__", Qr = Object.prototype, Wr = Qr.hasOwnProperty;
+function Xr(e) {
+  var t = this.__data__;
+  if (se) {
+    var n = t[e];
+    return n === Kr ? void 0 : n;
+  }
+  return Wr.call(t, e) ? t[e] : void 0;
+}
+var Yr = Object.prototype, Vr = Yr.hasOwnProperty;
+function Zr(e) {
+  var t = this.__data__;
+  return se ? t[e] !== void 0 : Vr.call(t, e);
+}
+var Jr = "__lodash_hash_undefined__";
+function kr(e, t) {
+  var n = this.__data__;
+  return this.size += this.has(e) ? 0 : 1, n[e] = se && t === void 0 ? Jr : t, this;
+}
+function K(e) {
+  var t = -1, n = e == null ? 0 : e.length;
+  for (this.clear(); ++t < n; ) {
+    var r = e[t];
+    this.set(r[0], r[1]);
+  }
+}
+K.prototype.clear = Ur;
+K.prototype.delete = Br;
+K.prototype.get = Xr;
+K.prototype.has = Zr;
+K.prototype.set = kr;
+function ei() {
+  this.__data__ = [], this.size = 0;
+}
+function ge(e, t) {
+  for (var n = e.length; n--; )
+    if (Ft(e[n][0], t))
+      return n;
+  return -1;
+}
+var ti = Array.prototype, ni = ti.splice;
+function ri(e) {
+  var t = this.__data__, n = ge(t, e);
+  if (n < 0)
+    return !1;
+  var r = t.length - 1;
+  return n == r ? t.pop() : ni.call(t, n, 1), --this.size, !0;
+}
+function ii(e) {
+  var t = this.__data__, n = ge(t, e);
+  return n < 0 ? void 0 : t[n][1];
+}
+function si(e) {
+  return ge(this.__data__, e) > -1;
+}
+function oi(e, t) {
+  var n = this.__data__, r = ge(n, e);
+  return r < 0 ? (++this.size, n.push([e, t])) : n[r][1] = t, this;
+}
+function D(e) {
+  var t = -1, n = e == null ? 0 : e.length;
+  for (this.clear(); ++t < n; ) {
+    var r = e[t];
+    this.set(r[0], r[1]);
+  }
+}
+D.prototype.clear = ei;
+D.prototype.delete = ri;
+D.prototype.get = ii;
+D.prototype.has = si;
+D.prototype.set = oi;
+var oe = Z(z, "Map");
+function ai() {
+  this.size = 0, this.__data__ = {
+    hash: new K(),
+    map: new (oe || D)(),
+    string: new K()
+  };
+}
+function ci(e) {
+  var t = typeof e;
+  return t == "string" || t == "number" || t == "symbol" || t == "boolean" ? e !== "__proto__" : e === null;
+}
+function me(e, t) {
+  var n = e.__data__;
+  return ci(t) ? n[typeof t == "string" ? "string" : "hash"] : n.map;
+}
+function ui(e) {
+  var t = me(this, e).delete(e);
+  return this.size -= t ? 1 : 0, t;
+}
+function fi(e) {
+  return me(this, e).get(e);
+}
+function li(e) {
+  return me(this, e).has(e);
+}
+function hi(e, t) {
+  var n = me(this, e), r = n.size;
+  return n.set(e, t), this.size += n.size == r ? 0 : 1, this;
+}
+function H(e) {
+  var t = -1, n = e == null ? 0 : e.length;
+  for (this.clear(); ++t < n; ) {
+    var r = e[t];
+    this.set(r[0], r[1]);
+  }
+}
+H.prototype.clear = ai;
+H.prototype.delete = ui;
+H.prototype.get = fi;
+H.prototype.has = li;
+H.prototype.set = hi;
+var pi = "Expected a function";
+function We(e, t) {
+  if (typeof e != "function" || t != null && typeof t != "function")
+    throw new TypeError(pi);
+  var n = function() {
+    var r = arguments, i = t ? t.apply(this, r) : r[0], s = n.cache;
+    if (s.has(i))
+      return s.get(i);
+    var o = e.apply(this, r);
+    return n.cache = s.set(i, o) || s, o;
+  };
+  return n.cache = new (We.Cache || H)(), n;
+}
+We.Cache = H;
+var di = 500;
+function _i(e) {
+  var t = We(e, function(r) {
+    return n.size === di && n.clear(), r;
+  }), n = t.cache;
+  return t;
+}
+var yi = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, bi = /\\(\\)?/g, gi = _i(function(e) {
+  var t = [];
+  return e.charCodeAt(0) === 46 && t.push(""), e.replace(yi, function(n, r, i, s) {
+    t.push(i ? s.replace(bi, "$1") : r || n);
+  }), t;
+});
+function mi(e) {
+  return e == null ? "" : It(e);
+}
+function Lt(e, t) {
+  return P(e) ? e : Qe(e, t) ? [e] : gi(mi(e));
+}
+function we(e) {
+  if (typeof e == "string" || _e(e))
+    return e;
+  var t = e + "";
+  return t == "0" && 1 / e == -1 / 0 ? "-0" : t;
+}
+function qt(e, t) {
+  t = Lt(t, e);
+  for (var n = 0, r = t.length; e != null && n < r; )
+    e = e[we(t[n++])];
+  return n && n == r ? e : void 0;
+}
+function wi(e, t, n) {
+  var r = e == null ? void 0 : qt(e, t);
+  return r === void 0 ? n : r;
+}
+function Gt(e, t) {
+  for (var n = -1, r = t.length, i = e.length; ++n < r; )
+    e[i + n] = t[n];
+  return e;
+}
+var ft = R ? R.isConcatSpreadable : void 0;
+function vi(e) {
+  return P(e) || Ke(e) || !!(ft && e && e[ft]);
+}
+function Si(e, t, n, r, i) {
+  var s = -1, o = e.length;
+  for (n || (n = vi), i || (i = []); ++s < o; ) {
+    var a = e[s];
+    n(a) ? Gt(i, a) : i[i.length] = a;
+  }
+  return i;
+}
+function Oi() {
+  this.__data__ = new D(), this.size = 0;
+}
+function Ai(e) {
+  var t = this.__data__, n = t.delete(e);
+  return this.size = t.size, n;
+}
+function Mi(e) {
+  return this.__data__.get(e);
+}
+function Ci(e) {
+  return this.__data__.has(e);
+}
+var Pi = 200;
+function Ti(e, t) {
+  var n = this.__data__;
+  if (n instanceof D) {
+    var r = n.__data__;
+    if (!oe || r.length < Pi - 1)
+      return r.push([e, t]), this.size = ++n.size, this;
+    n = this.__data__ = new H(r);
+  }
+  return n.set(e, t), this.size = n.size, this;
+}
+function $(e) {
+  var t = this.__data__ = new D(e);
+  this.size = t.size;
+}
+$.prototype.clear = Oi;
+$.prototype.delete = Ai;
+$.prototype.get = Mi;
+$.prototype.has = Ci;
+$.prototype.set = Ti;
+function Ei(e, t) {
+  for (var n = -1, r = e == null ? 0 : e.length, i = 0, s = []; ++n < r; ) {
+    var o = e[n];
+    t(o, n, e) && (s[i++] = o);
+  }
+  return s;
+}
+function xi() {
+  return [];
+}
+var Ri = Object.prototype, Ii = Ri.propertyIsEnumerable, lt = Object.getOwnPropertySymbols, ji = lt ? function(e) {
+  return e == null ? [] : (e = Object(e), Ei(lt(e), function(t) {
+    return Ii.call(e, t);
+  }));
+} : xi;
+function $i(e, t, n) {
+  var r = t(e);
+  return P(e) ? r : Gt(r, n(e));
+}
+function ht(e) {
+  return $i(e, be, ji);
+}
+var $e = Z(z, "DataView"), Fe = Z(z, "Promise"), ze = Z(z, "Set"), pt = "[object Map]", Fi = "[object Object]", dt = "[object Promise]", _t = "[object Set]", yt = "[object WeakMap]", bt = "[object DataView]", zi = W($e), Di = W(oe), Hi = W(Fe), Ni = W(ze), Li = W(Ie), L = V;
+($e && L(new $e(new ArrayBuffer(1))) != bt || oe && L(new oe()) != pt || Fe && L(Fe.resolve()) != dt || ze && L(new ze()) != _t || Ie && L(new Ie()) != yt) && (L = function(e) {
+  var t = V(e), n = t == Fi ? e.constructor : void 0, r = n ? W(n) : "";
+  if (r)
+    switch (r) {
+      case zi:
+        return bt;
+      case Di:
+        return pt;
+      case Hi:
+        return dt;
+      case Ni:
+        return _t;
+      case Li:
+        return yt;
+    }
+  return t;
+});
+var gt = z.Uint8Array, qi = "__lodash_hash_undefined__";
+function Gi(e) {
+  return this.__data__.set(e, qi), this;
+}
+function Ui(e) {
+  return this.__data__.has(e);
+}
+function de(e) {
+  var t = -1, n = e == null ? 0 : e.length;
+  for (this.__data__ = new H(); ++t < n; )
+    this.add(e[t]);
+}
+de.prototype.add = de.prototype.push = Gi;
+de.prototype.has = Ui;
+function Bi(e, t) {
+  for (var n = -1, r = e == null ? 0 : e.length; ++n < r; )
+    if (t(e[n], n, e))
+      return !0;
+  return !1;
+}
+function Ki(e, t) {
+  return e.has(t);
+}
+var Qi = 1, Wi = 2;
+function Ut(e, t, n, r, i, s) {
+  var o = n & Qi, a = e.length, c = t.length;
+  if (a != c && !(o && c > a))
+    return !1;
+  var u = s.get(e), f = s.get(t);
+  if (u && f)
+    return u == t && f == e;
+  var l = -1, d = !0, y = n & Wi ? new de() : void 0;
+  for (s.set(e, t), s.set(t, e); ++l < a; ) {
+    var m = e[l], O = t[l];
+    if (r)
+      var v = o ? r(O, m, l, t, e, s) : r(m, O, l, e, t, s);
+    if (v !== void 0) {
+      if (v)
+        continue;
+      d = !1;
+      break;
+    }
+    if (y) {
+      if (!Bi(t, function(w, b) {
+        if (!Ki(y, b) && (m === w || i(m, w, n, r, s)))
+          return y.push(b);
+      })) {
+        d = !1;
+        break;
+      }
+    } else if (!(m === O || i(m, O, n, r, s))) {
+      d = !1;
+      break;
+    }
+  }
+  return s.delete(e), s.delete(t), d;
+}
+function Xi(e) {
+  var t = -1, n = Array(e.size);
+  return e.forEach(function(r, i) {
+    n[++t] = [i, r];
+  }), n;
+}
+function Yi(e) {
+  var t = -1, n = Array(e.size);
+  return e.forEach(function(r) {
+    n[++t] = r;
+  }), n;
+}
+var Vi = 1, Zi = 2, Ji = "[object Boolean]", ki = "[object Date]", es = "[object Error]", ts = "[object Map]", ns = "[object Number]", rs = "[object RegExp]", is = "[object Set]", ss = "[object String]", os = "[object Symbol]", as = "[object ArrayBuffer]", cs = "[object DataView]", mt = R ? R.prototype : void 0, Ce = mt ? mt.valueOf : void 0;
+function us(e, t, n, r, i, s, o) {
+  switch (n) {
+    case cs:
+      if (e.byteLength != t.byteLength || e.byteOffset != t.byteOffset)
+        return !1;
+      e = e.buffer, t = t.buffer;
+    case as:
+      return !(e.byteLength != t.byteLength || !s(new gt(e), new gt(t)));
+    case Ji:
+    case ki:
+    case ns:
+      return Ft(+e, +t);
+    case es:
+      return e.name == t.name && e.message == t.message;
+    case rs:
+    case ss:
+      return e == t + "";
+    case ts:
+      var a = Xi;
+    case is:
+      var c = r & Vi;
+      if (a || (a = Yi), e.size != t.size && !c)
+        return !1;
+      var u = o.get(e);
+      if (u)
+        return u == t;
+      r |= Zi, o.set(e, t);
+      var f = Ut(a(e), a(t), r, i, s, o);
+      return o.delete(e), f;
+    case os:
+      if (Ce)
+        return Ce.call(e) == Ce.call(t);
+  }
+  return !1;
+}
+var fs = 1, ls = Object.prototype, hs = ls.hasOwnProperty;
+function ps(e, t, n, r, i, s) {
+  var o = n & fs, a = ht(e), c = a.length, u = ht(t), f = u.length;
+  if (c != f && !o)
+    return !1;
+  for (var l = c; l--; ) {
+    var d = a[l];
+    if (!(o ? d in t : hs.call(t, d)))
+      return !1;
+  }
+  var y = s.get(e), m = s.get(t);
+  if (y && m)
+    return y == t && m == e;
+  var O = !0;
+  s.set(e, t), s.set(t, e);
+  for (var v = o; ++l < c; ) {
+    d = a[l];
+    var w = e[d], b = t[d];
+    if (r)
+      var A = o ? r(b, w, d, t, e, s) : r(w, b, d, e, t, s);
+    if (!(A === void 0 ? w === b || i(w, b, n, r, s) : A)) {
+      O = !1;
+      break;
+    }
+    v || (v = d == "constructor");
+  }
+  if (O && !v) {
+    var G = e.constructor, p = t.constructor;
+    G != p && "constructor" in e && "constructor" in t && !(typeof G == "function" && G instanceof G && typeof p == "function" && p instanceof p) && (O = !1);
+  }
+  return s.delete(e), s.delete(t), O;
+}
+var ds = 1, wt = "[object Arguments]", vt = "[object Array]", ce = "[object Object]", _s = Object.prototype, St = _s.hasOwnProperty;
+function ys(e, t, n, r, i, s) {
+  var o = P(e), a = P(t), c = o ? vt : L(e), u = a ? vt : L(t);
+  c = c == wt ? ce : c, u = u == wt ? ce : u;
+  var f = c == ce, l = u == ce, d = c == u;
+  if (d && je(e)) {
+    if (!je(t))
+      return !1;
+    o = !0, f = !1;
+  }
+  if (d && !f)
+    return s || (s = new $()), o || Nt(e) ? Ut(e, t, n, r, i, s) : us(e, t, c, n, r, i, s);
+  if (!(n & ds)) {
+    var y = f && St.call(e, "__wrapped__"), m = l && St.call(t, "__wrapped__");
+    if (y || m) {
+      var O = y ? e.value() : e, v = m ? t.value() : t;
+      return s || (s = new $()), i(O, v, n, r, s);
+    }
+  }
+  return d ? (s || (s = new $()), ps(e, t, n, r, i, s)) : !1;
+}
+function ve(e, t, n, r, i) {
+  return e === t ? !0 : e == null || t == null || !Y(e) && !Y(t) ? e !== e && t !== t : ys(e, t, n, r, ve, i);
+}
+var bs = 1, gs = 2;
+function ms(e, t, n, r) {
+  var i = n.length, s = i;
+  if (e == null)
+    return !s;
+  for (e = Object(e); i--; ) {
+    var o = n[i];
+    if (o[2] ? o[1] !== e[o[0]] : !(o[0] in e))
+      return !1;
+  }
+  for (; ++i < s; ) {
+    o = n[i];
+    var a = o[0], c = e[a], u = o[1];
+    if (o[2]) {
+      if (c === void 0 && !(a in e))
+        return !1;
+    } else {
+      var f = new $(), l;
+      if (!(l === void 0 ? ve(u, c, bs | gs, r, f) : l))
+        return !1;
+    }
+  }
+  return !0;
+}
+function Bt(e) {
+  return e === e && !ie(e);
+}
+function ws(e) {
+  for (var t = be(e), n = t.length; n--; ) {
+    var r = t[n], i = e[r];
+    t[n] = [r, i, Bt(i)];
+  }
+  return t;
+}
+function Kt(e, t) {
+  return function(n) {
+    return n == null ? !1 : n[e] === t && (t !== void 0 || e in Object(n));
+  };
+}
+function vs(e) {
+  var t = ws(e);
+  return t.length == 1 && t[0][2] ? Kt(t[0][0], t[0][1]) : function(n) {
+    return n === e || ms(n, e, t);
+  };
+}
+function Ss(e, t) {
+  return e != null && t in Object(e);
+}
+function Os(e, t, n) {
+  t = Lt(t, e);
+  for (var r = -1, i = t.length, s = !1; ++r < i; ) {
+    var o = we(t[r]);
+    if (!(s = e != null && n(e, o)))
+      break;
+    e = e[o];
+  }
+  return s || ++r != i ? s : (i = e == null ? 0 : e.length, !!i && Be(i) && $t(o, i) && (P(e) || Ke(e)));
+}
+function As(e, t) {
+  return e != null && Os(e, t, Ss);
+}
+var Ms = 1, Cs = 2;
+function Ps(e, t) {
+  return Qe(e) && Bt(t) ? Kt(we(e), t) : function(n) {
+    var r = wi(n, e);
+    return r === void 0 && r === t ? As(n, e) : ve(t, r, Ms | Cs);
+  };
+}
+function Ts(e) {
+  return function(t) {
+    return t?.[e];
+  };
+}
+function Es(e) {
+  return function(t) {
+    return qt(t, e);
+  };
+}
+function xs(e) {
+  return Qe(e) ? Ts(we(e)) : Es(e);
+}
+function Se(e) {
+  return typeof e == "function" ? e : e == null ? xn : typeof e == "object" ? P(e) ? Ps(e[0], e[1]) : vs(e) : xs(e);
+}
+function Rs(e) {
+  return function(t, n, r) {
+    for (var i = -1, s = Object(t), o = r(t), a = o.length; a--; ) {
+      var c = o[++i];
+      if (n(s[c], c, s) === !1)
+        break;
+    }
+    return t;
+  };
+}
+var Is = Rs();
+function js(e, t) {
+  return e && Is(e, t, be);
+}
+function $s(e, t) {
+  return function(n, r) {
+    if (n == null)
+      return n;
+    if (!ye(n))
+      return e(n, r);
+    for (var i = n.length, s = -1, o = Object(n); ++s < i && r(o[s], s, o) !== !1; )
+      ;
+    return n;
+  };
+}
+var Qt = $s(js);
+function Fs(e) {
+  var t = e == null ? 0 : e.length;
+  return t ? e[t - 1] : void 0;
+}
+function zs(e, t) {
+  for (var n = -1, r = e == null ? 0 : e.length; ++n < r; )
+    if (!t(e[n], n, e))
+      return !1;
+  return !0;
+}
+function Ds(e, t) {
+  var n = !0;
+  return Qt(e, function(r, i, s) {
+    return n = !!t(r, i, s), n;
+  }), n;
+}
+function Hs(e, t, n) {
+  var r = P(e) ? zs : Ds;
+  return r(e, Se(t));
+}
+function Ns(e) {
+  return function(t, n, r) {
+    var i = Object(t);
+    if (!ye(t)) {
+      var s = Se(n);
+      t = be(t), n = function(a) {
+        return s(i[a], a, i);
+      };
+    }
+    var o = e(t, n, r);
+    return o > -1 ? i[s ? t[o] : o] : void 0;
+  };
+}
+var Ls = Math.max;
+function qs(e, t, n) {
+  var r = e == null ? 0 : e.length;
+  if (!r)
+    return -1;
+  var i = n == null ? 0 : En(n);
+  return i < 0 && (i = Ls(r + i, 0)), Wn(e, Se(t), i);
+}
+var Gs = Ns(qs);
+function Us(e, t) {
+  var n = -1, r = ye(e) ? Array(e.length) : [];
+  return Qt(e, function(i, s, o) {
+    r[++n] = t(i, s, o);
+  }), r;
+}
+function Bs(e, t) {
+  var n = P(e) ? Rt : Us;
+  return n(e, Se(t));
+}
+function Ks(e, t) {
+  return Si(Bs(e, t));
+}
+function Qs(e) {
+  for (var t = -1, n = e == null ? 0 : e.length, r = {}; ++t < n; ) {
+    var i = e[t];
+    r[i[0]] = i[1];
+  }
+  return r;
+}
+function Ws(e, t) {
+  return ve(e, t);
+}
+const Xs = (e, t) => {
+  if (!e.length) return [t];
+  const n = Fs(e);
+  return n.type === "create" && t.type === "delete" ? null : n.type === "create" && t.type === "update" ? [{ ...n, data: t.data }] : n.type === "update" && t.type === "update" ? [...e.slice(0, -1), t] : n.type === "update" && t.type === "delete" ? [...e, t] : [t];
+};
+class Ys {
+  _config;
+  _state;
+  _subscribers = /* @__PURE__ */ new Set();
+  _debounceTimer = null;
+  _abortController = null;
+  constructor(t) {
+    this._config = t, this._state = {
+      queue: /* @__PURE__ */ new Map(),
+      inFlight: /* @__PURE__ */ new Map(),
+      errors: /* @__PURE__ */ new Map(),
+      isPaused: !1,
+      isSyncing: !1
+    };
+  }
+  enqueue(t) {
+    this._updateState((n) => {
+      const r = [...n.queue.get(t.id) ?? []], i = Xs(r, t);
+      i ? n.queue.set(t.id, i) : n.queue.delete(t.id), n.errors.delete(t.id);
+    }), this._scheduleFlush();
+  }
+  pause() {
+    this._updateState((t) => {
+      t.isPaused = !0;
+    }), this._clearTimer();
+  }
+  resume() {
+    this._updateState((t) => {
+      t.isPaused = !1;
+    }), this._state.queue.size > 0 && this._scheduleFlush();
+  }
+  retryAll() {
+    const t = this._state.errors;
+    t.size !== 0 && (this._updateState((n) => {
+      for (const [r, i] of t)
+        n.queue.has(r) || n.queue.set(r, i.operations);
+      n.errors.clear();
+    }), this._scheduleFlush());
+  }
+  retry(t) {
+    const n = this._state.errors.get(t);
+    n && (this._updateState((r) => {
+      r.queue.has(t) || r.queue.set(t, n.operations), r.errors.delete(t);
+    }), this._scheduleFlush());
+  }
+  resetRetries(t) {
+    this._state.errors.has(t) && this._updateState((n) => {
+      const r = n.errors.get(t);
+      r && (r.retries = 0);
+    });
+  }
+  getState() {
+    return this._state;
+  }
+  subscribe(t) {
+    return this._subscribers.add(t), () => this._subscribers.delete(t);
+  }
+  _updateState(t) {
+    this._state = T(this._state, t), this._subscribers.forEach((n) => n());
+  }
+  _scheduleFlush() {
+    this._state.isPaused || this._state.isSyncing || (this._clearTimer(), this._debounceTimer = setTimeout(() => this._flush(), this._config.debounce));
+  }
+  _clearTimer() {
+    this._debounceTimer && (clearTimeout(this._debounceTimer), this._debounceTimer = null);
+  }
+  async _flush() {
+    const { isPaused: t, isSyncing: n, queue: r } = this._state;
+    if (t || n || r.size === 0) return;
+    this._updateState((s) => {
+      s.inFlight = new Map(r), s.queue = /* @__PURE__ */ new Map(), s.isSyncing = !0;
+    });
+    const i = Ks([...this._state.inFlight.values()]);
+    this._abortController = new AbortController();
+    try {
+      const s = await this._config.onSync(i, this._abortController.signal);
+      this._processResults(Qs(s.map((o) => [o.id, o])));
+    } catch (s) {
+      this._handleError(s);
+    }
+    this._abortController = null, this._state.queue.size > 0 && !this._state.isPaused && this._scheduleFlush();
+  }
+  _processResults(t) {
+    const n = this._state.inFlight, r = [];
+    this._updateState((i) => {
+      for (const [s, o] of n)
+        if (Hs(o, (c) => t[c.id]?.status === "success")) {
+          i.errors.delete(s);
+          for (const c of o) {
+            const u = t[c.id];
+            c.type === "create" && u?.newId && u.newId !== c.id && r.push({ tempId: c.id, newId: u.newId });
+          }
+        } else {
+          const c = (i.errors.get(s)?.retries ?? 0) + 1;
+          c < this._config.maxRetries && !i.queue.has(s) && i.queue.set(s, o);
+          const u = Gs(o, (f) => t[f.id]?.status !== "success");
+          i.errors.set(s, {
+            error: t[u?.id ?? ""]?.error ?? "Unknown error",
+            retries: c,
+            operations: o
+          });
+        }
+      i.inFlight = /* @__PURE__ */ new Map(), i.isSyncing = !1;
+    }), r.length > 0 && this._config.onIdRemap && this._config.onIdRemap(r);
+  }
+  _handleError(t) {
+    const n = this._state.inFlight, r = this._abortController?.signal.aborted, i = t instanceof Error ? t.message : String(t);
+    this._updateState((s) => {
+      for (const [o, a] of n)
+        if (r)
+          s.queue.has(o) || s.queue.set(o, a);
+        else {
+          const c = (s.errors.get(o)?.retries ?? 0) + 1;
+          c < this._config.maxRetries && !s.queue.has(o) && s.queue.set(o, a), s.errors.set(o, {
+            error: i,
+            retries: c,
+            operations: a
+          });
+        }
+      s.inFlight = /* @__PURE__ */ new Map(), s.isSyncing = !1;
+    });
+  }
+}
+class Vs {
+  _cache = /* @__PURE__ */ new Map();
+  _capacity;
+  _ttl;
+  constructor(t, n) {
+    this._capacity = t, this._ttl = n;
+  }
+  get(t) {
+    const n = this._cache.get(t);
+    return n ? Date.now() - n.ts > this._ttl ? (this._cache.delete(t), null) : (this._cache.delete(t), this._cache.set(t, n), n.data) : null;
+  }
+  set(t, n) {
+    if (this._cache.has(t))
+      this._cache.delete(t);
+    else if (this._cache.size >= this._capacity) {
+      const r = this._cache.keys().next().value;
+      r !== void 0 && this._cache.delete(r);
+    }
+    this._cache.set(t, { data: n, ts: Date.now() });
+  }
+  invalidate(t) {
+    this._cache.delete(t);
+  }
+  clear() {
+    this._cache.clear();
+  }
+  has(t) {
+    return this.get(t) !== null;
+  }
+  get size() {
+    return this._cache.size;
+  }
+}
+class Zs {
+  _config;
+  _cache;
+  _state = { status: "idle", items: [] };
+  _subscribers = /* @__PURE__ */ new Set();
+  _abortController = null;
+  _currentContext = null;
+  constructor(t) {
+    this._config = { retries: 0, ...t }, this._cache = new Vs(t.cacheCapacity, t.cacheTtl);
+  }
+  _getCacheKey = (t) => JSON.stringify([this._config.id, t]);
+  _setState(t) {
+    this._state = T(this._state, (n) => {
+      Object.assign(n, t);
+    }), this._subscribers.forEach((n) => n());
+  }
+  async _fetchWithRetry(t, n) {
+    const r = this._config.retries;
+    let i;
+    for (let s = 0; s <= r; s++) {
+      if (n.aborted) throw new DOMException("Aborted", "AbortError");
+      try {
+        return s > 0 && this._setState({ retryCount: s }), await this._config.onFetch(t, n);
+      } catch (o) {
+        if (i = o, n.aborted || s === r) throw o;
+      }
+    }
+    throw i;
+  }
+  async fetch(t) {
+    const n = this._getCacheKey(t), r = this._cache.get(n);
+    if (r !== null)
+      return this._currentContext = t, this._setState({ status: "idle", items: r, error: void 0, retryCount: void 0 }), r;
+    this._abortController?.abort("New fetch request started");
+    const i = new AbortController();
+    this._abortController = i, this._currentContext = t, this._setState({ status: "fetching", error: void 0, retryCount: void 0 });
+    try {
+      const s = await this._fetchWithRetry(t, i.signal);
+      return this._cache.set(n, s), this._abortController = null, this._setState({ status: "idle", items: s, error: void 0, retryCount: void 0 }), s;
+    } catch (s) {
+      if (i.signal.aborted) return this._state.items;
+      throw this._abortController = null, this._setState({
+        status: "error",
+        error: s instanceof Error ? s.message : String(s)
+      }), s;
+    }
+  }
+  async refresh(t) {
+    const n = t ?? this._currentContext;
+    if (!n) throw new Error("No context provided for refresh");
+    return this._cache.invalidate(this._getCacheKey(n)), this.fetch(n);
+  }
+  invalidateCache() {
+    this._cache.clear();
+  }
+  invalidateCacheForContext(t) {
+    this._cache.invalidate(this._getCacheKey(t));
+  }
+  getState = () => this._state;
+  getContext = () => this._currentContext;
+  isFetching = () => this._state.status === "fetching";
+  subscribe(t) {
+    return this._subscribers.add(t), () => {
+      this._subscribers.delete(t);
+    };
+  }
+}
+class Js {
+  _collection;
+  _id;
+  _cachedStatus = null;
+  constructor(t, n) {
+    this._collection = t, this._id = n;
+  }
+  get id() {
+    return this._id;
+  }
+  get data() {
+    return this._collection.getState().items.get(this._id);
+  }
+  update(t) {
+    this._collection.update(this._id, t);
+  }
+  remove() {
+    this._collection.remove(this._id);
+  }
+  getStatus() {
+    const t = this._collection.getItemStatus(this._id);
+    return Ws(this._cachedStatus, t) || (this._cachedStatus = t), this._cachedStatus;
+  }
+  exists() {
+    return this._collection.getState().items.has(this._id);
+  }
+  // Expose collection for useItem hook
+  get collection() {
+    return this._collection;
+  }
+  // Internal method to update ID after server assigns permanent ID
+  // Called by Collection when handling ID remapping
+  _updateId(t) {
+    this._id = t;
+  }
+}
+class U {
+  // Global cache of collection instances by id
+  static _cache = /* @__PURE__ */ new Map();
+  // Get or create a collection instance
+  static get(t) {
+    const n = U._cache.get(t.id);
+    if (n)
+      return n;
+    const r = new U(t);
+    return U._cache.set(t.id, r), r;
+  }
+  // Clear a specific collection from cache
+  static clear(t) {
+    U._cache.delete(t);
+  }
+  // Clear all collections from cache
+  static clearAll() {
+    U._cache.clear();
+  }
+  id;
+  config;
+  _state;
+  _syncQueue;
+  _fetchHandler;
+  _itemCache = /* @__PURE__ */ new Map();
+  _subscribers = /* @__PURE__ */ new Set();
+  _hasInitialized = !1;
+  _batchMode = !1;
+  constructor(t) {
+    this.id = t.id, this.config = t;
+    const n = async (s) => s.map((o) => ({ id: o.id, status: "success" }));
+    this._syncQueue = new Ys({
+      debounce: t.syncDebounce ?? 300,
+      maxRetries: t.syncRetries ?? 3,
+      onSync: t.onSync ?? n,
+      onIdRemap: (s) => this._handleIdRemap(s)
+    }), this._fetchHandler = new Zs({
+      id: t.id,
+      cacheCapacity: t.cacheCapacity ?? 10,
+      cacheTtl: t.cacheTtl ?? 6e4,
+      retries: t.fetchRetries ?? 0,
+      onFetch: t.onFetch
+    });
+    const r = this._syncQueue.getState(), i = this._fetchHandler.getState();
+    this._state = {
+      context: t.initialContext,
+      items: /* @__PURE__ */ new Map(),
+      syncState: "idle",
+      loading: !1,
+      syncing: !1,
+      syncQueue: r,
+      fetchStatus: i.status,
+      fetchError: i.error
+    }, this._syncQueue.subscribe(() => {
+      this._onSyncQueueChange();
+    }), this._fetchHandler.subscribe(() => {
+      this._onFetchChange();
+    }), this._initialFetch();
+  }
+  // Getters for convenience (read from state)
+  get context() {
+    return this._state.context;
+  }
+  get items() {
+    return this._state.items;
+  }
+  get loading() {
+    return this._state.loading;
+  }
+  get syncing() {
+    return this._state.syncing;
+  }
+  get syncQueue() {
+    return this._state.syncQueue;
+  }
+  // Subscribe to state changes
+  subscribe(t) {
+    return this._subscribers.add(t), () => {
+      this._subscribers.delete(t);
+    };
+  }
+  // Get current state (for useSyncExternalStore) - returns cached reference
+  getState() {
+    return this._state;
+  }
+  // Get item status from sync queue state
+  getItemStatus(t) {
+    const { queue: n, inFlight: r, errors: i } = this._state.syncQueue, s = r.get(t);
+    if (s && s.length > 0)
+      return {
+        type: s[s.length - 1].type,
+        status: "syncing",
+        retries: i.get(t)?.retries ?? 0
+      };
+    const o = n.get(t);
+    if (o && o.length > 0) {
+      const c = o[o.length - 1], u = i.get(t);
+      return {
+        type: c.type,
+        status: u ? "error" : "pending",
+        retries: u?.retries ?? 0,
+        error: u?.error
+      };
+    }
+    const a = i.get(t);
+    return a ? {
+      type: "update",
+      status: "error",
+      retries: a.retries,
+      error: a.error
+    } : null;
+  }
+  // Create a new item (local-first)
+  create(t) {
+    const n = this.config.getId(t);
+    this._state = T(this._state, (r) => {
+      r.items.set(n, t);
+    }), this._fetchHandler.invalidateCache(), this._notifySubscribers(), this._syncQueue.enqueue({ id: n, type: "create", data: t });
+  }
+  // Update an existing item (local-first)
+  update(t, n) {
+    const r = this._state.items.get(t);
+    if (!r) return;
+    const i = T(r, n);
+    this._state = T(this._state, (s) => {
+      s.items.set(t, i);
+    }), this._fetchHandler.invalidateCache(), this._notifySubscribers(), this._syncQueue.enqueue({ id: t, type: "update", data: i });
+  }
+  // Remove an item (local-first)
+  remove(t) {
+    const n = this._state.items.get(t);
+    n && (this._state = T(this._state, (r) => {
+      r.items.delete(t);
+    }), this._itemCache.delete(t), this._fetchHandler.invalidateCache(), this._notifySubscribers(), this._syncQueue.enqueue({ id: t, type: "delete", data: n }));
+  }
+  // Get Item reference (cached)
+  getItem(t) {
+    let n = this._itemCache.get(t);
+    return n || (n = new Js(this, t), this._itemCache.set(t, n)), n;
+  }
+  // Update context and refetch
+  setContext(t) {
+    const n = this._state.context, r = T(n, t);
+    n !== r && (this._state = T(this._state, (i) => {
+      i.context = r;
+    }), this._fetchHandler.fetch(r), this._notifySubscribers());
+  }
+  // Force refresh (bypass cache)
+  async refresh() {
+    this._fetchHandler.invalidateCache(), await this._fetchHandler.fetch(this._state.context);
+  }
+  // SyncQueue controls
+  pauseSync() {
+    this._syncQueue.pause();
+  }
+  resumeSync() {
+    this._syncQueue.resume(), this._fetchHandler.invalidateCache(), this._fetchHandler.fetch(this._state.context);
+  }
+  retrySync(t) {
+    t ? this._syncQueue.retry(t) : this._syncQueue.retryAll();
+  }
+  // Private methods
+  async _initialFetch() {
+    this._hasInitialized || (this._hasInitialized = !0, await this._fetchHandler.fetch(this._state.context));
+  }
+  _onSyncQueueChange() {
+    const t = this._syncQueue.getState();
+    this._updateSyncState(t);
+  }
+  _onFetchChange() {
+    const t = this._fetchHandler.getState();
+    this._state = T(this._state, (n) => {
+      n.fetchStatus = t.status, n.fetchError = t.error, n.loading = t.status === "fetching", n.syncState = this._computeSyncState(t.status, n.syncQueue.isSyncing);
+      const { queue: r, inFlight: i } = this._state.syncQueue, s = /* @__PURE__ */ new Map();
+      for (const o of t.items) {
+        const a = this.config.getId(o);
+        s.set(a, o);
+      }
+      for (const [o, a] of r) {
+        const c = a[a.length - 1];
+        (c.type === "create" || c.type === "update") && s.set(o, c.data);
+      }
+      for (const [o, a] of i) {
+        const c = a[a.length - 1];
+        (c.type === "create" || c.type === "update") && s.set(o, c.data);
+      }
+      n.items = s;
+    }), this._notifySubscribers();
+  }
+  _updateSyncState(t) {
+    this._state = T(this._state, (n) => {
+      n.syncQueue = t, n.syncing = t.isSyncing, n.syncState = this._computeSyncState(n.fetchStatus, t.isSyncing);
+    }), this._notifySubscribers();
+  }
+  _computeSyncState(t, n) {
+    return t === "fetching" ? "fetching" : n ? "syncing" : "idle";
+  }
+  _notifySubscribers() {
+    if (!this._batchMode)
+      for (const t of this._subscribers)
+        t();
+  }
+  _handleIdRemap(t) {
+    if (t.length === 0) return;
+    const { setId: n } = this.config;
+    this._state = T(this._state, (r) => {
+      for (const { tempId: i, newId: s } of t) {
+        const o = r.items.get(i);
+        if (o) {
+          let a;
+          n ? a = n(o, s) : (o.id = s, a = o), r.items.delete(i), r.items.set(s, a);
+        }
+      }
+    });
+    for (const { tempId: r, newId: i } of t) {
+      const s = this._itemCache.get(r);
+      s && (s._updateId(i), this._itemCache.delete(r), this._itemCache.set(i, s));
+    }
+    this._notifySubscribers();
+  }
+}
+function eo(e) {
+  const t = U.get(e), n = ue(
+    (r) => t.subscribe(r),
+    () => t.getState(),
+    () => t.getState()
+  );
+  return {
+    // State (all from single immutable state object)
+    items: n.items,
+    context: n.context,
+    syncState: n.syncState,
+    syncQueue: n.syncQueue,
+    loading: n.loading,
+    syncing: n.syncing,
+    // Item operations
+    create: (r) => t.create(r),
+    update: (r, i) => t.update(r, i),
+    remove: (r) => t.remove(r),
+    getItem: (r) => t.getItem(r),
+    getItemStatus: (r) => t.getItemStatus(r),
+    // Context & refresh
+    setContext: (r) => t.setContext(r),
+    refresh: () => t.refresh(),
+    // Sync controls
+    pauseSync: () => t.pauseSync(),
+    resumeSync: () => t.resumeSync(),
+    retrySync: (r) => t.retrySync(r)
+  };
+}
+function to(e) {
+  const t = ue(
+    (o) => e.collection.subscribe(o),
+    () => e.data,
+    () => e.data
+  ), n = ue(
+    (o) => e.collection.subscribe(o),
+    () => e.getStatus(),
+    () => e.getStatus()
+  ), r = ue(
+    (o) => e.collection.subscribe(o),
+    () => e.exists(),
+    () => e.exists()
+  ), i = Xe((o) => e.update(o), [e]), s = Xe(() => e.remove(), [e]);
+  return { data: t, status: n, update: i, remove: s, exists: r };
+}
+export {
+  Vs as Cache,
+  U as Collection,
+  Zs as FetchHandler,
+  Js as Item,
+  Ys as SyncQueue,
+  io as categorizeResults,
+  oo as createSyncClient,
+  ao as createSyncClientFromEndpoint,
+  co as createSyncClientWithStats,
+  uo as fetchToSyncResult,
+  fo as syncError,
+  lo as syncSuccess,
+  eo as useCrud,
+  to as useItem
+};
+//# sourceMappingURL=index.js.map