@mhmo91/schmancy 0.2.140 → 0.2.143

package/dist/context-array-DpyA_ATT.js

@@ -0,0 +1,1020 @@
+import { Subject as pe, BehaviorSubject as Q, throttleTime as oe } from "rxjs";
+var ce = Symbol.for("immer-nothing"), $ = Symbol.for("immer-draftable"), l = Symbol.for("immer-state"), fe = process.env.NODE_ENV !== "production" ? [function(t) {
+  return `The plugin for '${t}' has not been loaded into Immer. To enable the plugin, import and call \`enable${t}()\` when initializing your application.`;
+}, function(t) {
+  return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${t}'`;
+}, "This object has been frozen and should not be mutated", function(t) {
+  return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + t;
+}, "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.", "Immer forbids circular references", "The first or second argument to `produce` must be a function", "The third argument to `produce` must be a function or undefined", "First argument to `createDraft` must be a plain object, an array, or an immerable object", "First argument to `finishDraft` must be a draft returned by `createDraft`", function(t) {
+  return `'current' expects a draft, got: ${t}`;
+}, "Object.defineProperty() cannot be used on an Immer draft", "Object.setPrototypeOf() cannot be used on an Immer draft", "Immer only supports deleting array indices", "Immer only supports setting array indices and the 'length' property", function(t) {
+  return `'original' expects a draft, got: ${t}`;
+}] : [];
+function _(t, ...e) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = fe[t], s = typeof r == "function" ? r.apply(null, e) : r;
+    throw new Error(`[Immer] ${s}`);
+  }
+  throw new Error(`[Immer] minified error nr: ${t}. Full error at: https://bit.ly/3cXEKWf`);
+}
+var E = Object.getPrototypeOf;
+function w(t) {
+  return !!t && !!t[l];
+}
+function v(t) {
+  var e;
+  return !!t && (he(t) || Array.isArray(t) || !!t[$] || !!((e = t.constructor) != null && e[$]) || A(t) || R(t));
+}
+var ye = Object.prototype.constructor.toString();
+function he(t) {
+  if (!t || typeof t != "object") return !1;
+  const e = E(t);
+  if (e === null) return !0;
+  const r = Object.hasOwnProperty.call(e, "constructor") && e.constructor;
+  return r === Object || typeof r == "function" && Function.toString.call(r) === ye;
+}
+function P(t, e) {
+  T(t) === 0 ? Reflect.ownKeys(t).forEach((r) => {
+    e(r, t[r], t);
+  }) : t.forEach((r, s) => e(s, r, t));
+}
+function T(t) {
+  const e = t[l];
+  return e ? e.type_ : Array.isArray(t) ? 1 : A(t) ? 2 : R(t) ? 3 : 0;
+}
+function C(t, e) {
+  return T(t) === 2 ? t.has(e) : Object.prototype.hasOwnProperty.call(t, e);
+}
+function ue(t, e, r) {
+  const s = T(t);
+  s === 2 ? t.set(e, r) : s === 3 ? t.add(r) : t[e] = r;
+}
+function A(t) {
+  return t instanceof Map;
+}
+function R(t) {
+  return t instanceof Set;
+}
+function f(t) {
+  return t.copy_ || t.base_;
+}
+function J(t, e) {
+  if (A(t)) return new Map(t);
+  if (R(t)) return new Set(t);
+  if (Array.isArray(t)) return Array.prototype.slice.call(t);
+  const r = he(t);
+  if (e === !0 || e === "class_only" && !r) {
+    const s = Object.getOwnPropertyDescriptors(t);
+    delete s[l];
+    let n = Reflect.ownKeys(s);
+    for (let a = 0; a < n.length; a++) {
+      const h = n[a], c = s[h];
+      c.writable === !1 && (c.writable = !0, c.configurable = !0), (c.get || c.set) && (s[h] = { configurable: !0, writable: !0, enumerable: c.enumerable, value: t[h] });
+    }
+    return Object.create(E(t), s);
+  }
+  {
+    const s = E(t);
+    if (s !== null && r) return { ...t };
+    const n = Object.create(s);
+    return Object.assign(n, t);
+  }
+}
+function X(t, e = !1) {
+  return F(t) || w(t) || !v(t) || (T(t) > 1 && (t.set = t.add = t.clear = t.delete = _e), Object.freeze(t), e && Object.entries(t).forEach(([r, s]) => X(s, !0))), t;
+}
+function _e() {
+  _(2);
+}
+function F(t) {
+  return Object.isFrozen(t);
+}
+var j, U = {};
+function S(t) {
+  const e = U[t];
+  return e || _(0, t), e;
+}
+function N() {
+  return j;
+}
+function Y(t, e) {
+  e && (S("Patches"), t.patches_ = [], t.inversePatches_ = [], t.patchListener_ = e);
+}
+function K(t) {
+  W(t), t.drafts_.forEach(be), t.drafts_ = null;
+}
+function W(t) {
+  t === j && (j = t.parent_);
+}
+function Z(t) {
+  return j = { drafts_: [], parent_: j, immer_: t, canAutoFreeze_: !0, unfinalizedDrafts_: 0 };
+}
+function be(t) {
+  const e = t[l];
+  e.type_ === 0 || e.type_ === 1 ? e.revoke_() : e.revoked_ = !0;
+}
+function H(t, e) {
+  e.unfinalizedDrafts_ = e.drafts_.length;
+  const r = e.drafts_[0];
+  return t !== void 0 && t !== r ? (r[l].modified_ && (K(e), _(4)), v(t) && (t = z(e, t), e.parent_ || M(e, t)), e.patches_ && S("Patches").generateReplacementPatches_(r[l].base_, t, e.patches_, e.inversePatches_)) : t = z(e, r, []), K(e), e.patches_ && e.patchListener_(e.patches_, e.inversePatches_), t !== ce ? t : void 0;
+}
+function z(t, e, r) {
+  if (F(e)) return e;
+  const s = e[l];
+  if (!s) return P(e, (n, a) => ee(t, s, e, n, a, r)), e;
+  if (s.scope_ !== t) return e;
+  if (!s.modified_) return M(t, s.base_, !0), s.base_;
+  if (!s.finalized_) {
+    s.finalized_ = !0, s.scope_.unfinalizedDrafts_--;
+    const n = s.copy_;
+    let a = n, h = !1;
+    s.type_ === 3 && (a = new Set(n), n.clear(), h = !0), P(a, (c, i) => ee(t, s, n, c, i, r, h)), M(t, n, !1), r && t.patches_ && S("Patches").generatePatches_(s, r, t.patches_, t.inversePatches_);
+  }
+  return s.copy_;
+}
+function ee(t, e, r, s, n, a, h) {
+  if (process.env.NODE_ENV !== "production" && n === r && _(5), w(n)) {
+    const c = z(t, n, a && e && e.type_ !== 3 && !C(e.assigned_, s) ? a.concat(s) : void 0);
+    if (ue(r, s, c), !w(c)) return;
+    t.canAutoFreeze_ = !1;
+  } else h && r.add(n);
+  if (v(n) && !F(n)) {
+    if (!t.immer_.autoFreeze_ && t.unfinalizedDrafts_ < 1) return;
+    z(t, n), e && e.scope_.parent_ || typeof s == "symbol" || !Object.prototype.propertyIsEnumerable.call(r, s) || M(t, n);
+  }
+}
+function M(t, e, r = !1) {
+  !t.parent_ && t.immer_.autoFreeze_ && t.canAutoFreeze_ && X(e, r);
+}
+var L = { get(t, e) {
+  if (e === l) return t;
+  const r = f(t);
+  if (!C(r, e)) return function(n, a, h) {
+    var i;
+    const c = te(a, h);
+    return c ? "value" in c ? c.value : (i = c.get) == null ? void 0 : i.call(n.draft_) : void 0;
+  }(t, r, e);
+  const s = r[e];
+  return t.finalized_ || !v(s) ? s : s === V(t.base_, e) ? (B(t), t.copy_[e] = I(s, t)) : s;
+}, has: (t, e) => e in f(t), ownKeys: (t) => Reflect.ownKeys(f(t)), set(t, e, r) {
+  const s = te(f(t), e);
+  if (s != null && s.set) return s.set.call(t.draft_, r), !0;
+  if (!t.modified_) {
+    const h = V(f(t), e), c = h == null ? void 0 : h[l];
+    if (c && c.base_ === r) return t.copy_[e] = r, t.assigned_[e] = !1, !0;
+    if (((n = r) === (a = h) ? n !== 0 || 1 / n == 1 / a : n != n && a != a) && (r !== void 0 || C(t.base_, e))) return !0;
+    B(t), g(t);
+  }
+  var n, a;
+  return t.copy_[e] === r && (r !== void 0 || e in t.copy_) || Number.isNaN(r) && Number.isNaN(t.copy_[e]) || (t.copy_[e] = r, t.assigned_[e] = !0), !0;
+}, deleteProperty: (t, e) => (V(t.base_, e) !== void 0 || e in t.base_ ? (t.assigned_[e] = !1, B(t), g(t)) : delete t.assigned_[e], t.copy_ && delete t.copy_[e], !0), getOwnPropertyDescriptor(t, e) {
+  const r = f(t), s = Reflect.getOwnPropertyDescriptor(r, e);
+  return s && { writable: !0, configurable: t.type_ !== 1 || e !== "length", enumerable: s.enumerable, value: r[e] };
+}, defineProperty() {
+  _(11);
+}, getPrototypeOf: (t) => E(t.base_), setPrototypeOf() {
+  _(12);
+} }, x = {};
+function V(t, e) {
+  const r = t[l];
+  return (r ? f(r) : t)[e];
+}
+function te(t, e) {
+  if (!(e in t)) return;
+  let r = E(t);
+  for (; r; ) {
+    const s = Object.getOwnPropertyDescriptor(r, e);
+    if (s) return s;
+    r = E(r);
+  }
+}
+function g(t) {
+  t.modified_ || (t.modified_ = !0, t.parent_ && g(t.parent_));
+}
+function B(t) {
+  t.copy_ || (t.copy_ = J(t.base_, t.scope_.immer_.useStrictShallowCopy_));
+}
+P(L, (t, e) => {
+  x[t] = function() {
+    return arguments[0] = arguments[0][0], e.apply(this, arguments);
+  };
+}), x.deleteProperty = function(t, e) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(e)) && _(13), x.set.call(this, t, e, void 0);
+}, x.set = function(t, e, r) {
+  return process.env.NODE_ENV !== "production" && e !== "length" && isNaN(parseInt(e)) && _(14), L.set.call(this, t[0], e, r, t[0]);
+};
+function I(t, e) {
+  const r = A(t) ? S("MapSet").proxyMap_(t, e) : R(t) ? S("MapSet").proxySet_(t, e) : function(s, n) {
+    const a = Array.isArray(s), h = { type_: a ? 1 : 0, scope_: n ? n.scope_ : N(), modified_: !1, finalized_: !1, assigned_: {}, parent_: n, base_: s, draft_: null, copy_: null, revoke_: null, isManual_: !1 };
+    let c = h, i = L;
+    a && (c = [h], i = x);
+    const { revoke: o, proxy: p } = Proxy.revocable(c, i);
+    return h.draft_ = p, h.revoke_ = o, p;
+  }(t, e);
+  return (e ? e.scope_ : N()).drafts_.push(r), r;
+}
+function le(t) {
+  if (!v(t) || F(t)) return t;
+  const e = t[l];
+  let r;
+  if (e) {
+    if (!e.modified_) return e.base_;
+    e.finalized_ = !0, r = J(t, e.scope_.immer_.useStrictShallowCopy_);
+  } else r = J(t, !0);
+  return P(r, (s, n) => {
+    ue(r, s, le(n));
+  }), e && (e.finalized_ = !1), r;
+}
+var de, re, se, b = new class {
+  constructor(t) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.produce = (e, r, s) => {
+      if (typeof e == "function" && typeof r != "function") {
+        const a = r;
+        r = e;
+        const h = this;
+        return function(c = a, ...i) {
+          return h.produce(c, (o) => r.call(this, o, ...i));
+        };
+      }
+      let n;
+      if (typeof r != "function" && _(6), s !== void 0 && typeof s != "function" && _(7), v(e)) {
+        const a = Z(this), h = I(e, void 0);
+        let c = !0;
+        try {
+          n = r(h), c = !1;
+        } finally {
+          c ? K(a) : W(a);
+        }
+        return Y(a, s), H(n, a);
+      }
+      if (!e || typeof e != "object") {
+        if (n = r(e), n === void 0 && (n = e), n === ce && (n = void 0), this.autoFreeze_ && X(n, !0), s) {
+          const a = [], h = [];
+          S("Patches").generateReplacementPatches_(e, n, a, h), s(a, h);
+        }
+        return n;
+      }
+      _(1, e);
+    }, this.produceWithPatches = (e, r) => {
+      if (typeof e == "function") return (a, ...h) => this.produceWithPatches(a, (c) => e(c, ...h));
+      let s, n;
+      return [this.produce(e, r, (a, h) => {
+        s = a, n = h;
+      }), s, n];
+    }, typeof (t == null ? void 0 : t.autoFreeze) == "boolean" && this.setAutoFreeze(t.autoFreeze), typeof (t == null ? void 0 : t.useStrictShallowCopy) == "boolean" && this.setUseStrictShallowCopy(t.useStrictShallowCopy);
+  }
+  createDraft(t) {
+    v(t) || _(8), w(t) && (t = function(s) {
+      return w(s) || _(10, s), le(s);
+    }(t));
+    const e = Z(this), r = I(t, void 0);
+    return r[l].isManual_ = !0, W(e), r;
+  }
+  finishDraft(t, e) {
+    const r = t && t[l];
+    r && r.isManual_ || _(9);
+    const { scope_: s } = r;
+    return Y(s, e), H(void 0, s);
+  }
+  setAutoFreeze(t) {
+    this.autoFreeze_ = t;
+  }
+  setUseStrictShallowCopy(t) {
+    this.useStrictShallowCopy_ = t;
+  }
+  applyPatches(t, e) {
+    let r;
+    for (r = e.length - 1; r >= 0; r--) {
+      const n = e[r];
+      if (n.path.length === 0 && n.op === "replace") {
+        t = n.value;
+        break;
+      }
+    }
+    r > -1 && (e = e.slice(r + 1));
+    const s = S("Patches").applyPatches_;
+    return w(t) ? s(t, e) : this.produce(t, (n) => s(n, e));
+  }
+}(), d = b.produce;
+b.produceWithPatches.bind(b), b.setAutoFreeze.bind(b), b.setUseStrictShallowCopy.bind(b), b.applyPatches.bind(b), b.createDraft.bind(b), b.finishDraft.bind(b);
+class u extends Error {
+  constructor(e, r, s) {
+    super(e), this.name = "StoreError", this.cause = r, this.context = s, this.timestamp = /* @__PURE__ */ new Date(), Error.captureStackTrace && Error.captureStackTrace(this, u);
+  }
+  toJSON() {
+    return { name: this.name, message: this.message, cause: this.cause, context: this.context, timestamp: this.timestamp.toISOString(), stack: this.stack };
+  }
+}
+class me {
+  constructor() {
+    this.data = null;
+  }
+  async load() {
+    return this.data;
+  }
+  async save(e) {
+    this.data = e;
+  }
+  async clear() {
+    this.data = null;
+  }
+}
+class ge {
+  constructor(e) {
+    this.key = e;
+  }
+  async load() {
+    try {
+      const e = localStorage.getItem(this.key);
+      return e ? JSON.parse(e) : null;
+    } catch {
+      return null;
+    }
+  }
+  async save(e) {
+    try {
+      localStorage.setItem(this.key, JSON.stringify(e));
+    } catch (r) {
+      throw new u(`Failed to save to localStorage (${this.key})`, r);
+    }
+  }
+  async clear() {
+    localStorage.removeItem(this.key);
+  }
+}
+class ve {
+  constructor(e) {
+    this.key = e;
+  }
+  async load() {
+    try {
+      const e = sessionStorage.getItem(this.key);
+      return e ? JSON.parse(e) : null;
+    } catch {
+      return null;
+    }
+  }
+  async save(e) {
+    try {
+      sessionStorage.setItem(this.key, JSON.stringify(e));
+    } catch (r) {
+      throw new u(`Failed to save to sessionStorage (${this.key})`, r);
+    }
+  }
+  async clear() {
+    sessionStorage.removeItem(this.key);
+  }
+}
+const y = class y {
+  constructor(e) {
+    this.key = e;
+  }
+  openDB() {
+    return new Promise((e, r) => {
+      const s = indexedDB.open(y.DB_NAME, y.DB_VERSION);
+      s.onupgradeneeded = () => {
+        const n = s.result;
+        n.objectStoreNames.contains(y.STORE_NAME) || n.createObjectStore(y.STORE_NAME);
+      }, s.onsuccess = () => e(s.result), s.onerror = () => r(s.error);
+    });
+  }
+  async load() {
+    try {
+      const e = await this.openDB();
+      return new Promise((r, s) => {
+        const n = e.transaction(y.STORE_NAME, "readonly").objectStore(y.STORE_NAME).get(this.key);
+        n.onsuccess = () => {
+          e.close(), r(n.result || null);
+        }, n.onerror = () => {
+          e.close(), s(n.error);
+        };
+      });
+    } catch {
+      return null;
+    }
+  }
+  async save(e) {
+    try {
+      const r = await this.openDB();
+      return new Promise((s, n) => {
+        const a = r.transaction(y.STORE_NAME, "readwrite").objectStore(y.STORE_NAME).put(e, this.key);
+        a.onsuccess = () => {
+          r.close(), s();
+        }, a.onerror = () => {
+          r.close(), n(a.error);
+        };
+      });
+    } catch (r) {
+      throw new u(`Failed to save to IndexedDB (${this.key})`, r);
+    }
+  }
+  async clear() {
+    try {
+      const e = await this.openDB();
+      return new Promise((r, s) => {
+        const n = e.transaction(y.STORE_NAME, "readwrite").objectStore(y.STORE_NAME).delete(this.key);
+        n.onsuccess = () => {
+          e.close(), r();
+        }, n.onerror = () => {
+          e.close(), s(n.error);
+        };
+      });
+    } catch (e) {
+      throw new u(`Failed to clear from IndexedDB (${this.key})`, e);
+    }
+  }
+};
+y.DB_NAME = "StoreDB", y.STORE_NAME = "states", y.DB_VERSION = 1;
+let G = y;
+function Se(t, e) {
+  switch (t) {
+    case "local":
+      return new ge(e);
+    case "session":
+      return new ve(e);
+    case "indexeddb":
+      return new G(e);
+    default:
+      return new me();
+  }
+}
+(function() {
+  class t extends Map {
+    constructor(i, o) {
+      super(), this[l] = { type_: 2, parent_: o, scope_: o ? o.scope_ : N(), modified_: !1, finalized_: !1, copy_: void 0, assigned_: void 0, base_: i, draft_: this, isManual_: !1, revoked_: !1 };
+    }
+    get size() {
+      return f(this[l]).size;
+    }
+    has(i) {
+      return f(this[l]).has(i);
+    }
+    set(i, o) {
+      const p = this[l];
+      return n(p), f(p).has(i) && f(p).get(i) === o || (e(p), g(p), p.assigned_.set(i, !0), p.copy_.set(i, o), p.assigned_.set(i, !0)), this;
+    }
+    delete(i) {
+      if (!this.has(i)) return !1;
+      const o = this[l];
+      return n(o), e(o), g(o), o.base_.has(i) ? o.assigned_.set(i, !1) : o.assigned_.delete(i), o.copy_.delete(i), !0;
+    }
+    clear() {
+      const i = this[l];
+      n(i), f(i).size && (e(i), g(i), i.assigned_ = /* @__PURE__ */ new Map(), P(i.base_, (o) => {
+        i.assigned_.set(o, !1);
+      }), i.copy_.clear());
+    }
+    forEach(i, o) {
+      f(this[l]).forEach((p, m, we) => {
+        i.call(o, this.get(m), m, this);
+      });
+    }
+    get(i) {
+      const o = this[l];
+      n(o);
+      const p = f(o).get(i);
+      if (o.finalized_ || !v(p) || p !== o.base_.get(i)) return p;
+      const m = I(p, o);
+      return e(o), o.copy_.set(i, m), m;
+    }
+    keys() {
+      return f(this[l]).keys();
+    }
+    values() {
+      const i = this.keys();
+      return { [Symbol.iterator]: () => this.values(), next: () => {
+        const o = i.next();
+        return o.done ? o : { done: !1, value: this.get(o.value) };
+      } };
+    }
+    entries() {
+      const i = this.keys();
+      return { [Symbol.iterator]: () => this.entries(), next: () => {
+        const o = i.next();
+        if (o.done) return o;
+        const p = this.get(o.value);
+        return { done: !1, value: [o.value, p] };
+      } };
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  }
+  function e(c) {
+    c.copy_ || (c.assigned_ = /* @__PURE__ */ new Map(), c.copy_ = new Map(c.base_));
+  }
+  class r extends Set {
+    constructor(i, o) {
+      super(), this[l] = { type_: 3, parent_: o, scope_: o ? o.scope_ : N(), modified_: !1, finalized_: !1, copy_: void 0, base_: i, draft_: this, drafts_: /* @__PURE__ */ new Map(), revoked_: !1, isManual_: !1 };
+    }
+    get size() {
+      return f(this[l]).size;
+    }
+    has(i) {
+      const o = this[l];
+      return n(o), o.copy_ ? !!o.copy_.has(i) || !(!o.drafts_.has(i) || !o.copy_.has(o.drafts_.get(i))) : o.base_.has(i);
+    }
+    add(i) {
+      const o = this[l];
+      return n(o), this.has(i) || (s(o), g(o), o.copy_.add(i)), this;
+    }
+    delete(i) {
+      if (!this.has(i)) return !1;
+      const o = this[l];
+      return n(o), s(o), g(o), o.copy_.delete(i) || !!o.drafts_.has(i) && o.copy_.delete(o.drafts_.get(i));
+    }
+    clear() {
+      const i = this[l];
+      n(i), f(i).size && (s(i), g(i), i.copy_.clear());
+    }
+    values() {
+      const i = this[l];
+      return n(i), s(i), i.copy_.values();
+    }
+    entries() {
+      const i = this[l];
+      return n(i), s(i), i.copy_.entries();
+    }
+    keys() {
+      return this.values();
+    }
+    [Symbol.iterator]() {
+      return this.values();
+    }
+    forEach(i, o) {
+      const p = this.values();
+      let m = p.next();
+      for (; !m.done; ) i.call(o, m.value, m.value, this), m = p.next();
+    }
+  }
+  function s(c) {
+    c.copy_ || (c.copy_ = /* @__PURE__ */ new Set(), c.base_.forEach((i) => {
+      if (v(i)) {
+        const o = I(i, c);
+        c.drafts_.set(i, o), c.copy_.add(o);
+      } else c.copy_.add(i);
+    }));
+  }
+  function n(c) {
+    c.revoked_ && _(3, JSON.stringify(f(c)));
+  }
+  var a, h;
+  h = { proxyMap_: function(c, i) {
+    return new t(c, i);
+  }, proxySet_: function(c, i) {
+    return new r(c, i);
+  } }, U[a = "MapSet"] || (U[a] = h);
+})(), de = $;
+class q {
+  constructor(e, r, s) {
+    let n;
+    this.storageType = e, this.key = r, this[de] = !0, this._ready = !1, this._destroy$ = new pe(), this.error$ = new Q(null), n = s instanceof Map ? new Map(s) : Array.isArray(s) ? [...s] : s && typeof s == "object" ? { ...s } : s;
+    try {
+      this.defaultValue = this.isImmerDraftable(n) ? d(n, (a) => a) : n;
+    } catch {
+      this.defaultValue = n;
+    }
+    this.$ = new Q(this.defaultValue), this.storage = Se(e, r), e === "memory" ? this._ready = !0 : this.initializeFromStorage();
+  }
+  get ready() {
+    return this._ready;
+  }
+  set ready(e) {
+    this._ready = e, this.updateState(this.$.value);
+  }
+  get value() {
+    return this.$.getValue();
+  }
+  isImmerDraftable(e) {
+    return e !== null && typeof e == "object" && (Array.isArray(e) || e instanceof Map || e instanceof Set || Object.getPrototypeOf(e) === Object.prototype || e[$] === !0);
+  }
+  destroy() {
+    this._destroy$.next(), this._destroy$.complete(), this.$.complete(), this.error$.complete();
+  }
+  replace(e) {
+    try {
+      const r = this.isImmerDraftable(e) ? d(e, (s) => s) : e;
+      this.updateState(r);
+    } catch (r) {
+      const s = new u(`Error replacing state in ${this.key}`, r);
+      this.error$.next(s), this.updateState(e);
+    }
+  }
+  updateState(e) {
+    try {
+      let r;
+      r = this.isImmerDraftable(e) ? d(e, (s) => s) : e, this.$.next(r), this.storageType !== "memory" && this.persistToStorage(r).catch((s) => {
+        const n = new u(`Error saving to ${this.storageType} storage for ${this.key}`, s);
+        this.error$.next(n);
+      });
+    } catch (r) {
+      const s = new u(`Error updating state in ${this.key}`, r);
+      this.error$.next(s), this.$.next(e);
+    }
+  }
+  async initializeFromStorage() {
+    try {
+      const e = await this.storage.load();
+      if (e) {
+        const r = this.processStoredValue(e);
+        try {
+          const s = this.isImmerDraftable(r) ? d(r, (n) => n) : r;
+          this.updateState(s);
+        } catch {
+          this.updateState(r);
+        }
+      }
+      this._ready = !0;
+    } catch (e) {
+      const r = new u(`Error loading from ${this.storageType} storage for ${this.key}`, e);
+      this.error$.next(r), this._ready = !0;
+    }
+  }
+  processStoredValue(e) {
+    return e;
+  }
+  async persistToStorage(e) {
+    return this.storage.save(e);
+  }
+}
+const k = class k extends q {
+  static getInstance(e, r, s) {
+    const n = `${e}:${r}`;
+    return this.instances.has(n) || this.instances.set(n, new k(e, r, s)), this.instances.get(n);
+  }
+  set(e, r) {
+    try {
+      const s = d(this.value, (n) => {
+        n.set(e, r);
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (s) {
+      const n = new u(`Error setting value for key ${e} in ${this.key}`, s);
+      this.error$.next(n);
+    }
+  }
+  delete(e) {
+    try {
+      const r = d(this.value, (s) => {
+        s.delete(e);
+      });
+      this.updateState(r), this.error$.next(null);
+    } catch (r) {
+      const s = new u(`Error deleting key ${e} from ${this.key}`, r);
+      this.error$.next(s);
+    }
+  }
+  clear() {
+    this.updateState(/* @__PURE__ */ new Map());
+  }
+  batchUpdate(e) {
+    try {
+      const r = d(this.value, (s) => {
+        Object.entries(e).forEach(([n, a]) => {
+          s.set(n, a);
+        });
+      });
+      this.updateState(r), this.error$.next(null);
+    } catch (r) {
+      const s = new u(`Error batch updating in ${this.key}`, r);
+      this.error$.next(s);
+    }
+  }
+  update(e, r) {
+    try {
+      const s = d(this.value, (n) => {
+        const a = n.get(e);
+        a !== void 0 && r(a);
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (s) {
+      const n = new u(`Error updating item ${e} in ${this.key}`, s);
+      this.error$.next(n);
+    }
+  }
+  constructor(e, r, s) {
+    super(e, r, s), e !== "memory" && this.setupPersistence();
+  }
+  setupPersistence() {
+    this.$.pipe(oe(100, void 0, { leading: !0, trailing: !0 })).subscribe((e) => {
+      this.storage.save(e).catch((r) => {
+        const s = new u(`Error saving to ${this.storageType} storage for ${this.key}`, r);
+        this.error$.next(s);
+      });
+    });
+  }
+  setupDevTools() {
+    typeof window < "u" && (window.__STORES__ = window.__STORES__ || {}, window.__STORES__[this.key] = { getState: () => this.value, set: this.set.bind(this), delete: this.delete.bind(this), clear: this.clear.bind(this), batchUpdate: this.batchUpdate.bind(this), update: this.update.bind(this), subscribe: (e) => {
+      const r = this.$.subscribe(e);
+      return () => r.unsubscribe();
+    } });
+  }
+};
+k.type = "collection", k.instances = /* @__PURE__ */ new Map();
+let ne = k;
+const O = class O extends (se = q, re = $, se) {
+  constructor() {
+    super(...arguments), this[re] = !0;
+  }
+  static getInstance(e, r, s) {
+    const n = `${e}:${r}`;
+    return this.instances.has(n) || this.instances.set(n, new O(e, r, s)), this.instances.get(n);
+  }
+  set(e, r = !0) {
+    try {
+      if (!this.isImmerDraftable(this.value)) {
+        const n = r ? { ...this.value, ...e } : e;
+        return this.updateState(n), void this.error$.next(null);
+      }
+      const s = d(this.value, (n) => {
+        if (r) {
+          if (e == null) return;
+          try {
+            Object.assign(n, e);
+          } catch {
+            Object.keys(e).forEach((h) => {
+              n[h] = e[h];
+            });
+          }
+        } else try {
+          return e;
+        } catch {
+          return e;
+        }
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (s) {
+      const n = new u(`Error updating store: ${this.key}`, s, { value: e, merge: r });
+      this.error$.next(n);
+      try {
+        const a = r ? { ...this.value, ...e } : e;
+        this.updateState(a);
+      } catch {
+      }
+    }
+  }
+  clear() {
+    try {
+      if (this.isImmerDraftable(this.defaultValue)) {
+        const e = d(this.defaultValue, (r) => r);
+        this.set(e, !1);
+      } else this.set(this.defaultValue, !1);
+    } catch (e) {
+      const r = new u(`Error clearing store: ${this.key}`, e);
+      this.error$.next(r), this.updateState(this.defaultValue);
+    }
+  }
+  delete(e) {
+    try {
+      if (!this.isImmerDraftable(this.value)) {
+        const s = { ...this.value };
+        return delete s[e], void this.updateState(s);
+      }
+      const r = d(this.value, (s) => {
+        delete s[e];
+      });
+      this.updateState(r);
+    } catch (r) {
+      const s = new u(`Error deleting key ${String(e)} from store: ${this.key}`, r);
+      this.error$.next(s);
+      try {
+        const n = { ...this.value };
+        delete n[e], this.updateState(n);
+      } catch {
+      }
+    }
+  }
+  setPath(e, r) {
+    try {
+      if (!e) return;
+      if (!this.isImmerDraftable(this.value)) {
+        const n = e.split("."), a = { ...this.value };
+        let h = a;
+        for (let c = 0; c < n.length - 1; c++) {
+          const i = n[c];
+          h[i] === void 0 ? h[i] = {} : typeof h[i] == "object" && h[i] !== null || (h[i] = {}), h = h[i];
+        }
+        return h[n[n.length - 1]] = r, void this.updateState(a);
+      }
+      const s = d(this.value, (n) => {
+        const a = e.split(".");
+        let h = n;
+        for (let i = 0; i < a.length - 1; i++) {
+          const o = a[i];
+          h[o] === void 0 ? h[o] = {} : typeof h[o] == "object" && h[o] !== null || (h[o] = {}), h = h[o];
+        }
+        const c = a[a.length - 1];
+        try {
+          h[c] = r;
+        } catch {
+          h[c] = r;
+        }
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (s) {
+      const n = new u(`Error setting path ${e} in ${this.key}`, s);
+      this.error$.next(n);
+      try {
+        const a = e.split("."), h = { ...this.value };
+        let c = h;
+        for (let i = 0; i < a.length - 1; i++) {
+          const o = a[i];
+          c[o] === void 0 ? c[o] = {} : typeof c[o] == "object" && c[o] !== null || (c[o] = {}), c = c[o];
+        }
+        c[a[a.length - 1]] = r, this.updateState(h);
+      } catch {
+      }
+    }
+  }
+  processStoredValue(e) {
+    try {
+      return this.isImmerDraftable(this.defaultValue) && this.isImmerDraftable(e) ? d(this.defaultValue, (r) => {
+        Object.assign(r, e);
+      }) : { ...this.defaultValue, ...e };
+    } catch {
+      return e;
+    }
+  }
+  setupDevTools() {
+    typeof window < "u" && (window.__STORES__ = window.__STORES__ || {}, window.__STORES__[this.key] = { getState: () => this.value, set: this.set.bind(this), delete: this.delete.bind(this), clear: this.clear.bind(this), setPath: this.setPath.bind(this), subscribe: (e) => {
+      const r = this.$.subscribe(e);
+      return () => r.unsubscribe();
+    } });
+  }
+  isImmerDraftable(e) {
+    return e !== null && typeof e == "object" && (super.isImmerDraftable(e) || e[$] === !0);
+  }
+};
+O.type = "object", O.instances = /* @__PURE__ */ new Map();
+let ie = O;
+const D = class D extends q {
+  static getInstance(e, r, s = []) {
+    const n = `${e}:${r}`;
+    return this.instances.has(n) || this.instances.set(n, new D(e, r, s)), this.instances.get(n);
+  }
+  constructor(e, r, s = []) {
+    super(e, r, s), e !== "memory" && this.setupPersistence();
+  }
+  setupPersistence() {
+    this.$.pipe(oe(100, void 0, { leading: !0, trailing: !0 })).subscribe((e) => {
+      this.storage.save(e).catch((r) => {
+        const s = new u(`Error saving to ${this.storageType} storage for ${this.key}`, r);
+        this.error$.next(s);
+      });
+    });
+  }
+  push(...e) {
+    try {
+      const r = d(this.value, (s) => {
+        s.push(...e.map((n) => n));
+      });
+      this.updateState(r), this.error$.next(null);
+    } catch (r) {
+      const s = new u(`Error pushing items in ${this.key}`, r);
+      this.error$.next(s);
+    }
+  }
+  pop() {
+    try {
+      const e = this.value.length > 0 ? this.value[this.value.length - 1] : void 0, r = d(this.value, (s) => {
+        s.pop();
+      });
+      return this.updateState(r), this.error$.next(null), e;
+    } catch (e) {
+      const r = new u(`Error popping item from ${this.key}`, e);
+      return void this.error$.next(r);
+    }
+  }
+  unshift(...e) {
+    try {
+      const r = d(this.value, (s) => {
+        s.unshift(...e.map((n) => n));
+      });
+      this.updateState(r), this.error$.next(null);
+    } catch (r) {
+      const s = new u(`Error unshifting items in ${this.key}`, r);
+      this.error$.next(s);
+    }
+  }
+  shift() {
+    try {
+      const e = this.value.length > 0 ? this.value[0] : void 0, r = d(this.value, (s) => {
+        s.shift();
+      });
+      return this.updateState(r), this.error$.next(null), e;
+    } catch (e) {
+      const r = new u(`Error shifting item from ${this.key}`, e);
+      return void this.error$.next(r);
+    }
+  }
+  set(e, r) {
+    try {
+      const s = d(this.value, (n) => {
+        if (!(e >= 0 && e < n.length)) throw new Error(`Index ${e} out of bounds (length: ${n.length})`);
+        n[e] = r;
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (s) {
+      const n = new u(`Error setting item at index ${e} in ${this.key}`, s);
+      this.error$.next(n);
+    }
+  }
+  get(e) {
+    return this.value[e];
+  }
+  splice(e, r, ...s) {
+    try {
+      const n = [...this.value].splice(e, r ?? 0, ...s), a = d(this.value, (h) => {
+        h.splice(e, r ?? 0, ...s.map((c) => c));
+      });
+      return this.updateState(a), this.error$.next(null), n;
+    } catch (n) {
+      const a = new u(`Error splicing items in ${this.key}`, n);
+      return this.error$.next(a), [];
+    }
+  }
+  remove(e, r) {
+    try {
+      const s = r || ((a, h) => a === h), n = this.value.findIndex((a) => s(a, e));
+      if (n !== -1) {
+        const a = d(this.value, (h) => {
+          h.splice(n, 1);
+        });
+        return this.updateState(a), this.error$.next(null), !0;
+      }
+      return this.error$.next(null), !1;
+    } catch (s) {
+      const n = new u(`Error removing item in ${this.key}`, s);
+      return this.error$.next(n), !1;
+    }
+  }
+  replace(e) {
+    try {
+      const r = d(e, (s) => s);
+      this.updateState(r), this.error$.next(null);
+    } catch (r) {
+      const s = new u(`Error replacing array in ${this.key}`, r);
+      this.error$.next(s);
+    }
+  }
+  filter(e) {
+    try {
+      const r = this.value.filter(e), s = d(this.value, (n) => {
+        n.length = 0, n.push(...r.map((a) => a));
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (r) {
+      const s = new u(`Error filtering array in ${this.key}`, r);
+      this.error$.next(s);
+    }
+  }
+  map(e) {
+    return this.value.map(e);
+  }
+  sort(e) {
+    try {
+      const r = [...this.value].sort(e), s = d(this.value, (n) => {
+        n.length = 0, n.push(...r.map((a) => a));
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (r) {
+      const s = new u(`Error sorting array in ${this.key}`, r);
+      this.error$.next(s);
+    }
+  }
+  update(e, r) {
+    try {
+      const s = d(this.value, (n) => {
+        if (!(e >= 0 && e < n.length)) throw new Error(`Index ${e} out of bounds (length: ${n.length})`);
+        r(n[e]);
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (s) {
+      const n = new u(`Error updating item at index ${e} in ${this.key}`, s);
+      this.error$.next(n);
+    }
+  }
+  clear() {
+    this.updateState([]);
+  }
+  setupDevTools() {
+    typeof window < "u" && (window.__STORES__ = window.__STORES__ || {}, window.__STORES__[this.key] = { getState: () => this.value, push: this.push.bind(this), pop: this.pop.bind(this), unshift: this.unshift.bind(this), shift: this.shift.bind(this), set: this.set.bind(this), get: this.get.bind(this), splice: this.splice.bind(this), remove: this.remove.bind(this), replace: this.replace.bind(this), filter: this.filter.bind(this), map: this.map.bind(this), sort: this.sort.bind(this), update: this.update.bind(this), clear: this.clear.bind(this), subscribe: (e) => {
+      const r = this.$.subscribe(e);
+      return () => r.unsubscribe();
+    } });
+  }
+};
+D.type = "array", D.instances = /* @__PURE__ */ new Map();
+let ae = D;
+export {
+  G as I,
+  ge as L,
+  me as M,
+  ie as S,
+  ve as a,
+  u as b,
+  Se as c,
+  ne as d,
+  ae as e
+};
+//# sourceMappingURL=context-array-DpyA_ATT.js.map