@mhmo91/schmancy 0.2.139 → 0.2.142

package/dist/context-array-CSGdoQ1W.js

@@ -0,0 +1,923 @@
+import { Subject as ue, BehaviorSubject as q, throttleTime as ie } from "rxjs";
+var oe = Symbol.for("immer-nothing"), H = Symbol.for("immer-draftable"), u = Symbol.for("immer-state"), le = 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 = le[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 $ = Object.getPrototypeOf;
+function w(t) {
+  return !!t && !!t[u];
+}
+function v(t) {
+  var e;
+  return !!t && (ae(t) || Array.isArray(t) || !!t[H] || !!((e = t.constructor) != null && e[H]) || I(t) || A(t));
+}
+var de = Object.prototype.constructor.toString();
+function ae(t) {
+  if (!t || typeof t != "object") return !1;
+  const 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) === de;
+}
+function P(t, e) {
+  M(t) === 0 ? Reflect.ownKeys(t).forEach((r) => {
+    e(r, t[r], t);
+  }) : t.forEach((r, s) => e(s, r, t));
+}
+function M(t) {
+  const e = t[u];
+  return e ? e.type_ : Array.isArray(t) ? 1 : I(t) ? 2 : A(t) ? 3 : 0;
+}
+function B(t, e) {
+  return M(t) === 2 ? t.has(e) : Object.prototype.hasOwnProperty.call(t, e);
+}
+function ce(t, e, r) {
+  const s = M(t);
+  s === 2 ? t.set(e, r) : s === 3 ? t.add(r) : t[e] = r;
+}
+function I(t) {
+  return t instanceof Map;
+}
+function A(t) {
+  return t instanceof Set;
+}
+function f(t) {
+  return t.copy_ || t.base_;
+}
+function C(t, e) {
+  if (I(t)) return new Map(t);
+  if (A(t)) return new Set(t);
+  if (Array.isArray(t)) return Array.prototype.slice.call(t);
+  const r = ae(t);
+  if (e === !0 || e === "class_only" && !r) {
+    const s = Object.getOwnPropertyDescriptors(t);
+    delete s[u];
+    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($(t), s);
+  }
+  {
+    const s = $(t);
+    if (s !== null && r) return { ...t };
+    const n = Object.create(s);
+    return Object.assign(n, t);
+  }
+}
+function G(t, e = !1) {
+  return R(t) || w(t) || !v(t) || (M(t) > 1 && (t.set = t.add = t.clear = t.delete = pe), Object.freeze(t), e && Object.entries(t).forEach(([r, s]) => G(s, !0))), t;
+}
+function pe() {
+  _(2);
+}
+function R(t) {
+  return Object.isFrozen(t);
+}
+var N, J = {};
+function S(t) {
+  const e = J[t];
+  return e || _(0, t), e;
+}
+function D() {
+  return N;
+}
+function Y(t, e) {
+  e && (S("Patches"), t.patches_ = [], t.inversePatches_ = [], t.patchListener_ = e);
+}
+function U(t) {
+  K(t), t.drafts_.forEach(fe), t.drafts_ = null;
+}
+function K(t) {
+  t === N && (N = t.parent_);
+}
+function Z(t) {
+  return N = { drafts_: [], parent_: N, immer_: t, canAutoFreeze_: !0, unfinalizedDrafts_: 0 };
+}
+function fe(t) {
+  const e = t[u];
+  e.type_ === 0 || e.type_ === 1 ? e.revoke_() : e.revoked_ = !0;
+}
+function Q(t, e) {
+  e.unfinalizedDrafts_ = e.drafts_.length;
+  const r = e.drafts_[0];
+  return t !== void 0 && t !== r ? (r[u].modified_ && (U(e), _(4)), v(t) && (t = T(e, t), e.parent_ || j(e, t)), e.patches_ && S("Patches").generateReplacementPatches_(r[u].base_, t, e.patches_, e.inversePatches_)) : t = T(e, r, []), U(e), e.patches_ && e.patchListener_(e.patches_, e.inversePatches_), t !== oe ? t : void 0;
+}
+function T(t, e, r) {
+  if (R(e)) return e;
+  const s = e[u];
+  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 j(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)), j(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 = T(t, n, a && e && e.type_ !== 3 && !B(e.assigned_, s) ? a.concat(s) : void 0);
+    if (ce(r, s, c), !w(c)) return;
+    t.canAutoFreeze_ = !1;
+  } else h && r.add(n);
+  if (v(n) && !R(n)) {
+    if (!t.immer_.autoFreeze_ && t.unfinalizedDrafts_ < 1) return;
+    T(t, n), e && e.scope_.parent_ || typeof s == "symbol" || !Object.prototype.propertyIsEnumerable.call(r, s) || j(t, n);
+  }
+}
+function j(t, e, r = !1) {
+  !t.parent_ && t.immer_.autoFreeze_ && t.canAutoFreeze_ && G(e, r);
+}
+var L = { get(t, e) {
+  if (e === u) return t;
+  const r = f(t);
+  if (!B(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 === F(t.base_, e) ? (V(t), t.copy_[e] = z(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 = F(f(t), e), c = h == null ? void 0 : h[u];
+    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 || B(t.base_, e))) return !0;
+    V(t), m(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) => (F(t.base_, e) !== void 0 || e in t.base_ ? (t.assigned_[e] = !1, V(t), m(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) => $(t.base_), setPrototypeOf() {
+  _(12);
+} }, E = {};
+function F(t, e) {
+  const r = t[u];
+  return (r ? f(r) : t)[e];
+}
+function te(t, e) {
+  if (!(e in t)) return;
+  let r = $(t);
+  for (; r; ) {
+    const s = Object.getOwnPropertyDescriptor(r, e);
+    if (s) return s;
+    r = $(r);
+  }
+}
+function m(t) {
+  t.modified_ || (t.modified_ = !0, t.parent_ && m(t.parent_));
+}
+function V(t) {
+  t.copy_ || (t.copy_ = C(t.base_, t.scope_.immer_.useStrictShallowCopy_));
+}
+P(L, (t, e) => {
+  E[t] = function() {
+    return arguments[0] = arguments[0][0], e.apply(this, arguments);
+  };
+}), E.deleteProperty = function(t, e) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(e)) && _(13), E.set.call(this, t, e, void 0);
+}, E.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 z(t, e) {
+  const r = I(t) ? S("MapSet").proxyMap_(t, e) : A(t) ? S("MapSet").proxySet_(t, e) : function(s, n) {
+    const a = Array.isArray(s), h = { type_: a ? 1 : 0, scope_: n ? n.scope_ : D(), 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 = E);
+    const { revoke: o, proxy: p } = Proxy.revocable(c, i);
+    return h.draft_ = p, h.revoke_ = o, p;
+  }(t, e);
+  return (e ? e.scope_ : D()).drafts_.push(r), r;
+}
+function he(t) {
+  if (!v(t) || R(t)) return t;
+  const e = t[u];
+  let r;
+  if (e) {
+    if (!e.modified_) return e.base_;
+    e.finalized_ = !0, r = C(t, e.scope_.immer_.useStrictShallowCopy_);
+  } else r = C(t, !0);
+  return P(r, (s, n) => {
+    ce(r, s, he(n));
+  }), e && (e.finalized_ = !1), r;
+}
+var g = 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 = z(e, void 0);
+        let c = !0;
+        try {
+          n = r(h), c = !1;
+        } finally {
+          c ? U(a) : K(a);
+        }
+        return Y(a, s), Q(n, a);
+      }
+      if (!e || typeof e != "object") {
+        if (n = r(e), n === void 0 && (n = e), n === oe && (n = void 0), this.autoFreeze_ && G(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), he(s);
+    }(t));
+    const e = Z(this), r = z(t, void 0);
+    return r[u].isManual_ = !0, K(e), r;
+  }
+  finishDraft(t, e) {
+    const r = t && t[u];
+    r && r.isManual_ || _(9);
+    const { scope_: s } = r;
+    return Y(s, e), Q(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 = g.produce;
+g.produceWithPatches.bind(g), g.setAutoFreeze.bind(g), g.setUseStrictShallowCopy.bind(g), g.applyPatches.bind(g), g.createDraft.bind(g), g.finishDraft.bind(g);
+class l 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, l);
+  }
+  toJSON() {
+    return { name: this.name, message: this.message, cause: this.cause, context: this.context, timestamp: this.timestamp.toISOString(), stack: this.stack };
+  }
+}
+class ye {
+  constructor() {
+    this.data = null;
+  }
+  async load() {
+    return this.data;
+  }
+  async save(e) {
+    this.data = e;
+  }
+  async clear() {
+    this.data = null;
+  }
+}
+class _e {
+  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 l(`Failed to save to localStorage (${this.key})`, r);
+    }
+  }
+  async clear() {
+    localStorage.removeItem(this.key);
+  }
+}
+class ge {
+  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 l(`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 l(`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 l(`Failed to clear from IndexedDB (${this.key})`, e);
+    }
+  }
+};
+y.DB_NAME = "StoreDB", y.STORE_NAME = "states", y.DB_VERSION = 1;
+let W = y;
+function be(t, e) {
+  switch (t) {
+    case "local":
+      return new _e(e);
+    case "session":
+      return new ge(e);
+    case "indexeddb":
+      return new W(e);
+    default:
+      return new ye();
+  }
+}
+(function() {
+  class t extends Map {
+    constructor(i, o) {
+      super(), this[u] = { type_: 2, parent_: o, scope_: o ? o.scope_ : D(), modified_: !1, finalized_: !1, copy_: void 0, assigned_: void 0, base_: i, draft_: this, isManual_: !1, revoked_: !1 };
+    }
+    get size() {
+      return f(this[u]).size;
+    }
+    has(i) {
+      return f(this[u]).has(i);
+    }
+    set(i, o) {
+      const p = this[u];
+      return n(p), f(p).has(i) && f(p).get(i) === o || (e(p), m(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[u];
+      return n(o), e(o), m(o), o.base_.has(i) ? o.assigned_.set(i, !1) : o.assigned_.delete(i), o.copy_.delete(i), !0;
+    }
+    clear() {
+      const i = this[u];
+      n(i), f(i).size && (e(i), m(i), i.assigned_ = /* @__PURE__ */ new Map(), P(i.base_, (o) => {
+        i.assigned_.set(o, !1);
+      }), i.copy_.clear());
+    }
+    forEach(i, o) {
+      f(this[u]).forEach((p, b, me) => {
+        i.call(o, this.get(b), b, this);
+      });
+    }
+    get(i) {
+      const o = this[u];
+      n(o);
+      const p = f(o).get(i);
+      if (o.finalized_ || !v(p) || p !== o.base_.get(i)) return p;
+      const b = z(p, o);
+      return e(o), o.copy_.set(i, b), b;
+    }
+    keys() {
+      return f(this[u]).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[u] = { type_: 3, parent_: o, scope_: o ? o.scope_ : D(), modified_: !1, finalized_: !1, copy_: void 0, base_: i, draft_: this, drafts_: /* @__PURE__ */ new Map(), revoked_: !1, isManual_: !1 };
+    }
+    get size() {
+      return f(this[u]).size;
+    }
+    has(i) {
+      const o = this[u];
+      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[u];
+      return n(o), this.has(i) || (s(o), m(o), o.copy_.add(i)), this;
+    }
+    delete(i) {
+      if (!this.has(i)) return !1;
+      const o = this[u];
+      return n(o), s(o), m(o), o.copy_.delete(i) || !!o.drafts_.has(i) && o.copy_.delete(o.drafts_.get(i));
+    }
+    clear() {
+      const i = this[u];
+      n(i), f(i).size && (s(i), m(i), i.copy_.clear());
+    }
+    values() {
+      const i = this[u];
+      return n(i), s(i), i.copy_.values();
+    }
+    entries() {
+      const i = this[u];
+      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 b = p.next();
+      for (; !b.done; ) i.call(o, b.value, b.value, this), b = p.next();
+    }
+  }
+  function s(c) {
+    c.copy_ || (c.copy_ = /* @__PURE__ */ new Set(), c.base_.forEach((i) => {
+      if (v(i)) {
+        const o = z(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);
+  } }, J[a = "MapSet"] || (J[a] = h);
+})();
+class X {
+  constructor(e, r, s) {
+    this.storageType = e, this.key = r, this._ready = !1, this._destroy$ = new ue(), this.error$ = new q(null), this.defaultValue = d(s, (n) => n), this.$ = new q(this.defaultValue), this.storage = be(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();
+  }
+  destroy() {
+    this._destroy$.next(), this._destroy$.complete(), this.$.complete(), this.error$.complete();
+  }
+  replace(e) {
+    const r = d(e, (s) => s);
+    this.updateState(r);
+  }
+  updateState(e) {
+    try {
+      const r = d(e, (s) => s);
+      this.$.next(r), this.storageType !== "memory" && this.persistToStorage(r).catch((s) => {
+        const n = new l(`Error saving to ${this.storageType} storage for ${this.key}`, s);
+        this.error$.next(n);
+      });
+    } catch (r) {
+      const s = new l(`Error updating state in ${this.key}`, r);
+      this.error$.next(s);
+    }
+  }
+  async initializeFromStorage() {
+    try {
+      const e = await this.storage.load();
+      if (e) {
+        const r = this.processStoredValue(e), s = d(r, (n) => n);
+        this.updateState(s);
+      }
+      this._ready = !0;
+    } catch (e) {
+      const r = new l(`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 x = class x extends X {
+  static getInstance(e, r, s) {
+    const n = `${e}:${r}`;
+    return this.instances.has(n) || this.instances.set(n, new x(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 l(`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 l(`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 l(`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 l(`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(ie(100, void 0, { leading: !0, trailing: !0 })).subscribe((e) => {
+      this.storage.save(e).catch((r) => {
+        const s = new l(`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();
+    } });
+  }
+};
+x.type = "collection", x.instances = /* @__PURE__ */ new Map();
+let re = x;
+const k = class k extends X {
+  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 = !0) {
+    try {
+      const s = d(this.value, (n) => {
+        if (!r) return e;
+        Object.assign(n, e);
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (s) {
+      const n = new l(`Error updating store: ${this.key}`, s, { value: e, merge: r });
+      this.error$.next(n);
+    }
+  }
+  clear() {
+    const e = d(this.defaultValue, (r) => r);
+    this.set(e, !1);
+  }
+  delete(e) {
+    const r = d(this.value, (s) => {
+      delete s[e];
+    });
+    this.updateState(r);
+  }
+  setPath(e, r) {
+    try {
+      const s = d(this.value, (n) => {
+        const a = e.split(".");
+        let h = n;
+        for (let c = 0; c < a.length - 1; c++) {
+          const i = a[c];
+          (h[i] === void 0 || typeof h[i] != "object") && (h[i] = {}), h = h[i];
+        }
+        h[a[a.length - 1]] = r;
+      });
+      this.updateState(s), this.error$.next(null);
+    } catch (s) {
+      const n = new l(`Error setting path ${e} in ${this.key}`, s);
+      this.error$.next(n);
+    }
+  }
+  processStoredValue(e) {
+    return d(this.defaultValue, (r) => {
+      Object.assign(r, 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();
+    } });
+  }
+};
+k.type = "object", k.instances = /* @__PURE__ */ new Map();
+let se = k;
+const O = class O extends X {
+  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);
+  }
+  constructor(e, r, s = []) {
+    super(e, r, s), e !== "memory" && this.setupPersistence();
+  }
+  setupPersistence() {
+    this.$.pipe(ie(100, void 0, { leading: !0, trailing: !0 })).subscribe((e) => {
+      this.storage.save(e).catch((r) => {
+        const s = new l(`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 l(`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 l(`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 l(`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 l(`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 l(`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 l(`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 l(`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 l(`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 l(`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 l(`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 l(`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();
+    } });
+  }
+};
+O.type = "array", O.instances = /* @__PURE__ */ new Map();
+let ne = O;
+export {
+  W as I,
+  _e as L,
+  ye as M,
+  se as S,
+  ge as a,
+  l as b,
+  be as c,
+  re as d,
+  ne as e
+};
+//# sourceMappingURL=context-array-CSGdoQ1W.js.map