@biglogic/rgs 3.9.6 → 3.9.8

package/index.js

@@ -1,12 +1,15 @@
-import { produce as e, freeze as t } from "immer";
+import { useMemo as e, useSyncExternalStore as t, useCallback as n, useDebugValue as r, useState as s, useEffect as o } from "react";
 
-import { useMemo as n, useSyncExternalStore as s, useCallback as r, useDebugValue as o, useState as a, useEffect as i } from "react";
-
-var c, l, u, y, d = Object.defineProperty, g = Object.getOwnPropertyNames, f = (e, t) => function() {
-    return e && (t = (0, e[g(e)[0]])(e = 0)), t;
-}, h = f({
+var a, i, c, l, u = Object.defineProperty, d = Object.getOwnPropertyNames, f = (e => "undefined" != typeof require ? require : "undefined" != typeof Proxy ? new Proxy(e, {
+    get: (e, t) => ("undefined" != typeof require ? require : e)[t]
+}) : e)(function(e) {
+    if ("undefined" != typeof require) return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + e + '" is not supported');
+}), y = (e, t) => function() {
+    return e && (t = (0, e[d(e)[0]])(e = 0)), t;
+}, p = y({
     "core/utils.ts"() {
-        c = e => {
+        a = e => {
             if (null === e || "object" != typeof e) return e;
             if ("function" == typeof structuredClone) try {
                 return structuredClone(e);
@@ -18,53 +21,53 @@ var c, l, u, y, d = Object.defineProperty, g = Object.getOwnPropertyNames, f = (
                 if (e instanceof Date) return new Date(e.getTime());
                 if (e instanceof RegExp) return new RegExp(e.source, e.flags);
                 if (e instanceof Map) {
-                    const s = new Map;
-                    return t.set(e, s), e.forEach((e, t) => s.set(n(t), n(e))), s;
+                    const r = new Map;
+                    return t.set(e, r), e.forEach((e, t) => r.set(n(t), n(e))), r;
                 }
                 if (e instanceof Set) {
-                    const s = new Set;
-                    return t.set(e, s), e.forEach(e => s.add(n(e))), s;
+                    const r = new Set;
+                    return t.set(e, r), e.forEach(e => r.add(n(e))), r;
                 }
-                const s = Array.isArray(e) ? [] : Object.create(Object.getPrototypeOf(e));
-                t.set(e, s);
-                const r = [ ...Object.keys(e), ...Object.getOwnPropertySymbols(e) ];
-                for (const t of r) s[t] = n(e[t]);
-                return s;
+                const r = Array.isArray(e) ? [] : Object.create(Object.getPrototypeOf(e));
+                t.set(e, r);
+                const s = [ ...Object.keys(e), ...Object.getOwnPropertySymbols(e) ];
+                for (const t of s) r[t] = n(e[t]);
+                return r;
             };
             return n(e);
-        }, l = (e, t) => {
+        }, i = (e, t) => {
             if (e === t) return !0;
             if (null === e || null === t) return e === t;
             if ("object" != typeof e || "object" != typeof t) return e === t;
             if (Array.isArray(e) && Array.isArray(t)) {
                 if (e.length !== t.length) return !1;
-                for (let n = 0; n < e.length; n++) if (!l(e[n], t[n])) return !1;
+                for (let n = 0; n < e.length; n++) if (!i(e[n], t[n])) return !1;
                 return !0;
             }
-            const n = Object.keys(e), s = Object.keys(t);
-            if (n.length !== s.length) return !1;
-            for (let s = 0; s < n.length; s++) {
-                const r = n[s];
-                if (!(r in t) || !l(e[r], t[r])) return !1;
+            const n = Object.keys(e), r = Object.keys(t);
+            if (n.length !== r.length) return !1;
+            for (let r = 0; r < n.length; r++) {
+                const s = n[r];
+                if (!(s in t) || !i(e[s], t[s])) return !1;
             }
             return !0;
         };
     }
-}), p = {};
+}), h = {};
 
 ((e, t) => {
-    for (var n in t) d(e, n, {
+    for (var n in t) u(e, n, {
         get: t[n],
         enumerable: !0
     });
-})(p, {
-    SyncEngine: () => u,
-    createSyncEngine: () => y
+})(h, {
+    SyncEngine: () => c,
+    createSyncEngine: () => l
 });
 
-var m = f({
+var g = y({
     "core/sync.ts"() {
-        h(), u = class {
+        p(), c = class {
             store;
             config;
             pendingQueue=new Map;
@@ -121,7 +124,7 @@ var m = f({
                 const n = this.store._getVersion(e) || 1;
                 this.pendingQueue.set(e, {
                     key: e,
-                    value: c(t),
+                    value: a(t),
                     timestamp: Date.now(),
                     version: n
                 }), this._notifyStateChange(), this.syncTimer && clearTimeout(this.syncTimer), this.syncTimer = setTimeout(() => {
@@ -138,10 +141,10 @@ var m = f({
                     duration: 0
                 };
                 this._isSyncing = !0, this._notifyStateChange();
-                const e = Date.now(), t = [], n = [], s = [];
+                const e = Date.now(), t = [], n = [], r = [];
                 try {
-                    const r = Array.from(this.pendingQueue.values());
-                    if (0 === r.length) return this._isSyncing = !1, this._notifyStateChange(), {
+                    const s = Array.from(this.pendingQueue.values());
+                    if (0 === s.length) return this._isSyncing = !1, this._notifyStateChange(), {
                         success: !0,
                         syncedKeys: [],
                         conflicts: [],
@@ -149,42 +152,42 @@ var m = f({
                         timestamp: Date.now(),
                         duration: Date.now() - e
                     };
-                    await this._fetchRemoteVersions(r.map(e => e.key));
-                    for (const e of r) try {
-                        const s = this.remoteVersions.get(e.key);
-                        if (s) if (s.version >= e.version) {
-                            const r = {
+                    await this._fetchRemoteVersions(s.map(e => e.key));
+                    for (const e of s) try {
+                        const r = this.remoteVersions.get(e.key);
+                        if (r) if (r.version >= e.version) {
+                            const s = {
                                 key: e.key,
                                 localValue: e.value,
-                                remoteValue: s.value,
+                                remoteValue: r.value,
                                 localVersion: e.version,
-                                remoteVersion: s.version,
+                                remoteVersion: r.version,
                                 timestamp: e.timestamp
                             };
-                            n.push(r);
-                            const o = this.config.onConflict(r);
-                            await this._resolveConflict(e, s, o), t.push(e.key), this.pendingQueue.delete(e.key);
+                            n.push(s);
+                            const o = this.config.onConflict(s);
+                            await this._resolveConflict(e, r, o), t.push(e.key), this.pendingQueue.delete(e.key);
                         } else await this._pushChange(e), t.push(e.key), this.pendingQueue.delete(e.key); else await this._pushChange(e), 
                         t.push(e.key), this.pendingQueue.delete(e.key);
                     } catch (t) {
-                        s.push(`Failed to sync "${e.key}": ${t}`);
+                        r.push(`Failed to sync "${e.key}": ${t}`);
                     }
                     const o = {
-                        success: 0 === s.length,
+                        success: 0 === r.length,
                         syncedKeys: t,
                         conflicts: n,
-                        errors: s,
+                        errors: r,
                         timestamp: Date.now(),
                         duration: Date.now() - e
                     };
                     return this.config.onSync(o), o;
-                } catch (r) {
-                    const o = `Sync failed: ${r}`;
-                    return s.push(o), {
+                } catch (s) {
+                    const o = `Sync failed: ${s}`;
+                    return r.push(o), {
                         success: !1,
                         syncedKeys: t,
                         conflicts: n,
-                        errors: s,
+                        errors: r,
                         timestamp: Date.now(),
                         duration: Date.now() - e
                     };
@@ -215,7 +218,7 @@ var m = f({
             async _pushChange(e) {
                 let t = 0;
                 for (;t < this.config.maxRetries; ) try {
-                    const n = this._getAuthToken(), s = await this.config.fetch(`${this.config.endpoint}/sync`, {
+                    const n = this._getAuthToken(), r = await this.config.fetch(`${this.config.endpoint}/sync`, {
                         method: "POST",
                         headers: {
                             "Content-Type": "application/json",
@@ -230,8 +233,8 @@ var m = f({
                             timestamp: e.timestamp
                         })
                     });
-                    if (s.ok) {
-                        const t = await s.json();
+                    if (r.ok) {
+                        const t = await r.json();
                         return void (t.version && this.remoteVersions.set(e.key, {
                             version: t.version,
                             timestamp: t.timestamp || Date.now(),
@@ -288,9 +291,479 @@ var m = f({
                 this.syncTimer && clearTimeout(this.syncTimer), this.pendingQueue.clear(), this.onlineStatusListeners.clear(), 
                 this.syncStateListeners.clear();
             }
-        }, y = (e, t) => new u(e, t);
+        }, l = (e, t) => new c(e, t);
+    }
+}), m = Symbol.for("immer-nothing"), _ = Symbol.for("immer-draftable"), S = Symbol.for("immer-state"), w = [ function(e) {
+    return `The plugin for '${e}' has not been loaded into Immer. To enable the plugin, import and call \`enable${e}()\` when initializing your application.`;
+}, function(e) {
+    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 '${e}'`;
+}, "This object has been frozen and should not be mutated", function(e) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + e;
+}, "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(e) {
+    return `'current' expects a draft, got: ${e}`;
+}, "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(e) {
+    return `'original' expects a draft, got: ${e}`;
+} ];
+
+function b(e, ...t) {
+    {
+        const n = w[e], r = J(n) ? n.apply(null, t) : n;
+        throw new Error(`[Immer] ${r}`);
+    }
+}
+
+var v = Object, E = v.getPrototypeOf, k = "constructor", O = "prototype", C = "configurable", D = "enumerable", M = "writable", A = "value", j = e => !!e && !!e[S];
+
+function R(e) {
+    return !!e && (I(e) || U(e) || !!e[_] || !!e[k]?.[_] || L(e) || F(e));
+}
+
+var P = v[O][k].toString(), T = new WeakMap;
+
+function I(e) {
+    if (!e || !K(e)) return !1;
+    const t = E(e);
+    if (null === t || t === v[O]) return !0;
+    const n = v.hasOwnProperty.call(t, k) && t[k];
+    if (n === Object) return !0;
+    if (!J(n)) return !1;
+    let r = T.get(n);
+    return void 0 === r && (r = Function.toString.call(n), T.set(n, r)), r === P;
+}
+
+function z(e, t, n = !0) {
+    if (0 === x(e)) {
+        (n ? Reflect.ownKeys(e) : v.keys(e)).forEach(n => {
+            t(n, e[n], e);
+        });
+    } else e.forEach((n, r) => t(r, n, e));
+}
+
+function x(e) {
+    const t = e[S];
+    return t ? t.type_ : U(e) ? 1 : L(e) ? 2 : F(e) ? 3 : 0;
+}
+
+var $ = (e, t, n = x(e)) => 2 === n ? e.has(t) : v[O].hasOwnProperty.call(e, t), V = (e, t, n = x(e)) => 2 === n ? e.get(t) : e[t], N = (e, t, n, r = x(e)) => {
+    2 === r ? e.set(t, n) : 3 === r ? e.add(n) : e[t] = n;
+};
+
+var U = Array.isArray, L = e => e instanceof Map, F = e => e instanceof Set, K = e => "object" == typeof e, J = e => "function" == typeof e, B = e => "boolean" == typeof e;
+
+var W = e => e.copy_ || e.base_, Q = e => e.modified_ ? e.copy_ : e.base_;
+
+function q(e, t) {
+    if (L(e)) return new Map(e);
+    if (F(e)) return new Set(e);
+    if (U(e)) return Array[O].slice.call(e);
+    const n = I(e);
+    if (!0 === t || "class_only" === t && !n) {
+        const t = v.getOwnPropertyDescriptors(e);
+        delete t[S];
+        let n = Reflect.ownKeys(t);
+        for (let r = 0; r < n.length; r++) {
+            const s = n[r], o = t[s];
+            !1 === o[M] && (o[M] = !0, o[C] = !0), (o.get || o.set) && (t[s] = {
+                [C]: !0,
+                [M]: !0,
+                [D]: o[D],
+                [A]: e[s]
+            });
+        }
+        return v.create(E(e), t);
+    }
+    {
+        const t = E(e);
+        if (null !== t && n) return {
+            ...e
+        };
+        const r = v.create(t);
+        return v.assign(r, e);
+    }
+}
+
+function H(e, t = !1) {
+    return X(e) || j(e) || !R(e) || (x(e) > 1 && v.defineProperties(e, {
+        set: G,
+        add: G,
+        clear: G,
+        delete: G
+    }), v.freeze(e), t && z(e, (e, t) => {
+        H(t, !0);
+    }, !1)), e;
+}
+
+var G = {
+    [A]: function() {
+        b(2);
+    }
+};
+
+function X(e) {
+    return null === e || !K(e) || v.isFrozen(e);
+}
+
+var Z = "MapSet", Y = "Patches", ee = "ArrayMethods", te = {};
+
+function ne(e) {
+    const t = te[e];
+    return t || b(0, e), t;
+}
+
+var re, se = e => !!te[e], oe = () => re;
+
+function ae(e, t) {
+    t && (e.patchPlugin_ = ne(Y), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+
+function ie(e) {
+    ce(e), e.drafts_.forEach(ue), e.drafts_ = null;
+}
+
+function ce(e) {
+    e === re && (re = e.parent_);
+}
+
+var le = e => re = {
+    drafts_: [],
+    parent_: re,
+    immer_: e,
+    canAutoFreeze_: !0,
+    unfinalizedDrafts_: 0,
+    handledSet_: new Set,
+    processedForPatches_: new Set,
+    mapSetPlugin_: se(Z) ? ne(Z) : void 0,
+    arrayMethodsPlugin_: se(ee) ? ne(ee) : void 0
+};
+
+function ue(e) {
+    const t = e[S];
+    0 === t.type_ || 1 === t.type_ ? t.revoke_() : t.revoked_ = !0;
+}
+
+function de(e, t) {
+    t.unfinalizedDrafts_ = t.drafts_.length;
+    const n = t.drafts_[0];
+    if (void 0 !== e && e !== n) {
+        n[S].modified_ && (ie(t), b(4)), R(e) && (e = fe(t, e));
+        const {patchPlugin_: r} = t;
+        r && r.generateReplacementPatches_(n[S].base_, e, t);
+    } else e = fe(t, n);
+    return function(e, t, n = !1) {
+        !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && H(t, n);
+    }(t, e, !0), ie(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), 
+    e !== m ? e : void 0;
+}
+
+function fe(e, t) {
+    if (X(t)) return t;
+    const n = t[S];
+    if (!n) {
+        return _e(t, e.handledSet_, e);
+    }
+    if (!pe(n, e)) return t;
+    if (!n.modified_) return n.base_;
+    if (!n.finalized_) {
+        const {callbacks_: t} = n;
+        if (t) for (;t.length > 0; ) {
+            t.pop()(e);
+        }
+        me(n, e);
+    }
+    return n.copy_;
+}
+
+function ye(e) {
+    e.finalized_ = !0, e.scope_.unfinalizedDrafts_--;
+}
+
+var pe = (e, t) => e.scope_ === t, he = [];
+
+function ge(e, t, n, r) {
+    const s = W(e), o = e.type_;
+    if (void 0 !== r) {
+        if (V(s, r, o) === t) return void N(s, r, n, o);
+    }
+    if (!e.draftLocations_) {
+        const t = e.draftLocations_ = new Map;
+        z(s, (e, n) => {
+            if (j(n)) {
+                const r = t.get(n) || [];
+                r.push(e), t.set(n, r);
+            }
+        });
+    }
+    const a = e.draftLocations_.get(t) ?? he;
+    for (const e of a) N(s, e, n, o);
+}
+
+function me(e, t) {
+    if (e.modified_ && !e.finalized_ && (3 === e.type_ || 1 === e.type_ && e.allIndicesReassigned_ || (e.assigned_?.size ?? 0) > 0)) {
+        const {patchPlugin_: n} = t;
+        if (n) {
+            const r = n.getPath(e);
+            r && n.generatePatches_(e, r, t);
+        }
+        ye(e);
     }
-}), w = (e, t) => {
+}
+
+function _e(e, t, n) {
+    return !n.immer_.autoFreeze_ && n.unfinalizedDrafts_ < 1 || j(e) || t.has(e) || !R(e) || X(e) || (t.add(e), 
+    z(e, (r, s) => {
+        if (j(s)) {
+            const t = s[S];
+            if (pe(t, n)) {
+                const n = Q(t);
+                N(e, r, n, e.type_), ye(t);
+            }
+        } else R(s) && _e(s, t, n);
+    })), e;
+}
+
+var Se = {
+    get(e, t) {
+        if (t === S) return e;
+        let n = e.scope_.arrayMethodsPlugin_;
+        const r = 1 === e.type_ && "string" == typeof t;
+        if (r && n?.isArrayOperationMethod(t)) return n.createMethodInterceptor(e, t);
+        const s = W(e);
+        if (!$(s, t, e.type_)) return function(e, t, n) {
+            const r = ve(t, n);
+            return r ? A in r ? r[A] : r.get?.call(e.draft_) : void 0;
+        }(e, s, t);
+        const o = s[t];
+        if (e.finalized_ || !R(o)) return o;
+        if (r && e.operationMethod && n?.isMutatingArrayMethod(e.operationMethod) && function(e) {
+            const t = +e;
+            return Number.isInteger(t) && String(t) === e;
+        }(t)) return o;
+        if (o === be(e.base_, t)) {
+            ke(e);
+            const n = 1 === e.type_ ? +t : t, r = Oe(e.scope_, o, e, n);
+            return e.copy_[n] = r;
+        }
+        return o;
+    },
+    has: (e, t) => t in W(e),
+    ownKeys: e => Reflect.ownKeys(W(e)),
+    set(e, t, n) {
+        const r = ve(W(e), t);
+        if (r?.set) return r.set.call(e.draft_, n), !0;
+        if (!e.modified_) {
+            const r = be(W(e), t), a = r?.[S];
+            if (a && a.base_ === n) return e.copy_[t] = n, e.assigned_.set(t, !1), !0;
+            if (((s = n) === (o = r) ? 0 !== s || 1 / s == 1 / o : s != s && o != o) && (void 0 !== n || $(e.base_, t, e.type_))) return !0;
+            ke(e), Ee(e);
+        }
+        var s, o;
+        return e.copy_[t] === n && (void 0 !== n || t in e.copy_) || Number.isNaN(n) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = n, 
+        e.assigned_.set(t, !0), function(e, t, n) {
+            const {scope_: r} = e;
+            if (j(n)) {
+                const s = n[S];
+                pe(s, r) && s.callbacks_.push(function() {
+                    ke(e);
+                    const r = Q(s);
+                    ge(e, n, r, t);
+                });
+            } else R(n) && e.callbacks_.push(function() {
+                const s = W(e);
+                3 === e.type_ ? s.has(n) && _e(n, r.handledSet_, r) : V(s, t, e.type_) === n && r.drafts_.length > 1 && !0 === (e.assigned_.get(t) ?? !1) && e.copy_ && _e(V(e.copy_, t, e.type_), r.handledSet_, r);
+            });
+        }(e, t, n)), !0;
+    },
+    deleteProperty: (e, t) => (ke(e), void 0 !== be(e.base_, t) || t in e.base_ ? (e.assigned_.set(t, !1), 
+    Ee(e)) : e.assigned_.delete(t), e.copy_ && delete e.copy_[t], !0),
+    getOwnPropertyDescriptor(e, t) {
+        const n = W(e), r = Reflect.getOwnPropertyDescriptor(n, t);
+        return r ? {
+            [M]: !0,
+            [C]: 1 !== e.type_ || "length" !== t,
+            [D]: r[D],
+            [A]: n[t]
+        } : r;
+    },
+    defineProperty() {
+        b(11);
+    },
+    getPrototypeOf: e => E(e.base_),
+    setPrototypeOf() {
+        b(12);
+    }
+}, we = {};
+
+for (let e in Se) {
+    let t = Se[e];
+    we[e] = function() {
+        const e = arguments;
+        return e[0] = e[0][0], t.apply(this, e);
+    };
+}
+
+function be(e, t) {
+    const n = e[S];
+    return (n ? W(n) : e)[t];
+}
+
+function ve(e, t) {
+    if (!(t in e)) return;
+    let n = E(e);
+    for (;n; ) {
+        const e = Object.getOwnPropertyDescriptor(n, t);
+        if (e) return e;
+        n = E(n);
+    }
+}
+
+function Ee(e) {
+    e.modified_ || (e.modified_ = !0, e.parent_ && Ee(e.parent_));
+}
+
+function ke(e) {
+    e.copy_ || (e.assigned_ = new Map, e.copy_ = q(e.base_, e.scope_.immer_.useStrictShallowCopy_));
+}
+
+we.deleteProperty = function(e, t) {
+    return isNaN(parseInt(t)) && b(13), we.set.call(this, e, t, void 0);
+}, we.set = function(e, t, n) {
+    return "length" !== t && isNaN(parseInt(t)) && b(14), Se.set.call(this, e[0], t, n, e[0]);
+};
+
+function Oe(e, t, n, r) {
+    const [s, o] = L(t) ? ne(Z).proxyMap_(t, n) : F(t) ? ne(Z).proxySet_(t, n) : function(e, t) {
+        const n = U(e), r = {
+            type_: n ? 1 : 0,
+            scope_: t ? t.scope_ : oe(),
+            modified_: !1,
+            finalized_: !1,
+            assigned_: void 0,
+            parent_: t,
+            base_: e,
+            draft_: null,
+            copy_: null,
+            revoke_: null,
+            isManual_: !1,
+            callbacks_: void 0
+        };
+        let s = r, o = Se;
+        n && (s = [ r ], o = we);
+        const {revoke: a, proxy: i} = Proxy.revocable(s, o);
+        return r.draft_ = i, r.revoke_ = a, [ i, r ];
+    }(t, n);
+    return (n?.scope_ ?? oe()).drafts_.push(s), o.callbacks_ = n?.callbacks_ ?? [], 
+    o.key_ = r, n && void 0 !== r ? function(e, t, n) {
+        e.callbacks_.push(function(r) {
+            const s = t;
+            if (!s || !pe(s, r)) return;
+            r.mapSetPlugin_?.fixSetContents(s);
+            const o = Q(s);
+            ge(e, s.draft_ ?? s, o, n), me(s, r);
+        });
+    }(n, o, r) : o.callbacks_.push(function(e) {
+        e.mapSetPlugin_?.fixSetContents(o);
+        const {patchPlugin_: t} = e;
+        o.modified_ && t && t.generatePatches_(o, [], e);
+    }), s;
+}
+
+function Ce(e) {
+    if (!R(e) || X(e)) return e;
+    const t = e[S];
+    let n, r = !0;
+    if (t) {
+        if (!t.modified_) return t.base_;
+        t.finalized_ = !0, n = q(e, t.scope_.immer_.useStrictShallowCopy_), r = t.scope_.immer_.shouldUseStrictIteration();
+    } else n = q(e, !0);
+    return z(n, (e, t) => {
+        N(n, e, Ce(t));
+    }, r), t && (t.finalized_ = !1), n;
+}
+
+var De = (new class {
+    constructor(e) {
+        this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !1, 
+        this.produce = (e, t, n) => {
+            if (J(e) && !J(t)) {
+                const n = t;
+                t = e;
+                const r = this;
+                return function(e = n, ...s) {
+                    return r.produce(e, e => t.call(this, e, ...s));
+                };
+            }
+            let r;
+            if (J(t) || b(6), void 0 === n || J(n) || b(7), R(e)) {
+                const s = le(this), o = Oe(s, e, void 0);
+                let a = !0;
+                try {
+                    r = t(o), a = !1;
+                } finally {
+                    a ? ie(s) : ce(s);
+                }
+                return ae(s, n), de(r, s);
+            }
+            if (!e || !K(e)) {
+                if (r = t(e), void 0 === r && (r = e), r === m && (r = void 0), this.autoFreeze_ && H(r, !0), 
+                n) {
+                    const t = [], s = [];
+                    ne(Y).generateReplacementPatches_(e, r, {
+                        patches_: t,
+                        inversePatches_: s
+                    }), n(t, s);
+                }
+                return r;
+            }
+            b(1, e);
+        }, this.produceWithPatches = (e, t) => {
+            if (J(e)) return (t, ...n) => this.produceWithPatches(t, t => e(t, ...n));
+            let n, r;
+            return [ this.produce(e, t, (e, t) => {
+                n = e, r = t;
+            }), n, r ];
+        }, B(e?.autoFreeze) && this.setAutoFreeze(e.autoFreeze), B(e?.useStrictShallowCopy) && this.setUseStrictShallowCopy(e.useStrictShallowCopy), 
+        B(e?.useStrictIteration) && this.setUseStrictIteration(e.useStrictIteration);
+    }
+    createDraft(e) {
+        R(e) || b(8), j(e) && (e = function(e) {
+            j(e) || b(10, e);
+            return Ce(e);
+        }(e));
+        const t = le(this), n = Oe(t, e, void 0);
+        return n[S].isManual_ = !0, ce(t), n;
+    }
+    finishDraft(e, t) {
+        const n = e && e[S];
+        n && n.isManual_ || b(9);
+        const {scope_: r} = n;
+        return ae(r, t), de(void 0, r);
+    }
+    setAutoFreeze(e) {
+        this.autoFreeze_ = e;
+    }
+    setUseStrictShallowCopy(e) {
+        this.useStrictShallowCopy_ = e;
+    }
+    setUseStrictIteration(e) {
+        this.useStrictIteration_ = e;
+    }
+    shouldUseStrictIteration() {
+        return this.useStrictIteration_;
+    }
+    applyPatches(e, t) {
+        let n;
+        for (n = t.length - 1; n >= 0; n--) {
+            const r = t[n];
+            if (0 === r.path.length && "replace" === r.op) {
+                e = r.value;
+                break;
+            }
+        }
+        n > -1 && (t = t.slice(n + 1));
+        const r = ne(Y).applyPatches_;
+        return j(e) ? r(e, t) : this.produce(e, e => r(e, t));
+    }
+}).produce, Me = (e, t) => {
     const n = Date.now();
     if (/\(\.*\+\?\)\+/.test(e) || /\(\.*\?\)\*/.test(e)) return !1;
     if (e.length > 500) return !1;
@@ -301,28 +774,28 @@ var m = f({
     } catch {
         return !1;
     }
-}, S = () => {
+}, Ae = () => {
     if ("undefined" != typeof crypto && "function" == typeof crypto.randomUUID) try {
         return crypto.randomUUID();
     } catch {}
     throw new Error("Cryptographically secure random UUID generation is required but crypto.randomUUID is unavailable. Please use a browser or environment with Web Crypto API support.");
-}, v = "undefined" != typeof crypto && void 0 !== crypto.subtle && "function" == typeof crypto.subtle.generateKey, b = async (e, t, n = 6e5) => {
-    if (!v) throw new Error("Web Crypto API not available");
-    const s = await crypto.subtle.importKey("raw", (new TextEncoder).encode(e), "PBKDF2", !1, [ "deriveKey" ]);
+}, je = "undefined" != typeof crypto && void 0 !== crypto.subtle && "function" == typeof crypto.subtle.generateKey, Re = async (e, t, n = 6e5) => {
+    if (!je) throw new Error("Web Crypto API not available");
+    const r = await crypto.subtle.importKey("raw", (new TextEncoder).encode(e), "PBKDF2", !1, [ "deriveKey" ]);
     return {
         key: await crypto.subtle.deriveKey({
             name: "PBKDF2",
             salt: new Uint8Array(t),
             iterations: n,
             hash: "SHA-256"
-        }, s, {
+        }, r, {
             name: "AES-GCM",
             length: 256
         }, !0, [ "encrypt", "decrypt" ]),
         iv: crypto.getRandomValues(new Uint8Array(12))
     };
-}, E = (e = 32) => crypto.getRandomValues(new Uint8Array(e)), _ = async () => {
-    if (!v) throw new Error("Web Crypto API not available");
+}, Pe = (e = 32) => crypto.getRandomValues(new Uint8Array(e)), Te = async () => {
+    if (!je) throw new Error("Web Crypto API not available");
     return {
         key: await crypto.subtle.generateKey({
             name: "AES-GCM",
@@ -330,47 +803,47 @@ var m = f({
         }, !0, [ "encrypt", "decrypt" ]),
         iv: crypto.getRandomValues(new Uint8Array(12))
     };
-}, k = async e => {
+}, Ie = async e => {
     const t = await crypto.subtle.exportKey("raw", e.key);
     return {
         key: btoa(String.fromCharCode(...new Uint8Array(t))),
         iv: btoa(String.fromCharCode(...e.iv))
     };
-}, C = async (e, t) => {
-    const n = Uint8Array.from(atob(e), e => e.charCodeAt(0)), s = Uint8Array.from(atob(t), e => e.charCodeAt(0));
+}, ze = async (e, t) => {
+    const n = Uint8Array.from(atob(e), e => e.charCodeAt(0)), r = Uint8Array.from(atob(t), e => e.charCodeAt(0));
     return {
         key: await crypto.subtle.importKey("raw", n, {
             name: "AES-GCM",
             length: 256
         }, !0, [ "encrypt", "decrypt" ]),
-        iv: s
+        iv: r
     };
-}, O = async (e, t) => {
-    const n = (new TextEncoder).encode(JSON.stringify(e)), s = await crypto.subtle.encrypt({
+}, xe = async (e, t) => {
+    const n = (new TextEncoder).encode(JSON.stringify(e)), r = await crypto.subtle.encrypt({
         name: "AES-GCM",
         iv: t.iv
-    }, t.key, n), r = new Uint8Array(t.iv.length + s.byteLength);
-    return r.set(t.iv), r.set(new Uint8Array(s), t.iv.length), btoa(String.fromCharCode(...r));
-}, D = async (e, t) => {
-    const n = Uint8Array.from(atob(e), e => e.charCodeAt(0)), s = n.slice(0, 12), r = n.slice(12), o = await crypto.subtle.decrypt({
+    }, t.key, n), s = new Uint8Array(t.iv.length + r.byteLength);
+    return s.set(t.iv), s.set(new Uint8Array(r), t.iv.length), btoa(String.fromCharCode(...s));
+}, $e = async (e, t) => {
+    const n = Uint8Array.from(atob(e), e => e.charCodeAt(0)), r = n.slice(0, 12), s = n.slice(12), o = await crypto.subtle.decrypt({
         name: "AES-GCM",
-        iv: s
-    }, t.key, r);
+        iv: r
+    }, t.key, s);
     return JSON.parse((new TextDecoder).decode(o));
-}, A = null, M = e => {
-    A = e;
-}, R = e => {
-    A && A(e);
-}, T = (e, t, n) => {
+}, Ve = null, Ne = e => {
+    Ve = e;
+}, Ue = e => {
+    Ve && Ve(e);
+}, Le = (e, t, n) => {
     e.set(t instanceof RegExp ? t.source : t, n);
-}, j = (e, t, n, s) => {
+}, Fe = (e, t, n, r) => {
     if (0 === e.size) return !0;
-    for (const [r, o] of e) {
+    for (const [s, o] of e) {
         let e;
-        if (e = "function" == typeof r ? r(t, s) : w(r, t), e) return o.includes(n) || o.includes("admin");
+        if (e = "function" == typeof s ? s(t, r) : Me(s, t), e) return o.includes(n) || o.includes("admin");
     }
     return !1;
-}, V = e => {
+}, Ke = e => {
     if ("string" == typeof e) {
         let t = e.replace(/&#[xX]?[0-9a-fA-F]+;?/g, e => {
             const t = e.match(/&#x([0-9a-fA-F]+);?/i);
@@ -386,35 +859,35 @@ var m = f({
     if (e && "object" == typeof e && !Array.isArray(e)) {
         if (Object.getPrototypeOf(e) === Object.prototype) {
             const t = {};
-            for (const [n, s] of Object.entries(e)) t[n] = V(s);
+            for (const [n, r] of Object.entries(e)) t[n] = Ke(r);
             return t;
         }
         return e;
     }
-    return Array.isArray(e) ? e.map(e => V(e)) : e;
-}, I = e => /^([a-zA-Z0-9_.-][a-zA-Z0-9_.-]*)$/.test(e) && e.length <= 256 && e.length > 0, $ = (e, t, n, s) => {
-    const r = {
-        id: S(),
+    return Array.isArray(e) ? e.map(e => Ke(e)) : e;
+}, Je = e => /^([a-zA-Z0-9_.-][a-zA-Z0-9_.-]*)$/.test(e) && e.length <= 256 && e.length > 0, Be = (e, t, n, r) => {
+    const s = {
+        id: Ae(),
         purpose: n,
-        granted: s,
+        granted: r,
         timestamp: Date.now()
     }, o = e.get(t) || [];
-    return o.push(r), e.set(t, o), R({
+    return o.push(s), e.set(t, o), Ue({
         timestamp: Date.now(),
         action: "set",
         key: `consent:${n}`,
         userId: t,
         success: !0
-    }), r;
+    }), s;
 };
 
-h();
+p();
 
-var U = e => `${e}_`;
+var We = e => `${e}_`;
 
-h();
+p();
 
-var x = () => {
+var Qe = () => {
     try {
         0;
         const e = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof window ? window : {};
@@ -422,31 +895,42 @@ var x = () => {
     } catch {
         return !1;
     }
-}, P = () => "undefined" != typeof window ? window.localStorage : null, N = n => {
-    const s = new Map, r = new Map, o = new Map, a = new Set, i = new Map, u = new Set, y = new Map, d = new Map, g = new Map, f = new Map, h = new Map, w = new Map, S = new Map, v = new Map, b = n?.namespace || "gstate", E = n?.silent ?? !1, _ = n?.debounceTime ?? 150, k = n?.version ?? 0, C = n?.storage || P(), M = n?.onError, N = n?.maxObjectSize ?? 0, L = n?.maxTotalSize ?? 0, z = n?.encryptionKey ?? null, K = n?.validateInput ?? !0, J = n?.auditEnabled ?? !0, B = n?.userId, Q = n?.immer ?? !0, W = n?.persistByDefault ?? n?.persistence ?? n?.persist ?? !1;
-    n?.accessRules && n.accessRules.forEach(e => T(S, e.pattern, e.permissions));
-    let F, G = !1, q = !1, X = !1, Z = 0, H = null, Y = null;
-    const ee = new Promise(e => {
-        F = e;
-    }), te = () => ({
-        store: s,
-        versions: r,
-        sizes: o,
-        totalSize: Z,
-        storage: C,
-        config: n || {},
-        diskQueue: h,
-        encryptionKey: z,
-        audit: oe,
-        onError: M,
-        silent: E,
-        debounceTime: _,
-        currentVersion: k
-    }), ne = () => ({
+}, qe = () => "undefined" != typeof window ? window.localStorage : null, He = () => {
+    const e = new Map;
+    return {
+        getItem: t => e.get(t) || null,
+        setItem: (t, n) => e.set(t, n),
+        removeItem: t => e.delete(t),
+        key: t => Array.from(e.keys())[t] || null,
+        get length() {
+            return e.size;
+        }
+    };
+}, Ge = e => {
+    const t = new Map, n = new Map, r = new Map, s = new Set, o = new Map, c = new Set, l = new Map, u = new Map, d = new Map, f = new Map, y = new Map, p = new Map, m = new Map, _ = new Map, S = e?.namespace || "gstate", w = e?.silent ?? !1, b = e?.debounceTime ?? 150, v = e?.version ?? 0, E = e?.storage || qe(), k = e?.onError, O = e?.maxObjectSize ?? 0, C = e?.maxTotalSize ?? 0, D = e?.encryptionKey ?? null, M = e?.validateInput ?? !0, A = e?.auditEnabled ?? !0, j = e?.userId, R = e?.immer ?? !0, P = e?.persistByDefault ?? e?.persistence ?? e?.persist ?? !1;
+    e?.accessRules && e.accessRules.forEach(e => Le(m, e.pattern, e.permissions));
+    let T, I = !1, z = !1, x = !1, $ = 0, V = null, N = null;
+    const U = new Promise(e => {
+        T = e;
+    }), L = () => `${S}_`, F = () => ({
+        store: t,
+        versions: n,
+        sizes: r,
+        totalSize: $,
+        storage: E,
+        config: e || {},
+        diskQueue: y,
+        encryptionKey: D,
+        audit: W,
+        onError: k,
+        silent: w,
+        debounceTime: b,
+        currentVersion: v
+    }), K = () => ({
         plugins: f,
-        onError: M,
-        silent: E
-    }), se = e => {
+        onError: k,
+        silent: w
+    }), J = e => {
         if (null == e) return 0;
         const t = typeof e;
         if ("boolean" === t) return 4;
@@ -454,108 +938,108 @@ var x = () => {
         if ("string" === t) return 2 * e.length;
         if ("object" !== t) return 0;
         let n = 0;
-        const s = [ e ], r = new WeakSet;
-        for (;s.length > 0; ) {
-            const e = s.pop();
+        const r = [ e ], s = new WeakSet;
+        for (;r.length > 0; ) {
+            const e = r.pop();
             if ("boolean" == typeof e) n += 4; else if ("number" == typeof e) n += 8; else if ("string" == typeof e) n += 2 * e.length; else if ("object" == typeof e && null !== e) {
                 const t = e;
-                if (r.has(t)) continue;
-                if (r.add(t), Array.isArray(t)) for (let e = 0; e < t.length; e++) s.push(t[e]); else for (const e of Object.keys(t)) n += 2 * e.length, 
-                s.push(t[e]);
+                if (s.has(t)) continue;
+                if (s.add(t), Array.isArray(t)) for (let e = 0; e < t.length; e++) r.push(t[e]); else for (const e of Object.keys(t)) n += 2 * e.length, 
+                r.push(t[e]);
             }
         }
         return n;
-    }, re = (e, t) => {
+    }, B = (e, t) => {
         ((e, t, n) => {
-            if (0 !== e.plugins.size) for (const s of e.plugins.values()) {
-                const r = s.hooks?.[t];
-                if (r) try {
-                    r(n);
-                } catch (r) {
-                    const o = r instanceof Error ? r : new Error(String(r));
+            if (0 !== e.plugins.size) for (const r of e.plugins.values()) {
+                const s = r.hooks?.[t];
+                if (s) try {
+                    s(n);
+                } catch (s) {
+                    const o = s instanceof Error ? s : new Error(String(s));
                     e.onError ? e.onError(o, {
-                        operation: `plugin:${s.name}:${t}`,
+                        operation: `plugin:${r.name}:${t}`,
                         key: n.key
                     }) : e.silent;
                 }
             }
-        })(ne(), e, t);
-    }, oe = (e, t, n, s) => {
-        J && null !== A && R && R({
+        })(K(), e, t);
+    }, W = (e, t, n, r) => {
+        A && null !== Ve && Ue && Ue({
             timestamp: Date.now(),
             action: e,
             key: t,
-            userId: B,
+            userId: j,
             success: n,
-            error: s
+            error: r
         });
-    }, ae = e => {
-        const n = d.get(e);
-        if (!n) return;
-        const s = new Set, o = n.selector(e => (s.add(e), d.has(e) ? d.get(e).lastValue : ue.get(e)));
-        n.deps.forEach(t => {
-            if (!s.has(t)) {
-                const n = g.get(t);
-                n && (n.delete(e), 0 === n.size && g.delete(t));
+    }, Q = e => {
+        const t = u.get(e);
+        if (!t) return;
+        const r = new Set, s = t.selector(e => (r.add(e), u.has(e) ? u.get(e).lastValue : Z.get(e)));
+        t.deps.forEach(t => {
+            if (!r.has(t)) {
+                const n = d.get(t);
+                n && (n.delete(e), 0 === n.size && d.delete(t));
             }
-        }), s.forEach(t => {
-            n.deps.has(t) || (g.has(t) || g.set(t, new Set), g.get(t).add(e));
-        }), n.deps = s, l(n.lastValue, o) || (n.lastValue = Q && null !== o && "object" == typeof o ? t(c(o), !0) : o, 
-        r.set(e, (r.get(e) || 0) + 1), ie(e));
-    }, ie = e => {
+        }), r.forEach(n => {
+            t.deps.has(n) || (d.has(n) || d.set(n, new Set), d.get(n).add(e));
+        }), t.deps = r, i(t.lastValue, s) || (t.lastValue = R && null !== s && "object" == typeof s ? H(a(s), !0) : s, 
+        n.set(e, (n.get(e) || 0) + 1), q(e));
+    }, q = e => {
         if (e) {
-            if (g.has(e)) {
-                const t = g.get(e);
-                for (const e of t) ae(e);
+            if (d.has(e)) {
+                const t = d.get(e);
+                for (const e of t) Q(e);
             }
-            const t = y.get(e);
+            const t = l.get(e);
             if (t) {
-                const n = ue.get(e);
-                for (const s of t) try {
-                    s(n);
+                const n = Z.get(e);
+                for (const r of t) try {
+                    r(n);
                 } catch (t) {
                     const n = t instanceof Error ? t : new Error(String(t));
-                    M && M(n, {
+                    k && k(n, {
                         operation: "watcher",
                         key: e
                     });
                 }
             }
-            const n = i.get(e);
+            const n = o.get(e);
             if (n) for (const t of n) try {
                 t();
             } catch (t) {
                 const n = t instanceof Error ? t : new Error(String(t));
-                M && M(n, {
+                k && k(n, {
                     operation: "keyListener",
                     key: e
                 });
             }
         }
-        if (G) q = !0; else for (const e of a) try {
+        if (I) z = !0; else for (const e of s) try {
             e();
         } catch (e) {
             const t = e instanceof Error ? e : new Error(String(e));
-            M && M(t, {
+            k && k(t, {
                 operation: "listener"
             });
         }
-    }, ce = async () => {
+    }, G = async () => {
         (async e => {
             if (!e.storage) return;
-            const {store: t, config: n, diskQueue: s, storage: r, encryptionKey: o, audit: a, onError: i, silent: c, currentVersion: l} = e, u = U(n.namespace || "gstate");
+            const {store: t, config: n, diskQueue: r, storage: s, encryptionKey: o, audit: a, onError: i, silent: c, currentVersion: l} = e, u = We(n.namespace || "gstate");
             try {
                 const e = {};
-                let s;
+                let r;
                 t.forEach((t, n) => {
                     e[n] = t;
                 });
                 const o = n?.encoded;
-                s = o ? btoa(JSON.stringify(e)) : JSON.stringify(e), r.setItem(u.replace("_", ""), JSON.stringify({
+                r = o ? btoa(JSON.stringify(e)) : JSON.stringify(e), s.setItem(u.replace("_", ""), JSON.stringify({
                     v: 1,
                     t: Date.now(),
                     e: null,
-                    d: s,
+                    d: r,
                     _sys_v: l,
                     _b64: !!o || void 0
                 })), a("set", "FULL_STATE", !0);
@@ -566,21 +1050,21 @@ var x = () => {
                     key: "FULL_STATE"
                 });
             }
-            const y = Array.from(s.entries());
-            s.clear();
-            for (const [t, n] of y) try {
+            const d = Array.from(r.entries());
+            r.clear();
+            for (const [t, n] of d) try {
                 if (!t || !/^[a-zA-Z0-9_.-]+$/.test(t) || t.length > 256) continue;
-                let s = n.value;
+                let r = n.value;
                 const i = n.options.encoded || n.options.encrypted || n.options.secure;
                 if (n.options.encrypted) {
                     if (!o) throw new Error(`Encryption key missing for "${t}"`);
-                    s = await O(n.value, o);
-                } else i ? s = btoa(JSON.stringify(n.value)) : "object" == typeof n.value && null !== n.value && (s = JSON.stringify(n.value));
-                r.setItem(`${u}${t}`, JSON.stringify({
+                    r = await xe(n.value, o);
+                } else i ? r = btoa(JSON.stringify(n.value)) : "object" == typeof n.value && null !== n.value && (r = JSON.stringify(n.value));
+                s.setItem(`${u}${t}`, JSON.stringify({
                     v: e.versions.get(t) || 1,
                     t: Date.now(),
                     e: n.options.ttl ? Date.now() + n.options.ttl : null,
-                    d: s,
+                    d: r,
                     _sys_v: l,
                     _enc: !!n.options.encrypted || void 0,
                     _b64: !(!n.options.encoded && !n.options.secure) || void 0
@@ -592,140 +1076,141 @@ var x = () => {
                     key: t
                 });
             }
-        })(te());
-    }, le = {}, ue = {
-        _setSilently: (e, n) => {
-            const a = o.get(e) || 0, i = Q && null !== n && "object" == typeof n ? t(c(n), !0) : n, l = (N > 0 || L > 0) && !x() ? se(i) : 0;
-            Z = Z - a + l, o.set(e, l), s.set(e, i), r.set(e, (r.get(e) || 0) + 1), Y = null;
+        })(F());
+    }, X = {}, Z = {
+        _setSilently: (e, s) => {
+            const o = r.get(e) || 0, i = R && null !== s && "object" == typeof s ? H(a(s), !0) : s, c = (O > 0 || C > 0) && !Qe() ? J(i) : 0;
+            $ = $ - o + c, r.set(e, c), t.set(e, i), n.set(e, (n.get(e) || 0) + 1), N = null;
         },
         _registerMethod: (e, t, n) => {
-            const s = e => "__proto__" === e || "constructor" === e || "prototype" === e;
-            s(e) || s(t) || (le[e] || (le[e] = {}), le[e][t] = n);
+            const r = e => "__proto__" === e || "constructor" === e || "prototype" === e;
+            r(e) || r(t) || (X[e] || (X[e] = {}), X[e][t] = n);
         },
-        set: (a, i, u = {}) => {
-            const y = s.get(a), d = Q && "function" == typeof i ? e(y, i) : i;
-            if (K && !I(a)) return !1;
-            if (!j(S, a, "write", B)) return oe("set", a, !1, "RBAC Denied"), !1;
-            const g = K ? V(d) : d, f = o.get(a) || 0;
-            re("onBeforeSet", {
-                key: a,
-                value: g,
-                store: ue,
-                version: r.get(a) || 0
+        set: (s, o, c = {}) => {
+            const l = t.get(s), u = R && "function" == typeof o ? De(l, o) : o;
+            if (M && !Je(s)) return !1;
+            if (!Fe(m, s, "write", j)) return W("set", s, !1, "RBAC Denied"), !1;
+            const d = M ? Ke(u) : u, f = r.get(s) || 0;
+            B("onBeforeSet", {
+                key: s,
+                value: d,
+                store: Z,
+                version: n.get(s) || 0
             });
-            const p = Q && null !== g && "object" == typeof g ? t(c(g), !0) : g;
-            if (!l(y, p)) {
-                const e = (N > 0 || L > 0) && !x() ? se(p) : 0;
-                if (N > 0 && e > N) {
-                    const t = new Error(`Object size (${e} bytes) exceeds maxObjectSize (${N} bytes)`);
-                    M && M(t, {
+            const p = R && null !== d && "object" == typeof d ? H(a(d), !0) : d;
+            if (!i(l, p)) {
+                const o = (O > 0 || C > 0) && !Qe() ? J(p) : 0;
+                if (O > 0 && o > O) {
+                    const e = new Error(`Object size (${o} bytes) exceeds maxObjectSize (${O} bytes)`);
+                    return k && k(e, {
                         operation: "set",
-                        key: a
-                    });
+                        key: s
+                    }), !1;
                 }
-                if (L > 0) {
-                    const t = Z - f + e;
-                    if (t > L) {
-                        const e = new Error(`Total store size (${t} bytes) exceeds limit (${L} bytes)`);
-                        M && M(e, {
+                if (C > 0) {
+                    const e = $ - f + o;
+                    if (e > C) {
+                        const t = new Error(`Total store size (${e} bytes) exceeds limit (${C} bytes)`);
+                        return k && k(t, {
                             operation: "set"
-                        });
+                        }), !1;
                     }
                 }
-                Z = Z - f + e, o.set(a, e), s.set(a, p), r.set(a, (r.get(a) || 0) + 1), Y = null;
-                const t = u.persist ?? W;
-                return t && (h.set(a, {
+                $ = $ - f + o, r.set(s, o), t.set(s, p), n.set(s, (n.get(s) || 0) + 1), N = null;
+                const a = c.persist ?? P;
+                return a && (y.set(s, {
                     value: p,
                     options: {
-                        ...u,
-                        persist: t,
-                        encoded: u.encoded || n?.encoded
+                        ...c,
+                        persist: a,
+                        encoded: c.encoded || e?.encoded
                     }
-                }), H && clearTimeout(H), H = setTimeout(ce, _)), re("onSet", {
-                    key: a,
+                }), V && clearTimeout(V), V = setTimeout(G, b)), B("onSet", {
+                    key: s,
                     value: p,
-                    store: ue,
-                    version: r.get(a)
-                }), oe("set", a, !0), ie(a), !0;
+                    store: Z,
+                    version: n.get(s)
+                }), W("set", s, !0), q(s), !0;
             }
             return !1;
         },
         get: e => {
-            if (!j(S, e, "read", B)) return oe("get", e, !1, "RBAC Denied"), null;
-            const t = s.get(e);
-            return re("onGet", {
-                store: ue,
+            if (!Fe(m, e, "read", j)) return W("get", e, !1, "RBAC Denied"), null;
+            const n = t.get(e);
+            return B("onGet", {
+                store: Z,
                 key: e,
-                value: t
-            }), oe("get", e, !0), t;
+                value: n
+            }), W("get", e, !0), n;
         },
         compute: (e, t) => {
             try {
-                return d.has(e) || (d.set(e, {
+                return u.has(e) || (u.set(e, {
                     selector: t,
                     lastValue: null,
                     deps: new Set
-                }), ae(e)), d.get(e).lastValue;
+                }), Q(e)), u.get(e).lastValue;
             } catch (t) {
                 const n = t instanceof Error ? t : new Error(String(t));
-                return M && M(n, {
+                return k && k(n, {
                     operation: "compute",
                     key: e
                 }), null;
             }
         },
         watch: (e, t) => {
-            y.has(e) || y.set(e, new Set);
-            const n = y.get(e);
+            l.has(e) || l.set(e, new Set);
+            const n = l.get(e);
             return n.add(t), () => {
-                n.delete(t), 0 === n.size && y.delete(e);
+                n.delete(t), 0 === n.size && l.delete(e);
             };
         },
         remove: e => {
-            if (!j(S, e, "delete", B)) return oe("delete", e, !1, "RBAC Denied"), !1;
-            const t = s.get(e), n = s.delete(e);
-            return n && (Z -= o.get(e) || 0, o.delete(e), re("onRemove", {
-                store: ue,
+            if (!Fe(m, e, "delete", j)) return W("delete", e, !1, "RBAC Denied"), !1;
+            const s = t.get(e), o = t.delete(e);
+            return o && ($ -= r.get(e) || 0, r.delete(e), B("onRemove", {
+                store: Z,
                 key: e,
-                value: t
-            }), Y = null), r.set(e, (r.get(e) || 0) + 1), C && C.removeItem(`${b}_${e}`), oe("delete", e, !0), 
-            ie(e), n;
+                value: s
+            }), N = null), n.set(e, (n.get(e) || 0) + 1), E && E.removeItem(`${L()}${e}`), W("delete", e, !0), 
+            q(e), o;
         },
-        delete: e => ue.remove(e),
+        delete: e => Z.remove(e),
         deleteAll: () => {
-            if (Array.from(s.keys()).forEach(e => ue.remove(e)), C) {
-                const e = b + "_";
-                for (let t = 0; t < (C.length || 0); t++) {
-                    const n = C.key(t);
-                    n?.startsWith(e) && (C.removeItem(n), t--);
+            if (Array.from(t.keys()).forEach(e => Z.remove(e)), E) {
+                const e = L(), t = [], n = E.length || 0;
+                for (let r = 0; r < n; r++) {
+                    const n = E.key(r);
+                    n && n.startsWith(e) && t.push(n);
                 }
+                for (const e of t) E.removeItem(e);
             }
-            return Z = 0, o.clear(), Y = null, !0;
+            return $ = 0, r.clear(), N = null, !0;
         },
-        list: () => Object.fromEntries(s.entries()),
+        list: () => Object.fromEntries(t.entries()),
         use: e => {
-            u.add(e);
+            c.add(e);
         },
         transaction: e => {
-            G = !0, re("onTransaction", {
-                store: ue,
+            I = !0, B("onTransaction", {
+                store: Z,
                 key: "START"
             });
             try {
                 e();
             } finally {
-                G = !1, re("onTransaction", {
-                    store: ue,
+                I = !1, B("onTransaction", {
+                    store: Z,
                     key: "END"
-                }), q && (q = !1, ie());
+                }), z && (z = !1, q());
             }
         },
         destroy: () => {
-            H && (clearTimeout(H), H = null), h.clear(), "undefined" != typeof window && window.removeEventListener("beforeunload", ye), 
-            re("onDestroy", {
-                store: ue
-            }), a.clear(), i.clear(), y.clear(), d.clear(), g.clear(), f.clear(), s.clear(), 
-            o.clear(), Z = 0, S.clear(), v.clear(), r.clear(), w.clear(), u.clear();
+            V && (clearTimeout(V), V = null), y.clear(), "undefined" != typeof window && window.removeEventListener("beforeunload", Y), 
+            B("onDestroy", {
+                store: Z
+            }), s.clear(), o.clear(), l.clear(), u.clear(), d.clear(), f.clear(), t.clear(), 
+            r.clear(), $ = 0, m.clear(), _.clear(), n.clear(), p.clear(), c.clear();
         },
         _addPlugin: e => {
             ((e, t, n) => {
@@ -734,158 +1219,158 @@ var x = () => {
                         store: n
                     });
                 } catch (n) {
-                    const s = n instanceof Error ? n : new Error(String(n));
-                    e.onError ? e.onError(s, {
+                    const r = n instanceof Error ? n : new Error(String(n));
+                    e.onError ? e.onError(r, {
                         operation: "plugin:install",
                         key: t.name
                     }) : e.silent;
                 }
-            })(ne(), e, ue);
+            })(K(), e, Z);
         },
         _removePlugin: e => {
             f.delete(e);
         },
         _subscribe: (e, t) => {
             if (t) {
-                i.has(t) || i.set(t, new Set);
-                const n = i.get(t);
+                o.has(t) || o.set(t, new Set);
+                const n = o.get(t);
                 return n.add(e), () => {
-                    n.delete(e), 0 === n.size && i.delete(t);
+                    n.delete(e), 0 === n.size && o.delete(t);
                 };
             }
-            return a.add(e), () => a.delete(e);
+            return s.add(e), () => s.delete(e);
         },
-        _getVersion: e => r.get(e) ?? 0,
-        addAccessRule: (e, t) => T(S, e, t),
-        hasPermission: (e, t, n) => j(S, e, t, n),
-        recordConsent: (e, t, n) => $(v, e, t, n),
+        _getVersion: e => n.get(e) ?? 0,
+        addAccessRule: (e, t) => Le(m, e, t),
+        hasPermission: (e, t, n) => Fe(m, e, t, n),
+        recordConsent: (e, t, n) => Be(_, e, t, n),
         hasConsent: (e, t) => ((e, t, n) => {
-            const s = e.get(t);
-            if (!s) return !1;
-            for (let e = s.length - 1; e >= 0; e--) {
-                const t = s[e];
+            const r = e.get(t);
+            if (!r) return !1;
+            for (let e = r.length - 1; e >= 0; e--) {
+                const t = r[e];
                 if (t && t.purpose === n) return t.granted;
             }
             return !1;
-        })(v, e, t),
-        getConsents: e => ((e, t) => e.get(t) || [])(v, e),
-        revokeConsent: (e, t) => ((e, t, n) => $(e, t, n, !1))(v, e, t),
+        })(_, e, t),
+        getConsents: e => ((e, t) => e.get(t) || [])(_, e),
+        revokeConsent: (e, t) => ((e, t, n) => Be(e, t, n, !1))(_, e, t),
         exportUserData: e => ((e, t) => ({
             userId: t,
             exportedAt: Date.now(),
             consents: e.get(t) || []
-        }))(v, e),
+        }))(_, e),
         deleteUserData: e => ((e, t) => {
             const n = e.get(t)?.length || 0;
             return e.delete(t), {
                 success: !0,
                 deletedConsents: n
             };
-        })(v, e),
-        getSnapshot: () => (Y || (Y = Object.fromEntries(s.entries())), Y),
+        })(_, e),
+        getSnapshot: () => (N || (N = Object.fromEntries(t.entries())), N),
         get plugins() {
-            return le;
+            return X;
         },
         get isReady() {
-            return X;
+            return x;
         },
         get namespace() {
-            return b;
+            return S;
         },
         get userId() {
-            return B;
+            return j;
         },
-        whenReady: () => ee
+        whenReady: () => U
     };
     [ "addAccessRule", "recordConsent", "hasConsent", "getConsents", "revokeConsent", "exportUserData", "deleteUserData" ].forEach(e => {
-        const t = ue[e];
-        t && ue._registerMethod("security", e, t);
+        const t = Z[e];
+        t && Z._registerMethod("security", e, t);
     });
-    const ye = () => {
-        h.size > 0 && ce();
+    const Y = () => {
+        y.size > 0 && G();
     };
-    if ("undefined" != typeof window && window.addEventListener("beforeunload", ye), 
-    C ? (async (e, n, s) => {
-        const {storage: r, config: o, encryptionKey: a, audit: i, onError: l, silent: u, currentVersion: y, store: d, sizes: g, versions: f} = e, h = U(o.namespace || "gstate"), p = o.immer ?? !0;
+    if ("undefined" != typeof window && window.addEventListener("beforeunload", Y), 
+    E ? (async (e, t, n) => {
+        const {storage: r, config: s, encryptionKey: o, audit: i, onError: c, silent: l, currentVersion: u, store: d, sizes: f, versions: y} = e, p = We(s.namespace || "gstate"), h = s.immer ?? !0;
         if (r) try {
-            const u = {};
-            let m = 0;
+            const l = {};
+            let g = 0;
             for (let e = 0; e < (r.length || 0); e++) {
                 const t = r.key(e);
-                if (!t || !t.startsWith(h)) continue;
+                if (!t || !t.startsWith(p)) continue;
                 const n = r.getItem(t);
                 if (n) try {
-                    const s = JSON.parse(n), o = t.substring(h.length);
-                    if (m = Math.max(m, void 0 !== s._sys_v ? s._sys_v : s.v || 0), s.e && Date.now() > s.e) {
+                    const s = JSON.parse(n), a = t.substring(p.length);
+                    if (g = Math.max(g, void 0 !== s._sys_v ? s._sys_v : s.v || 0), s.e && Date.now() > s.e) {
                         r.removeItem(t), e--;
                         continue;
                     }
                     let c = s.d;
-                    if (s._enc && a) c = await D(c, a); else if ("string" == typeof c) if (s._b64) try {
+                    if (s._enc && o) c = await $e(c, o); else if ("string" == typeof c) if (s._b64) try {
                         c = JSON.parse(atob(c));
                     } catch (e) {} else if (c.startsWith("{") || c.startsWith("[")) try {
                         c = JSON.parse(c);
                     } catch (e) {}
-                    u[o] = c, i("hydrate", o, !0);
+                    l[a] = c, i("hydrate", a, !0);
                 } catch (e) {
                     i("hydrate", t, !1, String(e));
                     const n = e instanceof Error ? e : new Error(String(e));
-                    l && l(n, {
+                    c && c(n, {
                         operation: "hydration",
                         key: t
                     });
                 }
             }
-            const w = m < y && o.migrate ? o.migrate(u, m) : u;
-            Object.entries(w).forEach(([s, r]) => {
-                const o = p && null !== r && "object" == typeof r ? t(c(r), !0) : r, a = n(o), i = g.get(s) || 0;
-                e.totalSize = e.totalSize - i + a, g.set(s, a), d.set(s, o), f.set(s, 1);
-            }), s();
+            const m = g < u && s.migrate ? s.migrate(l, g) : l;
+            Object.entries(m).forEach(([n, r]) => {
+                const s = h && null !== r && "object" == typeof r ? H(a(r), !0) : r, o = t(s), i = f.get(n) || 0;
+                e.totalSize = e.totalSize - i + o, f.set(n, o), d.set(n, s), y.set(n, 1);
+            }), n();
         } catch (e) {
             const t = e instanceof Error ? e : new Error(String(e));
-            l && l(t, {
+            c && c(t, {
                 operation: "hydration"
             });
         }
-    })(te(), e => (N > 0 || L > 0) && !x() ? se(e) : 0, () => {
-        X = !0, Y = null, F(), ie();
-    }).then(() => {}) : (X = !0, F()), n?.sync) {
-        const e = n.sync, t = async () => {
-            const {SyncEngine: t} = await Promise.resolve().then(() => (m(), p));
-            return new t(ue, e);
+    })(F(), e => (O > 0 || C > 0) && !Qe() ? J(e) : 0, () => {
+        x = !0, N = null, T(), q();
+    }).then(() => {}) : (x = !0, T()), e?.sync) {
+        const t = e.sync, n = async () => {
+            const {SyncEngine: e} = await Promise.resolve().then(() => (g(), h));
+            return new e(Z, t);
         };
-        let s = null;
-        ue._registerMethod("sync", "flush", async () => {
-            s || (s = t());
-            return (await s).flush();
-        }), ue._registerMethod("sync", "getState", async () => {
-            s || (s = t());
-            return (await s).getState();
-        }), ue._registerMethod("sync", "onStateChange", async e => {
-            s || (s = t());
-            return (await s).onStateChange(e);
-        }), ue._registerMethod("sync", "forceSync", async () => {
-            s || (s = t());
-            return (await s).sync();
+        let r = null;
+        Z._registerMethod("sync", "flush", async () => {
+            r || (r = n());
+            return (await r).flush();
+        }), Z._registerMethod("sync", "getState", async () => {
+            r || (r = n());
+            return (await r).getState();
+        }), Z._registerMethod("sync", "onStateChange", async e => {
+            r || (r = n());
+            return (await r).onStateChange(e);
+        }), Z._registerMethod("sync", "forceSync", async () => {
+            r || (r = n());
+            return (await r).sync();
         });
     }
-    return ue;
+    return Z;
 };
 
-m();
+g();
 
-var L = null, z = e => {
-    const t = N(e);
-    return L = t, t;
-}, K = () => {
-    L && (L.destroy(), L = null);
-}, J = e => {
-    const t = e || L, r = n(() => e => t ? t._subscribe(e) : () => {}, [ t ]);
-    return s(r, () => !!t && t.isReady, () => !0);
-}, B = () => L;
+var Xe = null, Ze = e => {
+    const t = Ge(e);
+    return Xe = t, t;
+}, Ye = () => {
+    Xe && (Xe.destroy(), Xe = null);
+}, et = n => {
+    const r = n || Xe, s = e(() => e => r ? r._subscribe(e) : () => {}, [ r ]);
+    return t(s, () => !!r && r.isReady, () => !0);
+}, tt = () => Xe;
 
-function Q(e, t) {
-    const a = n(() => t || L, [ t ]), i = n(() => {
+function nt(s, o) {
+    const a = e(() => o || Xe, [ o ]), i = e(() => {
         const e = () => {}, t = () => !1, n = () => null;
         return {
             set: t,
@@ -918,96 +1403,96 @@ function Q(e, t) {
             },
             get userId() {}
         };
-    }, []), c = a || i, l = "function" == typeof e, u = l ? null : e, y = l ? e : null, d = r(e => l ? c._subscribe(e) : c._subscribe(e, u), [ c, l, u ]), g = r(() => l ? y(c.getSnapshot()) : c.get(u) ?? void 0, [ c, l, u, y ]), f = r(() => {
+    }, []), c = a || i, l = "function" == typeof s, u = l ? null : s, d = l ? s : null, f = n(e => l ? c._subscribe(e) : c._subscribe(e, u), [ c, l, u ]), y = n(() => l ? d(c.getSnapshot()) : c.get(u) ?? void 0, [ c, l, u, d ]), p = n(() => {
         if (l) try {
-            return y({});
+            return d({});
         } catch {
             return;
         }
-    }, [ y, l ]), h = s(d, g, f), p = r((e, t) => l ? (x(), !1) : c.set(u, e, t), [ c, l, u ]);
-    return o(h, e => l ? `Selector: ${JSON.stringify(e)}` : `${u}: ${JSON.stringify(e)}`), 
-    l ? h : [ h, p ];
+    }, [ d, l ]), h = t(f, y, p), g = n((e, t) => l ? (Qe(), !1) : c.set(u, e, t), [ c, l, u ]);
+    return r(h, e => l ? `Selector: ${JSON.stringify(e)}` : `${u}: ${JSON.stringify(e)}`), 
+    l ? h : [ h, g ];
 }
 
-var W = new Map, F = (e, t) => {
+var rt = new Map, st = (e, t) => {
     const n = e.namespace;
-    if (W.has(n)) return W.get(n);
-    const s = new u(e, t);
-    return W.set(n, s), s;
-}, G = e => {
-    const t = W.get(e);
-    t && (t.destroy(), W.delete(e));
+    if (rt.has(n)) return rt.get(n);
+    const r = new c(e, t);
+    return rt.set(n, r), r;
+}, ot = e => {
+    const t = rt.get(e);
+    t && (t.destroy(), rt.delete(e));
 };
 
-function q(e, t) {
-    const n = t || L, s = n?.namespace || "default", o = W.get(s), c = Q(e, n), l = c[0], u = c[1], [y, d] = a(() => o?.getState() || {
+function at(e, t) {
+    const r = t || Xe, a = r?.namespace || "default", i = rt.get(a), c = nt(e, r), l = c[0], u = c[1], [d, f] = s(() => i?.getState() || {
         isOnline: !0,
         isSyncing: !1,
         lastSyncTimestamp: null,
         pendingChanges: 0,
         conflicts: 0
     });
-    i(() => {
-        if (!o) return;
-        return o.onStateChange(d);
-    }, [ o ]);
-    return [ l, r((t, s) => {
-        const r = u(t, s);
-        if (r && o) {
-            const t = n?.get(e);
-            o.queueChange(e, t);
+    o(() => {
+        if (!i) return;
+        return i.onStateChange(f);
+    }, [ i ]);
+    return [ l, n((t, n) => {
+        const s = u(t, n);
+        if (s && i) {
+            const t = r?.get(e);
+            i.queueChange(e, t);
         }
-        return r;
-    }, [ u, o, e, n ]), y ];
+        return s;
+    }, [ u, i, e, r ]), d ];
 }
 
-var X = () => {
-    const [e, t] = a({
+var it, ct, lt, ut, dt, ft, yt = () => {
+    const [e, t] = s({
         isOnline: !0,
         isSyncing: !1,
         lastSyncTimestamp: null,
         pendingChanges: 0,
         conflicts: 0
     });
-    return i(() => {
+    return o(() => {
         const e = () => {
-            let e = !0, n = !1, s = 0, r = 0;
-            W.forEach(t => {
+            let e = !0, n = !1, r = 0, s = 0;
+            rt.forEach(t => {
                 const o = t.getState();
-                e = e && o.isOnline, n = n || o.isSyncing, s += o.pendingChanges, r += o.conflicts;
+                e = e && o.isOnline, n = n || o.isSyncing, r += o.pendingChanges, s += o.conflicts;
             }), t({
                 isOnline: e,
                 isSyncing: n,
                 lastSyncTimestamp: null,
-                pendingChanges: s,
-                conflicts: r
+                pendingChanges: r,
+                conflicts: s
             });
         };
         e();
-        const n = Array.from(W.values()).map(t => t.onStateChange(e));
+        const n = Array.from(rt.values()).map(t => t.onStateChange(e));
         return () => n.forEach(e => e());
     }, []), e;
-}, Z = async e => {
-    const t = e || L?.namespace;
+}, pt = async e => {
+    const t = e || Xe?.namespace;
     if (!t) return;
-    const n = W.get(t);
+    const n = rt.get(t);
     n && await n.flush();
-}, H = (e, t) => {
-    const n = t?.key || "async_data", s = t?.store || N({
+}, ht = (e, t) => {
+    const n = t?.key || "async_data", r = t?.store || Ge({
         namespace: `async_${n}`,
         silent: !0
     });
-    null == s.get(n) && s.set(n, {
+    null == r.get(n) && r.set(n, {
         data: null,
         loading: !1,
         error: null,
         updatedAt: null
     });
-    return Object.assign(s, {
+    return Object.assign(r, {
         execute: async () => {
-            const r = s.get(n);
-            s.set(n, {
-                ...r || {
+            const s = r.get(n);
+            r.set(n, {
+                ...s || {
                     data: null,
                     loading: !1,
                     error: null,
@@ -1015,25 +1500,25 @@ var X = () => {
                 },
                 loading: !0,
                 error: null
-            }), "whenReady" in s && !s.isReady && await s.whenReady();
+            }), "whenReady" in r && !r.isReady && await r.whenReady();
             try {
-                const r = await e(), o = s.get(n);
-                s.set(n, {
+                const s = await e(), o = r.get(n);
+                r.set(n, {
                     ...o || {
                         data: null,
                         loading: !1,
                         error: null,
                         updatedAt: null
                     },
-                    data: r,
+                    data: s,
                     loading: !1,
                     updatedAt: Date.now()
                 }, {
                     persist: t?.persist
                 });
             } catch (e) {
-                const t = s.get(n);
-                s.set(n, {
+                const t = r.get(n);
+                r.set(n, {
                     ...t || {
                         data: null,
                         loading: !1,
@@ -1046,62 +1531,298 @@ var X = () => {
             }
         }
     });
-};
+}, gt = () => "undefined" == typeof window || void 0 === window.document, mt = () => !gt(), _t = e => {
+    const t = e?.ssrSafe ?? !0, n = e?.deferHydration ?? !1;
+    let r = e?.storage;
+    !r && t && gt() && (r = He());
+    const s = Ge({
+        ...e,
+        storage: r || void 0,
+        persistByDefault: !n && (e?.persistByDefault ?? !1)
+    });
+    let o = !1, a = null;
+    e?.initialState && gt() && (Object.entries(e.initialState).forEach(([e, t]) => {
+        s._setSilently(e, t);
+    }), a = JSON.stringify(e.initialState));
+    return Object.assign(s, {
+        hydrate: async () => {
+            if (!o && !gt()) {
+                if (t && !s.namespace.startsWith("async_")) {
+                    const t = s.getSnapshot(), n = Ge({
+                        ...e,
+                        namespace: s.namespace,
+                        storage: void 0,
+                        persistByDefault: e?.persistByDefault ?? !1
+                    });
+                    Object.entries(t).forEach(([e, t]) => {
+                        n._setSilently(e, t);
+                    }), o = !0;
+                } else o = !0;
+                await s.whenReady();
+            }
+        },
+        getSerializedState: () => gt() ? JSON.stringify(s.getSnapshot()) : a,
+        isHydrated: () => o || s.isReady
+    });
+}, St = async e => {
+    gt() || await e.whenReady();
+}, wt = e => JSON.stringify(e.getSnapshot()), bt = (e, t) => {
+    if (!gt()) try {
+        const n = JSON.parse(t);
+        Object.entries(n).forEach(([t, n]) => {
+            e._setSilently(t, n);
+        });
+    } catch (e) {}
+}, vt = () => (it || (it = f("react"), ct = it.useState, lt = it.useEffect, ut = it.useSyncExternalStore, 
+dt = it.useMemo, ft = it.useCallback), {
+    React: it,
+    useState: ct,
+    useEffect: lt,
+    useSyncExternalStore: ut,
+    useMemo: dt,
+    useCallback: ft
+}), Et = () => {
+    const {useSyncExternalStore: e} = vt();
+    return e(e => () => {}, () => mt(), () => !0);
+}, kt = () => {
+    const {useState: e, useEffect: t} = vt(), [n, r] = e(() => gt()), [s, o] = e(() => gt());
+    return t(() => {
+        if (gt()) return;
+        r(!0);
+        const e = setTimeout(() => {
+            o(!0), r(!1);
+        }, 0);
+        return () => clearTimeout(e);
+    }, []), {
+        isHydrated: s,
+        isHydrating: n
+    };
+}, Ot = e => {
+    const {useState: t, useEffect: n, useMemo: r} = vt(), [s, o] = t(() => !!gt() || (e.isHydrated?.() ?? e.isReady));
+    return n(() => {
+        if (gt()) return;
+        const t = () => {
+            const t = e.isHydrated?.() ?? e.isReady;
+            o(t);
+        }, n = setInterval(t, 50), r = e._subscribe(t);
+        return t(), () => {
+            clearInterval(n), r();
+        };
+    }, [ e ]), r(() => {
+        if (s) return e;
+        const t = () => {}, n = () => !1, r = () => null;
+        return {
+            set: n,
+            get: r,
+            remove: n,
+            delete: n,
+            deleteAll: n,
+            list: () => ({}),
+            compute: r,
+            watch: () => () => {},
+            use: t,
+            transaction: t,
+            destroy: t,
+            _subscribe: () => () => {},
+            _setSilently: t,
+            _registerMethod: t,
+            _addPlugin: t,
+            _removePlugin: t,
+            _getVersion: () => 0,
+            get isReady() {
+                return !1;
+            },
+            whenReady: () => Promise.resolve(),
+            get plugins() {
+                return {};
+            },
+            getSnapshot: () => ({}),
+            get namespace() {
+                return e.namespace;
+            },
+            get userId() {
+                return e.userId;
+            }
+        };
+    }, [ e, s ]);
+}, Ct = e => {
+    const t = _t(e);
+    return Object.assign(t, {
+        useHydrated: Et,
+        useHydrationStatus: kt,
+        useDeferredStore: e => {
+            const n = Ot(t), {useCallback: r} = vt();
+            return (e => {
+                const {useSyncExternalStore: t} = vt();
+                return t(r(t => n._subscribe(t, e), [ n, e ]), r(() => n.get(e), [ n, e ]), () => {});
+            })(e);
+        }
+    });
+}, Dt = e => e.getSnapshot(), Mt = (e, t) => {
+    gt() || Object.entries(t).forEach(([t, n]) => {
+        e._setSilently(t, n);
+    });
+}, At = (e, t) => {
+    const n = t?.extraArgument, r = async t => {
+        if ("function" == typeof t) return t(r, () => e.getSnapshot(), n);
+        if (t.type) {
+            const {type: n, payload: r} = t, s = n.match(/^SET_(.+)$/i);
+            if (s && s[1]) {
+                const t = s[1].toLowerCase();
+                e.set(t, r);
+            }
+            const o = n.match(/^REMOVE_(.+)$/i);
+            if (o && o[1]) {
+                const t = o[1].toLowerCase();
+                e.remove(t);
+            }
+        }
+    };
+    return Object.assign(e, {
+        dispatch: r
+    });
+}, jt = (e, t) => {
+    const n = At(e);
+    return Object.assign(n.dispatch, t);
+}, Rt = (e, t) => async (n, r) => {
+    const s = r()[e];
+    n({
+        type: `SET_${e.toUpperCase()}`,
+        payload: {
+            ...s,
+            loading: !0,
+            error: null
+        }
+    });
+    try {
+        const r = await t();
+        return n({
+            type: `SET_${e.toUpperCase()}`,
+            payload: {
+                data: r,
+                loading: !1,
+                error: null
+            }
+        }), r;
+    } catch (t) {
+        throw n({
+            type: `SET_${e.toUpperCase()}`,
+            payload: {
+                data: s?.data ?? null,
+                loading: !1,
+                error: t instanceof Error ? t : new Error(String(t))
+            }
+        }), t;
+    }
+}, Pt = (e, t) => {
+    At(e);
+    const n = {};
+    for (const [e, r] of Object.entries(t)) n[e] = Rt(e, r);
+    return n;
+}, Tt = (e, ...t) => ({
+    type: "call",
+    fn: e,
+    args: t
+}), It = e => ({
+    type: "put",
+    action: e
+}), zt = e => ({
+    type: "select",
+    selector: e
+}), xt = e => ({
+    type: "take",
+    pattern: e
+}), $t = e => ({
+    type: "all",
+    effects: e
+}), Vt = e => ({
+    type: "race",
+    effects: e
+}), Nt = e => async (t, n) => {
+    const r = async e => {
+        switch (e.type) {
+          case "call":
+            return e.fn();
 
-m();
+          case "put":
+            return t(e.action);
 
-var Y = () => ({
+          case "select":
+            return e.selector(n());
+
+          case "all":
+            return Promise.all(e.effects.map(r));
+
+          case "race":
+            {
+                const t = Object.fromEntries(Object.entries(e.effects).map(([e, t]) => [ e, r(t) ]));
+                return Promise.race(Object.values(t));
+            }
+
+          default:
+            return;
+        }
+    };
+    try {
+        let t = e.next();
+        for (;!t.done; ) await r(t.value), t = e.next();
+    } catch (e) {}
+}, Ut = (e, t) => (At(e).dispatch(t), () => {});
+
+g();
+
+var Lt = () => ({
     name: "gstate-immer",
     hooks: {
         onInstall: ({store: e}) => {
             e._registerMethod("immer", "setWithProduce", (t, n) => e.set(t, n));
         }
     }
-}), ee = e => {
-    let t = [], n = -1, s = !1;
-    const r = e?.limit || 50;
+}), Ft = e => {
+    let t = [], n = -1, r = !1;
+    const s = e?.limit || 50;
     return {
         name: "gstate-undo-redo",
         hooks: {
             onInstall: ({store: e}) => {
                 t.push(e.list()), n = 0, e._registerMethod("undoRedo", "undo", () => {
                     if (n > 0) {
-                        s = !0, n--;
-                        const r = t[n];
-                        return !!r && (Object.entries(r).forEach(([t, n]) => {
+                        r = !0, n--;
+                        const s = t[n];
+                        return !!s && (Object.entries(s).forEach(([t, n]) => {
                             e._setSilently(t, n);
-                        }), s = !1, !0);
+                        }), r = !1, !0);
                     }
                     return !1;
                 }), e._registerMethod("undoRedo", "redo", () => {
                     if (n < t.length - 1) {
-                        s = !0, n++;
-                        const r = t[n];
-                        return !!r && (Object.entries(r).forEach(([t, n]) => {
+                        r = !0, n++;
+                        const s = t[n];
+                        return !!s && (Object.entries(s).forEach(([t, n]) => {
                             e._setSilently(t, n);
-                        }), s = !1, !0);
+                        }), r = !1, !0);
                     }
                     return !1;
                 }), e._registerMethod("undoRedo", "canUndo", () => n > 0), e._registerMethod("undoRedo", "canRedo", () => n < t.length - 1);
             },
             onSet: ({store: e}) => {
-                s || (n < t.length - 1 && (t = t.slice(0, n + 1)), t.push(e.list()), t.length > r ? t.shift() : n++);
+                r || (n < t.length - 1 && (t = t.slice(0, n + 1)), t.push(e.list()), t.length > s ? t.shift() : n++);
             }
         }
     };
-}, te = e => ({
+}, Kt = e => ({
     name: "gstate-schema",
     hooks: {
         onSet: ({key: t, value: n}) => {
             if (!t) return;
-            const s = e[t];
-            if (s) {
-                const e = s(n);
+            const r = e[t];
+            if (r) {
+                const e = r(n);
                 if (!0 !== e) throw new Error(`[Schema Error] Validation failed for key "${t}": ${!1 === e ? "Invalid type" : e}`);
             }
         }
     }
-}), ne = e => {
+}), Jt = e => {
     const t = globalThis.__REDUX_DEVTOOLS_EXTENSION__;
     if (!t?.connect) return {
         name: "gstate-devtools-noop",
@@ -1111,10 +1832,10 @@ var Y = () => ({
     return {
         name: "gstate-devtools",
         hooks: {
-            onInstall: ({store: s}) => {
+            onInstall: ({store: r}) => {
                 n = t.connect({
                     name: e?.name || "Magnetar Store"
-                }), n.init(s.list());
+                }), n.init(r.list());
             },
             onSet: ({key: e, store: t}) => {
                 e && n && n.send(`SET_${e.toUpperCase()}`, t.list());
@@ -1124,7 +1845,7 @@ var Y = () => ({
             }
         }
     };
-}, se = () => {
+}, Bt = () => {
     const e = new Map;
     return {
         name: "gstate-snapshot",
@@ -1133,9 +1854,9 @@ var Y = () => ({
                 t._registerMethod("snapshot", "takeSnapshot", n => {
                     e.set(n, t.list());
                 }), t._registerMethod("snapshot", "restoreSnapshot", n => {
-                    const s = e.get(n);
-                    return !!s && (t.transaction(() => {
-                        Object.entries(s).forEach(([e, n]) => {
+                    const r = e.get(n);
+                    return !!r && (t.transaction(() => {
+                        Object.entries(r).forEach(([e, n]) => {
                             t.set(e, n);
                         });
                     }), !0);
@@ -1144,16 +1865,16 @@ var Y = () => ({
             }
         }
     };
-}, re = e => ({
+}, Wt = e => ({
     name: "gstate-guard",
     hooks: {
-        onBeforeSet: ({key: t, value: n, store: s}) => {
+        onBeforeSet: ({key: t, value: n, store: r}) => {
             if (!t) return;
-            const r = e[t];
-            r && r(n);
+            const s = e[t];
+            s && s(n);
         }
     }
-}), oe = e => ({
+}), Qt = e => ({
     name: "gstate-analytics",
     hooks: {
         onSet: ({key: t, value: n}) => {
@@ -1171,7 +1892,7 @@ var Y = () => ({
             }));
         }
     }
-}), ae = e => {
+}), qt = e => {
     const t = new BroadcastChannel(e?.channelName || "gstate_sync");
     let n = !1;
     return {
@@ -1179,14 +1900,14 @@ var Y = () => ({
         hooks: {
             onInstall: ({store: e}) => {
                 t.onmessage = t => {
-                    const {key: s, value: r, action: o} = t.data;
-                    s && (n = !0, "REMOVE" === o ? e.remove(s) : e.set(s, r), n = !1);
+                    const {key: r, value: s, action: o} = t.data;
+                    r && (n = !0, "REMOVE" === o ? e.remove(r) : e.set(r, s), n = !1);
                 };
             },
-            onSet: ({key: e, value: s}) => {
+            onSet: ({key: e, value: r}) => {
                 e && !n && t.postMessage({
                     key: e,
-                    value: s,
+                    value: r,
                     action: "SET"
                 });
             },
@@ -1201,12 +1922,12 @@ var Y = () => ({
             }
         }
     };
-}, ie = () => {
-    if (x()) return {
+}, Ht = () => {
+    if (Qe()) return {
         name: "gstate-debug-noop",
         hooks: {}
     };
-    x();
+    Qe();
     return {
         name: "gstate-debug",
         hooks: {
@@ -1218,8 +1939,8 @@ var Y = () => ({
                         return n;
                     },
                     set: (t, n) => {
-                        const s = e.set(t, n);
-                        return JSON.stringify(n), s;
+                        const r = e.set(t, n);
+                        return JSON.stringify(n), r;
                     },
                     watch: (t, n) => e.watch(t, n),
                     info: () => {
@@ -1239,23 +1960,23 @@ var Y = () => ({
             }
         }
     };
-}, ce = (e = {}) => {
-    const t = e.dbName || "rgs-db", n = e.storeName || "states", s = e.version || 1;
-    let r = null;
+}, Gt = (e = {}) => {
+    const t = e.dbName || "rgs-db", n = e.storeName || "states", r = e.version || 1;
+    let s = null;
     const o = () => new Promise((e, o) => {
-        if (r) return e(r);
-        const a = indexedDB.open(t, s);
+        if (s) return e(s);
+        const a = indexedDB.open(t, r);
         a.onerror = () => o(a.error), a.onsuccess = () => {
-            r = a.result, e(r);
+            s = a.result, e(s);
         }, a.onupgradeneeded = e => {
             const t = e.target.result;
             t.objectStoreNames.contains(n) || t.createObjectStore(n);
         };
     }), a = async e => {
         const t = await o();
-        return new Promise((s, r) => {
+        return new Promise((r, s) => {
             const o = t.transaction(n, "readonly").objectStore(n).get(e);
-            o.onsuccess = () => s(o.result), o.onerror = () => r(o.error);
+            o.onsuccess = () => r(o.result), o.onerror = () => s(o.error);
         });
     };
     return {
@@ -1269,46 +1990,46 @@ var Y = () => ({
             onInit: async ({store: e}) => {
                 const t = (await o()).transaction(n, "readonly").objectStore(n).getAllKeys();
                 t.onsuccess = async () => {
-                    const n = t.result, s = e.namespace + "_";
-                    for (const t of n) if (t.startsWith(s)) {
+                    const n = t.result, r = e.namespace + "_";
+                    for (const t of n) if (t.startsWith(r)) {
                         const n = await a(t);
                         if (n) {
-                            const r = t.substring(s.length);
-                            e._setSilently(r, n.d);
+                            const s = t.substring(r.length);
+                            e._setSilently(s, n.d);
                         }
                     }
                 };
             },
-            onSet: async ({key: e, value: t, store: s}) => {
+            onSet: async ({key: e, value: t, store: r}) => {
                 if (!e) return;
-                const r = s.namespace + "_", a = {
+                const s = r.namespace + "_", a = {
                     d: t,
                     t: Date.now(),
-                    v: s._getVersion?.(e) || 1
+                    v: r._getVersion?.(e) || 1
                 };
                 await (async (e, t) => {
-                    const s = await o();
-                    return new Promise((r, o) => {
-                        const a = s.transaction(n, "readwrite").objectStore(n).put(t, e);
-                        a.onsuccess = () => r(), a.onerror = () => o(a.error);
+                    const r = await o();
+                    return new Promise((s, o) => {
+                        const a = r.transaction(n, "readwrite").objectStore(n).put(t, e);
+                        a.onsuccess = () => s(), a.onerror = () => o(a.error);
                     });
-                })(`${r}${e}`, a);
+                })(`${s}${e}`, a);
             },
             onRemove: async ({key: e, store: t}) => {
                 if (!e) return;
-                const s = t.namespace + "_";
+                const r = t.namespace + "_";
                 await (async e => {
                     const t = await o();
-                    return new Promise((s, r) => {
+                    return new Promise((r, s) => {
                         const o = t.transaction(n, "readwrite").objectStore(n).delete(e);
-                        o.onsuccess = () => s(), o.onerror = () => r(o.error);
+                        o.onsuccess = () => r(), o.onerror = () => s(o.error);
                     });
-                })(`${s}${e}`);
+                })(`${r}${e}`);
             }
         }
     };
-}, le = e => {
-    const {adapter: t, autoSyncInterval: n} = e, s = new Map, r = {
+}, Xt = e => {
+    const {adapter: t, autoSyncInterval: n} = e, r = new Map, s = {
         lastSyncTimestamp: null,
         totalKeysSynced: 0,
         totalBytesSynced: 0,
@@ -1328,30 +2049,30 @@ var Y = () => ({
                         const c = a.list(), l = Object.keys(c);
                         for (const e of l) {
                             const t = a._getVersion?.(e) || 0;
-                            if (t > (s.get(e) || 0)) {
+                            if (t > (r.get(e) || 0)) {
                                 const n = c[e];
-                                o[e] = n, i += JSON.stringify(n).length, s.set(e, t);
+                                o[e] = n, i += JSON.stringify(n).length, r.set(e, t);
                             }
                         }
                         if (0 === Object.keys(o).length) return {
                             status: "no-change",
-                            stats: r
+                            stats: s
                         };
-                        if (await t.save(o)) return r.lastSyncTimestamp = Date.now(), r.totalKeysSynced += Object.keys(o).length, 
-                        r.totalBytesSynced += i, r.syncCount++, r.lastDuration = performance.now() - n, 
-                        e.onSync && e.onSync(r), {
+                        if (await t.save(o)) return s.lastSyncTimestamp = Date.now(), s.totalKeysSynced += Object.keys(o).length, 
+                        s.totalBytesSynced += i, s.syncCount++, s.lastDuration = performance.now() - n, 
+                        e.onSync && e.onSync(s), {
                             status: "success",
-                            stats: r
+                            stats: s
                         };
                         throw new Error(`Adapter ${t.name} failed to save.`);
                     } catch (e) {
-                        return r.errors++, {
+                        return s.errors++, {
                             status: "error",
                             error: String(e),
-                            stats: r
+                            stats: s
                         };
                     }
-                }), a._registerMethod("cloudSync", "getStats", () => r), n && n > 0 && (o = setInterval(() => {
+                }), a._registerMethod("cloudSync", "getStats", () => s), n && n > 0 && (o = setInterval(() => {
                     const e = a.plugins.cloudSync;
                     e && e.sync();
                 }, n));
@@ -1361,7 +2082,7 @@ var Y = () => ({
             }
         }
     };
-}, ue = (e, t) => ({
+}, Zt = (e, t) => ({
     name: "MongoDB-Atlas",
     save: async n => (await fetch(`${e}/action/updateOne`, {
         method: "POST",
@@ -1385,32 +2106,32 @@ var Y = () => ({
             upsert: !0
         })
     })).ok
-}), ye = (e, t) => ({
+}), Yt = (e, t) => ({
     name: "Firebase-Firestore",
     save: async e => {
         try {
-            x();
+            Qe();
             return (() => {})("[Mock] Firestore Syncing:", e), !0;
         } catch (e) {
             return !1;
         }
     }
-}), de = (e, t) => ({
+}), en = (e, t) => ({
     name: "SQL-REST-API",
     save: async n => {
-        const s = t();
-        if (!s) return !1;
+        const r = t();
+        if (!r) return !1;
         return (await fetch(e, {
             method: "PATCH",
             headers: {
                 "Content-Type": "application/json",
-                Authorization: `Bearer ${s}`
+                Authorization: `Bearer ${r}`
             },
             body: JSON.stringify(n),
             credentials: "same-origin"
         })).ok;
     }
-}), ge = e => ({
+}), tn = e => ({
     name: "gstate-logger",
     hooks: {
         onSet: ({key: e, value: t, version: n}) => {
@@ -1419,27 +2140,27 @@ var Y = () => ({
         onRemove: ({key: e}) => {},
         onTransaction: ({key: e}) => {}
     }
-}), fe = (e, t) => {
-    const n = N("string" == typeof t ? {
+}), nn = (e, t) => {
+    const n = Ge("string" == typeof t ? {
         namespace: t
     } : t);
     e && Object.entries(e).forEach(([e, t]) => {
         null === n.get(e) && n._setSilently(e, t);
     });
-    return "undefined" == typeof window || x() || (window.gstate = n, window.gState = n, 
-    window.rgs = n), Object.assign(e => Q(e, n), n);
-}, he = (e, t) => B()?.addAccessRule(e, t), pe = (e, t, n) => B()?.hasPermission(e, t, n) ?? !0, me = (e, t, n) => {
-    const s = B();
-    if (!s) throw new Error("[gstate] recordConsent failed: No store found. call initState() first.");
-    return s.recordConsent(e, t, n);
-}, we = (e, t) => B()?.hasConsent(e, t) ?? !1, Se = e => B()?.getConsents(e) ?? [], ve = (e, t) => B()?.revokeConsent(e, t), be = e => {
-    const t = B();
+    return "undefined" == typeof window || Qe() || (window.gstate = n, window.gState = n, 
+    window.rgs = n), Object.assign(e => nt(e, n), n);
+}, rn = (e, t) => tt()?.addAccessRule(e, t), sn = (e, t, n) => tt()?.hasPermission(e, t, n) ?? !0, on = (e, t, n) => {
+    const r = tt();
+    if (!r) throw new Error("[gstate] recordConsent failed: No store found. call initState() first.");
+    return r.recordConsent(e, t, n);
+}, an = (e, t) => tt()?.hasConsent(e, t) ?? !1, cn = e => tt()?.getConsents(e) ?? [], ln = (e, t) => tt()?.revokeConsent(e, t), un = e => {
+    const t = tt();
     if (!t) throw new Error("[gstate] exportUserData failed: No store found.");
     return t.exportUserData(e);
-}, Ee = e => {
-    const t = B();
+}, dn = e => {
+    const t = tt();
     if (!t) throw new Error("[gstate] deleteUserData failed: No store found.");
     return t.deleteUserData(e);
-}, _e = () => {}, ke = () => {};
+}, fn = () => {}, yn = () => {};
 
-export { u as SyncEngine, he as addAccessRule, oe as analyticsPlugin, _e as clearAccessRules, ke as clearAllConsents, le as cloudSyncPlugin, H as createAsyncStore, ye as createFirestoreAdapter, ue as createMongoAdapter, de as createSqlRestAdapter, N as createStore, y as createSyncEngine, ie as debugPlugin, Ee as deleteUserData, b as deriveKeyFromPassword, K as destroyState, G as destroySync, ne as devToolsPlugin, k as exportKey, be as exportUserData, _ as generateEncryptionKey, E as generateSalt, Se as getConsents, B as getStore, fe as gstate, re as guardPlugin, we as hasConsent, pe as hasPermission, Y as immerPlugin, C as importKey, ce as indexedDBPlugin, z as initState, F as initSync, v as isCryptoAvailable, R as logAudit, ge as loggerPlugin, me as recordConsent, ve as revokeConsent, V as sanitizeValue, te as schemaPlugin, M as setAuditLogger, se as snapshotPlugin, ae as syncPlugin, Z as triggerSync, ee as undoRedoPlugin, Q as useGState, J as useIsStoreReady, Q as useSimpleState, Q as useStore, X as useSyncStatus, q as useSyncedState, I as validateKey };
+export { c as SyncEngine, rn as addAccessRule, $t as all, Qt as analyticsPlugin, Tt as call, fn as clearAccessRules, yn as clearAllConsents, Xt as cloudSyncPlugin, jt as createActions, Rt as createAsyncAction, Pt as createAsyncActions, ht as createAsyncStore, Yt as createFirestoreAdapter, Zt as createMongoAdapter, Ct as createNextStore, _t as createSSRStore, Nt as createSaga, en as createSqlRestAdapter, Ge as createStore, l as createSyncEngine, At as createThunkStore, Ht as debugPlugin, wt as dehydrateStore, dn as deleteUserData, Re as deriveKeyFromPassword, Ye as destroyState, ot as destroySync, Jt as devToolsPlugin, Ie as exportKey, un as exportUserData, Te as generateEncryptionKey, Pe as generateSalt, cn as getConsents, Dt as getSSRInitialState, tt as getStore, nn as gstate, Wt as guardPlugin, an as hasConsent, sn as hasPermission, St as hydrateOnClient, Lt as immerPlugin, ze as importKey, Gt as indexedDBPlugin, Ze as initState, st as initSync, Mt as initializeFromSSR, mt as isClientSide, je as isCryptoAvailable, gt as isServerSide, Ue as logAudit, tn as loggerPlugin, It as put, Vt as race, on as recordConsent, bt as rehydrateStore, ln as revokeConsent, Ut as runSaga, Ke as sanitizeValue, Kt as schemaPlugin, zt as select, Ne as setAuditLogger, Bt as snapshotPlugin, qt as syncPlugin, xt as take, pt as triggerSync, Ft as undoRedoPlugin, Ot as useDeferredStore, nt as useGState, Et as useHydrated, kt as useHydrationStatus, et as useIsStoreReady, nt as useSimpleState, nt as useStore, yt as useSyncStatus, at as useSyncedState, Je as validateKey };