@open-kingdom/shared-feature-notifications 0.0.2-0

package/dist/index.js

@@ -0,0 +1,1619 @@
+import { jsx as E, jsxs as he } from "react/jsx-runtime";
+import * as D from "react";
+import Te, { useState as re, useEffect as ne } from "react";
+var $ = { exports: {} }, Q = {};
+var ye;
+function Xe() {
+  if (ye) return Q;
+  ye = 1;
+  var e = Te;
+  function t(a, u) {
+    return a === u && (a !== 0 || 1 / a === 1 / u) || a !== a && u !== u;
+  }
+  var r = typeof Object.is == "function" ? Object.is : t, n = e.useSyncExternalStore, o = e.useRef, i = e.useEffect, c = e.useMemo, s = e.useDebugValue;
+  return Q.useSyncExternalStoreWithSelector = function(a, u, l, p, h) {
+    var d = o(null);
+    if (d.current === null) {
+      var _ = { hasValue: !1, value: null };
+      d.current = _;
+    } else _ = d.current;
+    d = c(
+      function() {
+        function O(m) {
+          if (!C) {
+            if (C = !0, f = m, m = p(m), h !== void 0 && _.hasValue) {
+              var v = _.value;
+              if (h(v, m))
+                return y = v;
+            }
+            return y = m;
+          }
+          if (v = y, r(f, m)) return v;
+          var w = p(m);
+          return h !== void 0 && h(v, w) ? (f = m, v) : (f = m, y = w);
+        }
+        var C = !1, f, y, b = l === void 0 ? null : l;
+        return [
+          function() {
+            return O(u());
+          },
+          b === null ? void 0 : function() {
+            return O(b());
+          }
+        ];
+      },
+      [u, l, p, h]
+    );
+    var g = n(a, d[0], d[1]);
+    return i(
+      function() {
+        _.hasValue = !0, _.value = g;
+      },
+      [g]
+    ), s(g), g;
+  }, Q;
+}
+var Z = {};
+var me;
+function qe() {
+  return me || (me = 1, process.env.NODE_ENV !== "production" && function() {
+    function e(a, u) {
+      return a === u && (a !== 0 || 1 / a === 1 / u) || a !== a && u !== u;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var t = Te, r = typeof Object.is == "function" ? Object.is : e, n = t.useSyncExternalStore, o = t.useRef, i = t.useEffect, c = t.useMemo, s = t.useDebugValue;
+    Z.useSyncExternalStoreWithSelector = function(a, u, l, p, h) {
+      var d = o(null);
+      if (d.current === null) {
+        var _ = { hasValue: !1, value: null };
+        d.current = _;
+      } else _ = d.current;
+      d = c(
+        function() {
+          function O(m) {
+            if (!C) {
+              if (C = !0, f = m, m = p(m), h !== void 0 && _.hasValue) {
+                var v = _.value;
+                if (h(v, m))
+                  return y = v;
+              }
+              return y = m;
+            }
+            if (v = y, r(f, m))
+              return v;
+            var w = p(m);
+            return h !== void 0 && h(v, w) ? (f = m, v) : (f = m, y = w);
+          }
+          var C = !1, f, y, b = l === void 0 ? null : l;
+          return [
+            function() {
+              return O(u());
+            },
+            b === null ? void 0 : function() {
+              return O(b());
+            }
+          ];
+        },
+        [u, l, p, h]
+      );
+      var g = n(a, d[0], d[1]);
+      return i(
+        function() {
+          _.hasValue = !0, _.value = g;
+        },
+        [g]
+      ), s(g), g;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }()), Z;
+}
+var _e;
+function Je() {
+  return _e || (_e = 1, process.env.NODE_ENV === "production" ? $.exports = Xe() : $.exports = qe()), $.exports;
+}
+var Qe = Je(), Ze = /* @__PURE__ */ Symbol.for("react-redux-context"), et = typeof globalThis < "u" ? globalThis : (
+  /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
+  {}
+);
+function tt() {
+  if (!D.createContext) return {};
+  const e = et[Ze] ??= /* @__PURE__ */ new Map();
+  let t = e.get(D.createContext);
+  return t || (t = D.createContext(
+    null
+  ), process.env.NODE_ENV !== "production" && (t.displayName = "ReactRedux"), e.set(D.createContext, t)), t;
+}
+var R = /* @__PURE__ */ tt();
+function de(e = R) {
+  return function() {
+    const r = D.useContext(e);
+    if (process.env.NODE_ENV !== "production" && !r)
+      throw new Error(
+        "could not find react-redux context value; please ensure the component is wrapped in a <Provider>"
+      );
+    return r;
+  };
+}
+var Ve = /* @__PURE__ */ de();
+function ze(e = R) {
+  const t = e === R ? Ve : (
+    // @ts-ignore
+    de(e)
+  ), r = () => {
+    const { store: n } = t();
+    return n;
+  };
+  return Object.assign(r, {
+    withTypes: () => r
+  }), r;
+}
+var rt = /* @__PURE__ */ ze();
+function nt(e = R) {
+  const t = e === R ? rt : ze(e), r = () => t().dispatch;
+  return Object.assign(r, {
+    withTypes: () => r
+  }), r;
+}
+var ot = /* @__PURE__ */ nt(), it = (e, t) => e === t;
+function st(e = R) {
+  const t = e === R ? Ve : de(e), r = (n, o = {}) => {
+    const { equalityFn: i = it } = typeof o == "function" ? { equalityFn: o } : o;
+    if (process.env.NODE_ENV !== "production") {
+      if (!n)
+        throw new Error("You must pass a selector to useSelector");
+      if (typeof n != "function")
+        throw new Error("You must pass a function as a selector to useSelector");
+      if (typeof i != "function")
+        throw new Error(
+          "You must pass a function as an equality function to useSelector"
+        );
+    }
+    const c = t(), { store: s, subscription: a, getServerState: u } = c, l = D.useRef(!0), p = D.useCallback(
+      {
+        [n.name](d) {
+          const _ = n(d);
+          if (process.env.NODE_ENV !== "production") {
+            const { devModeChecks: g = {} } = typeof o == "function" ? {} : o, { identityFunctionCheck: O, stabilityCheck: C } = c, {
+              identityFunctionCheck: f,
+              stabilityCheck: y
+            } = {
+              stabilityCheck: C,
+              identityFunctionCheck: O,
+              ...g
+            };
+            if (y === "always" || y === "once" && l.current) {
+              const b = n(d);
+              if (!i(_, b)) {
+                let m;
+                try {
+                  throw new Error();
+                } catch (v) {
+                  ({ stack: m } = v);
+                }
+                console.warn(
+                  "Selector " + (n.name || "unknown") + ` returned a different result when called with the same parameters. This can lead to unnecessary rerenders.
+Selectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization`,
+                  {
+                    state: d,
+                    selected: _,
+                    selected2: b,
+                    stack: m
+                  }
+                );
+              }
+            }
+            if ((f === "always" || f === "once" && l.current) && _ === d) {
+              let b;
+              try {
+                throw new Error();
+              } catch (m) {
+                ({ stack: b } = m);
+              }
+              console.warn(
+                "Selector " + (n.name || "unknown") + ` returned the root state when called. This can lead to unnecessary rerenders.
+Selectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.`,
+                { stack: b }
+              );
+            }
+            l.current && (l.current = !1);
+          }
+          return _;
+        }
+      }[n.name],
+      [n]
+    ), h = Qe.useSyncExternalStoreWithSelector(
+      a.addNestedSub,
+      s.getState,
+      u || s.getState,
+      p,
+      i
+    );
+    return D.useDebugValue(h), h;
+  };
+  return Object.assign(r, {
+    withTypes: () => r
+  }), r;
+}
+var be = /* @__PURE__ */ st();
+function ct(e) {
+  if (typeof e != "object" || e === null)
+    return !1;
+  let t = e;
+  for (; Object.getPrototypeOf(t) !== null; )
+    t = Object.getPrototypeOf(t);
+  return Object.getPrototypeOf(e) === t || Object.getPrototypeOf(e) === null;
+}
+function at(e) {
+  return ct(e) && "type" in e && typeof e.type == "string";
+}
+var Me = Symbol.for("immer-nothing"), ve = Symbol.for("immer-draftable"), x = Symbol.for("immer-state"), ut = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  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}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function S(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = ut[e], n = typeof r == "function" ? r.apply(null, t) : r;
+    throw new Error(`[Immer] ${n}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var P = Object.getPrototypeOf;
+function T(e) {
+  return !!e && !!e[x];
+}
+function k(e) {
+  return e ? Pe(e) || Array.isArray(e) || !!e[ve] || !!e.constructor?.[ve] || L(e) || X(e) : !1;
+}
+var lt = Object.prototype.constructor.toString(), ge = /* @__PURE__ */ new WeakMap();
+function Pe(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  if (t === null || t === Object.prototype)
+    return !0;
+  const r = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  if (r === Object)
+    return !0;
+  if (typeof r != "function")
+    return !1;
+  let n = ge.get(r);
+  return n === void 0 && (n = Function.toString.call(r), ge.set(r, n)), n === lt;
+}
+function K(e, t, r = !0) {
+  Y(e) === 0 ? (r ? Reflect.ownKeys(e) : Object.keys(e)).forEach((n) => {
+    t(n, e[n], e);
+  }) : e.forEach((n, o) => t(o, n, e));
+}
+function Y(e) {
+  const t = e[x];
+  return t ? t.type_ : Array.isArray(e) ? 1 : L(e) ? 2 : X(e) ? 3 : 0;
+}
+function oe(e, t) {
+  return Y(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function Ae(e, t, r) {
+  const n = Y(e);
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+}
+function dt(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function L(e) {
+  return e instanceof Map;
+}
+function X(e) {
+  return e instanceof Set;
+}
+function j(e) {
+  return e.copy_ || e.base_;
+}
+function ie(e, t) {
+  if (L(e))
+    return new Map(e);
+  if (X(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const r = Pe(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = Object.getOwnPropertyDescriptors(e);
+    delete n[x];
+    let o = Reflect.ownKeys(n);
+    for (let i = 0; i < o.length; i++) {
+      const c = o[i], s = n[c];
+      s.writable === !1 && (s.writable = !0, s.configurable = !0), (s.get || s.set) && (n[c] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: s.enumerable,
+        value: e[c]
+      });
+    }
+    return Object.create(P(e), n);
+  } else {
+    const n = P(e);
+    if (n !== null && r)
+      return { ...e };
+    const o = Object.create(n);
+    return Object.assign(o, e);
+  }
+}
+function fe(e, t = !1) {
+  return q(e) || T(e) || !k(e) || (Y(e) > 1 && Object.defineProperties(e, {
+    set: F,
+    add: F,
+    clear: F,
+    delete: F
+  }), Object.freeze(e), t && Object.values(e).forEach((r) => fe(r, !0))), e;
+}
+function ft() {
+  S(2);
+}
+var F = {
+  value: ft
+};
+function q(e) {
+  return e === null || typeof e != "object" ? !0 : Object.isFrozen(e);
+}
+var pt = {};
+function V(e) {
+  const t = pt[e];
+  return t || S(0, e), t;
+}
+var A;
+function Ie() {
+  return A;
+}
+function ht(e, t) {
+  return {
+    drafts_: [],
+    parent_: e,
+    immer_: t,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: !0,
+    unfinalizedDrafts_: 0
+  };
+}
+function we(e, t) {
+  t && (V("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function se(e) {
+  ce(e), e.drafts_.forEach(yt), e.drafts_ = null;
+}
+function ce(e) {
+  e === A && (A = e.parent_);
+}
+function Ee(e) {
+  return A = ht(A, e);
+}
+function yt(e) {
+  const t = e[x];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function Ne(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  return e !== void 0 && e !== r ? (r[x].modified_ && (se(t), S(4)), k(e) && (e = H(t, e), t.parent_ || G(t, e)), t.patches_ && V("Patches").generateReplacementPatches_(
+    r[x].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = H(t, r, []), se(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== Me ? e : void 0;
+}
+function H(e, t, r) {
+  if (q(t))
+    return t;
+  const n = e.immer_.shouldUseStrictIteration(), o = t[x];
+  if (!o)
+    return K(
+      t,
+      (i, c) => Se(e, o, t, i, c, r),
+      n
+    ), t;
+  if (o.scope_ !== e)
+    return t;
+  if (!o.modified_)
+    return G(e, o.base_, !0), o.base_;
+  if (!o.finalized_) {
+    o.finalized_ = !0, o.scope_.unfinalizedDrafts_--;
+    const i = o.copy_;
+    let c = i, s = !1;
+    o.type_ === 3 && (c = new Set(i), i.clear(), s = !0), K(
+      c,
+      (a, u) => Se(
+        e,
+        o,
+        i,
+        a,
+        u,
+        r,
+        s
+      ),
+      n
+    ), G(e, i, !1), r && e.patches_ && V("Patches").generatePatches_(
+      o,
+      r,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return o.copy_;
+}
+function Se(e, t, r, n, o, i, c) {
+  if (o == null || typeof o != "object" && !c)
+    return;
+  const s = q(o);
+  if (!(s && !c)) {
+    if (process.env.NODE_ENV !== "production" && o === r && S(5), T(o)) {
+      const a = i && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+      !oe(t.assigned_, n) ? i.concat(n) : void 0, u = H(e, o, a);
+      if (Ae(r, n, u), T(u))
+        e.canAutoFreeze_ = !1;
+      else
+        return;
+    } else c && r.add(o);
+    if (k(o) && !s) {
+      if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1 || t && t.base_ && t.base_[n] === o && s)
+        return;
+      H(e, o), (!t || !t.scope_.parent_) && typeof n != "symbol" && (L(r) ? r.has(n) : Object.prototype.propertyIsEnumerable.call(r, n)) && G(e, o);
+    }
+  }
+}
+function G(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && fe(t, r);
+}
+function mt(e, t) {
+  const r = Array.isArray(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : Ie(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: t,
+    // The base state.
+    base_: e,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1
+  };
+  let o = n, i = pe;
+  r && (o = [n], i = I);
+  const { revoke: c, proxy: s } = Proxy.revocable(o, i);
+  return n.draft_ = s, n.revoke_ = c, s;
+}
+var pe = {
+  get(e, t) {
+    if (t === x)
+      return e;
+    const r = j(e);
+    if (!oe(r, t))
+      return _t(e, r, t);
+    const n = r[t];
+    return e.finalized_ || !k(n) ? n : n === ee(e.base_, t) ? (te(e), e.copy_[t] = ue(n, e)) : n;
+  },
+  has(e, t) {
+    return t in j(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(j(e));
+  },
+  set(e, t, r) {
+    const n = Le(j(e), t);
+    if (n?.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const o = ee(j(e), t), i = o?.[x];
+      if (i && i.base_ === r)
+        return e.copy_[t] = r, e.assigned_[t] = !1, !0;
+      if (dt(r, o) && (r !== void 0 || oe(e.base_, t)))
+        return !0;
+      te(e), ae(e);
+    }
+    return e.copy_[t] === r && // special case: handle new props with value 'undefined'
+    (r !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(r) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = r, e.assigned_[t] = !0), !0;
+  },
+  deleteProperty(e, t) {
+    return ee(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, te(e), ae(e)) : delete e.assigned_[t], e.copy_ && delete e.copy_[t], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(e, t) {
+    const r = j(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: n.enumerable,
+      value: r[t]
+    };
+  },
+  defineProperty() {
+    S(11);
+  },
+  getPrototypeOf(e) {
+    return P(e.base_);
+  },
+  setPrototypeOf() {
+    S(12);
+  }
+}, I = {};
+K(pe, (e, t) => {
+  I[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+I.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && S(13), I.set.call(this, e, t, void 0);
+};
+I.set = function(e, t, r) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && S(14), pe.set.call(this, e[0], t, r, e[0]);
+};
+function ee(e, t) {
+  const r = e[x];
+  return (r ? j(r) : e)[t];
+}
+function _t(e, t, r) {
+  const n = Le(t, r);
+  return n ? "value" in n ? n.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    n.get?.call(e.draft_)
+  ) : void 0;
+}
+function Le(e, t) {
+  if (!(t in e))
+    return;
+  let r = P(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = P(r);
+  }
+}
+function ae(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && ae(e.parent_));
+}
+function te(e) {
+  e.copy_ || (e.copy_ = ie(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var bt = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !0, this.produce = (t, r, n) => {
+      if (typeof t == "function" && typeof r != "function") {
+        const i = r;
+        r = t;
+        const c = this;
+        return function(s = i, ...a) {
+          return c.produce(s, (u) => r.call(this, u, ...a));
+        };
+      }
+      typeof r != "function" && S(6), n !== void 0 && typeof n != "function" && S(7);
+      let o;
+      if (k(t)) {
+        const i = Ee(this), c = ue(t, void 0);
+        let s = !0;
+        try {
+          o = r(c), s = !1;
+        } finally {
+          s ? se(i) : ce(i);
+        }
+        return we(i, n), Ne(o, i);
+      } else if (!t || typeof t != "object") {
+        if (o = r(t), o === void 0 && (o = t), o === Me && (o = void 0), this.autoFreeze_ && fe(o, !0), n) {
+          const i = [], c = [];
+          V("Patches").generateReplacementPatches_(t, o, i, c), n(i, c);
+        }
+        return o;
+      } else
+        S(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (typeof t == "function")
+        return (i, ...c) => this.produceWithPatches(i, (s) => t(s, ...c));
+      let n, o;
+      return [this.produce(t, r, (i, c) => {
+        n = i, o = c;
+      }), n, o];
+    }, typeof e?.autoFreeze == "boolean" && this.setAutoFreeze(e.autoFreeze), typeof e?.useStrictShallowCopy == "boolean" && this.setUseStrictShallowCopy(e.useStrictShallowCopy), typeof e?.useStrictIteration == "boolean" && this.setUseStrictIteration(e.useStrictIteration);
+  }
+  createDraft(e) {
+    k(e) || S(8), T(e) && (e = vt(e));
+    const t = Ee(this), r = ue(e, void 0);
+    return r[x].isManual_ = !0, ce(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[x];
+    (!r || !r.isManual_) && S(9);
+    const { scope_: n } = r;
+    return we(n, t), Ne(void 0, n);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(e) {
+    this.autoFreeze_ = e;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(e) {
+    this.useStrictShallowCopy_ = e;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(e) {
+    this.useStrictIteration_ = e;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(e, t) {
+    let r;
+    for (r = t.length - 1; r >= 0; r--) {
+      const o = t[r];
+      if (o.path.length === 0 && o.op === "replace") {
+        e = o.value;
+        break;
+      }
+    }
+    r > -1 && (t = t.slice(r + 1));
+    const n = V("Patches").applyPatches_;
+    return T(e) ? n(e, t) : this.produce(
+      e,
+      (o) => n(o, t)
+    );
+  }
+};
+function ue(e, t) {
+  const r = L(e) ? V("MapSet").proxyMap_(e, t) : X(e) ? V("MapSet").proxySet_(e, t) : mt(e, t);
+  return (t ? t.scope_ : Ie()).drafts_.push(r), r;
+}
+function vt(e) {
+  return T(e) || S(10, e), $e(e);
+}
+function $e(e) {
+  if (!k(e) || q(e))
+    return e;
+  const t = e[x];
+  let r, n = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = ie(e, t.scope_.immer_.useStrictShallowCopy_), n = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    r = ie(e, !0);
+  return K(
+    r,
+    (o, i) => {
+      Ae(r, o, $e(i));
+    },
+    n
+  ), t && (t.finalized_ = !1), r;
+}
+var le = new bt(), Fe = le.produce, gt = /* @__PURE__ */ le.setUseStrictIteration.bind(
+  le
+), wt = (e, t, r) => {
+  if (t.length === 1 && t[0] === r) {
+    let n = !1;
+    try {
+      const o = {};
+      e(o) === o && (n = !0);
+    } catch {
+    }
+    if (n) {
+      let o;
+      try {
+        throw new Error();
+      } catch (i) {
+        ({ stack: o } = i);
+      }
+      console.warn(
+        `The result function returned its own inputs without modification. e.g
+\`createSelector([state => state.todos], todos => todos)\`
+This could lead to inefficient memoization and unnecessary re-renders.
+Ensure transformation logic is in the result function, and extraction logic is in the input selectors.`,
+        { stack: o }
+      );
+    }
+  }
+}, Et = (e, t, r) => {
+  const { memoize: n, memoizeOptions: o } = t, { inputSelectorResults: i, inputSelectorResultsCopy: c } = e, s = n(() => ({}), ...o);
+  if (s.apply(null, i) !== s.apply(null, c)) {
+    let a;
+    try {
+      throw new Error();
+    } catch (u) {
+      ({ stack: a } = u);
+    }
+    console.warn(
+      `An input selector returned a different result when passed same arguments.
+This means your output selector will likely run more frequently than intended.
+Avoid returning a new reference inside your input selector, e.g.
+\`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)\``,
+      {
+        arguments: r,
+        firstInputs: i,
+        secondInputs: c,
+        stack: a
+      }
+    );
+  }
+}, Nt = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+};
+function St(e, t = `expected a function, instead received ${typeof e}`) {
+  if (typeof e != "function")
+    throw new TypeError(t);
+}
+function Ot(e, t = `expected an object, instead received ${typeof e}`) {
+  if (typeof e != "object")
+    throw new TypeError(t);
+}
+function xt(e, t = "expected all items to be functions, instead received the following types: ") {
+  if (!e.every((r) => typeof r == "function")) {
+    const r = e.map(
+      (n) => typeof n == "function" ? `function ${n.name || "unnamed"}()` : typeof n
+    ).join(", ");
+    throw new TypeError(`${t}[${r}]`);
+  }
+}
+var Oe = (e) => Array.isArray(e) ? e : [e];
+function Ct(e) {
+  const t = Array.isArray(e[0]) ? e[0] : e;
+  return xt(
+    t,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), t;
+}
+function xe(e, t) {
+  const r = [], { length: n } = e;
+  for (let o = 0; o < n; o++)
+    r.push(e[o].apply(null, t));
+  return r;
+}
+var kt = (e, t) => {
+  const { identityFunctionCheck: r, inputStabilityCheck: n } = {
+    ...Nt,
+    ...t
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: r === "always" || r === "once" && e,
+      run: wt
+    },
+    inputStabilityCheck: {
+      shouldRun: n === "always" || n === "once" && e,
+      run: Et
+    }
+  };
+}, Dt = class {
+  constructor(e) {
+    this.value = e;
+  }
+  deref() {
+    return this.value;
+  }
+}, jt = typeof WeakRef < "u" ? WeakRef : Dt, Rt = 0, Ce = 1;
+function W() {
+  return {
+    s: Rt,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function We(e, t = {}) {
+  let r = W();
+  const { resultEqualityCheck: n } = t;
+  let o, i = 0;
+  function c() {
+    let s = r;
+    const { length: a } = arguments;
+    for (let p = 0, h = a; p < h; p++) {
+      const d = arguments[p];
+      if (typeof d == "function" || typeof d == "object" && d !== null) {
+        let _ = s.o;
+        _ === null && (s.o = _ = /* @__PURE__ */ new WeakMap());
+        const g = _.get(d);
+        g === void 0 ? (s = W(), _.set(d, s)) : s = g;
+      } else {
+        let _ = s.p;
+        _ === null && (s.p = _ = /* @__PURE__ */ new Map());
+        const g = _.get(d);
+        g === void 0 ? (s = W(), _.set(d, s)) : s = g;
+      }
+    }
+    const u = s;
+    let l;
+    if (s.s === Ce)
+      l = s.v;
+    else if (l = e.apply(null, arguments), i++, n) {
+      const p = o?.deref?.() ?? o;
+      p != null && n(p, l) && (l = p, i !== 0 && i--), o = typeof l == "object" && l !== null || typeof l == "function" ? new jt(l) : l;
+    }
+    return u.s = Ce, u.v = l, l;
+  }
+  return c.clearCache = () => {
+    r = W(), c.resetResultsCount();
+  }, c.resultsCount = () => i, c.resetResultsCount = () => {
+    i = 0;
+  }, c;
+}
+function Tt(e, ...t) {
+  const r = typeof e == "function" ? {
+    memoize: e,
+    memoizeOptions: t
+  } : e, n = (...o) => {
+    let i = 0, c = 0, s, a = {}, u = o.pop();
+    typeof u == "object" && (a = u, u = o.pop()), St(
+      u,
+      `createSelector expects an output function after the inputs, but received: [${typeof u}]`
+    );
+    const l = {
+      ...r,
+      ...a
+    }, {
+      memoize: p,
+      memoizeOptions: h = [],
+      argsMemoize: d = We,
+      argsMemoizeOptions: _ = [],
+      devModeChecks: g = {}
+    } = l, O = Oe(h), C = Oe(_), f = Ct(o), y = p(function() {
+      return i++, u.apply(
+        null,
+        arguments
+      );
+    }, ...O);
+    let b = !0;
+    const m = d(function() {
+      c++;
+      const v = xe(
+        f,
+        arguments
+      );
+      if (s = y.apply(null, v), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: w, inputStabilityCheck: M } = kt(b, g);
+        if (w.shouldRun && w.run(
+          u,
+          v,
+          s
+        ), M.shouldRun) {
+          const J = xe(
+            f,
+            arguments
+          );
+          M.run(
+            { inputSelectorResults: v, inputSelectorResultsCopy: J },
+            { memoize: p, memoizeOptions: O },
+            arguments
+          );
+        }
+        b && (b = !1);
+      }
+      return s;
+    }, ...C);
+    return Object.assign(m, {
+      resultFunc: u,
+      memoizedResultFunc: y,
+      dependencies: f,
+      dependencyRecomputations: () => c,
+      resetDependencyRecomputations: () => {
+        c = 0;
+      },
+      lastResult: () => s,
+      recomputations: () => i,
+      resetRecomputations: () => {
+        i = 0;
+      },
+      memoize: p,
+      argsMemoize: d
+    });
+  };
+  return Object.assign(n, {
+    withTypes: () => n
+  }), n;
+}
+var z = /* @__PURE__ */ Tt(We), Vt = Object.assign(
+  (e, t = z) => {
+    Ot(
+      e,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof e}`
+    );
+    const r = Object.keys(e), n = r.map(
+      (o) => e[o]
+    );
+    return t(
+      n,
+      (...o) => o.reduce((i, c, s) => (i[r[s]] = c, i), {})
+    );
+  },
+  { withTypes: () => Vt }
+);
+function ke(e, t) {
+  function r(...n) {
+    if (t) {
+      let o = t(...n);
+      if (!o)
+        throw new Error(process.env.NODE_ENV === "production" ? N(0) : "prepareAction did not return an object");
+      return {
+        type: e,
+        payload: o.payload,
+        ..."meta" in o && {
+          meta: o.meta
+        },
+        ..."error" in o && {
+          error: o.error
+        }
+      };
+    }
+    return {
+      type: e,
+      payload: n[0]
+    };
+  }
+  return r.toString = () => `${e}`, r.type = e, r.match = (n) => at(n) && n.type === e, r;
+}
+function De(e) {
+  return k(e) ? Fe(e, () => {
+  }) : e;
+}
+function B(e, t, r) {
+  return e.has(t) ? e.get(t) : e.set(t, r(t)).get(t);
+}
+function Be(e) {
+  const t = {}, r = [];
+  let n;
+  const o = {
+    addCase(i, c) {
+      if (process.env.NODE_ENV !== "production") {
+        if (r.length > 0)
+          throw new Error(process.env.NODE_ENV === "production" ? N(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        if (n)
+          throw new Error(process.env.NODE_ENV === "production" ? N(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
+      }
+      const s = typeof i == "string" ? i : i.type;
+      if (!s)
+        throw new Error(process.env.NODE_ENV === "production" ? N(28) : "`builder.addCase` cannot be called with an empty action type");
+      if (s in t)
+        throw new Error(process.env.NODE_ENV === "production" ? N(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${s}'`);
+      return t[s] = c, o;
+    },
+    addAsyncThunk(i, c) {
+      if (process.env.NODE_ENV !== "production" && n)
+        throw new Error(process.env.NODE_ENV === "production" ? N(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
+      return c.pending && (t[i.pending.type] = c.pending), c.rejected && (t[i.rejected.type] = c.rejected), c.fulfilled && (t[i.fulfilled.type] = c.fulfilled), c.settled && r.push({
+        matcher: i.settled,
+        reducer: c.settled
+      }), o;
+    },
+    addMatcher(i, c) {
+      if (process.env.NODE_ENV !== "production" && n)
+        throw new Error(process.env.NODE_ENV === "production" ? N(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+      return r.push({
+        matcher: i,
+        reducer: c
+      }), o;
+    },
+    addDefaultCase(i) {
+      if (process.env.NODE_ENV !== "production" && n)
+        throw new Error(process.env.NODE_ENV === "production" ? N(31) : "`builder.addDefaultCase` can only be called once");
+      return n = i, o;
+    }
+  };
+  return e(o), [t, r, n];
+}
+gt(!1);
+function zt(e) {
+  return typeof e == "function";
+}
+function Mt(e, t) {
+  if (process.env.NODE_ENV !== "production" && typeof t == "object")
+    throw new Error(process.env.NODE_ENV === "production" ? N(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
+  let [r, n, o] = Be(t), i;
+  if (zt(e))
+    i = () => De(e());
+  else {
+    const s = De(e);
+    i = () => s;
+  }
+  function c(s = i(), a) {
+    let u = [r[a.type], ...n.filter(({
+      matcher: l
+    }) => l(a)).map(({
+      reducer: l
+    }) => l)];
+    return u.filter((l) => !!l).length === 0 && (u = [o]), u.reduce((l, p) => {
+      if (p)
+        if (T(l)) {
+          const h = p(l, a);
+          return h === void 0 ? l : h;
+        } else {
+          if (k(l))
+            return Fe(l, (h) => p(h, a));
+          {
+            const h = p(l, a);
+            if (h === void 0) {
+              if (l === null)
+                return l;
+              throw Error("A case reducer on a non-draftable value must not return undefined");
+            }
+            return h;
+          }
+        }
+      return l;
+    }, s);
+  }
+  return c.getInitialState = i, c;
+}
+var Pt = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+function At(e, t) {
+  return `${e}/${t}`;
+}
+function It({
+  creators: e
+} = {}) {
+  const t = e?.asyncThunk?.[Pt];
+  return function(r) {
+    const {
+      name: n,
+      reducerPath: o = n
+    } = r;
+    if (!n)
+      throw new Error(process.env.NODE_ENV === "production" ? N(11) : "`name` is a required option for createSlice");
+    typeof process < "u" && process.env.NODE_ENV === "development" && r.initialState === void 0 && console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+    const i = (typeof r.reducers == "function" ? r.reducers(Ft()) : r.reducers) || {}, c = Object.keys(i), s = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    }, a = {
+      addCase(f, y) {
+        const b = typeof f == "string" ? f : f.type;
+        if (!b)
+          throw new Error(process.env.NODE_ENV === "production" ? N(12) : "`context.addCase` cannot be called with an empty action type");
+        if (b in s.sliceCaseReducersByType)
+          throw new Error(process.env.NODE_ENV === "production" ? N(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + b);
+        return s.sliceCaseReducersByType[b] = y, a;
+      },
+      addMatcher(f, y) {
+        return s.sliceMatchers.push({
+          matcher: f,
+          reducer: y
+        }), a;
+      },
+      exposeAction(f, y) {
+        return s.actionCreators[f] = y, a;
+      },
+      exposeCaseReducer(f, y) {
+        return s.sliceCaseReducersByName[f] = y, a;
+      }
+    };
+    c.forEach((f) => {
+      const y = i[f], b = {
+        reducerName: f,
+        type: At(n, f),
+        createNotation: typeof r.reducers == "function"
+      };
+      Bt(y) ? Kt(b, y, a, t) : Wt(b, y, a);
+    });
+    function u() {
+      if (process.env.NODE_ENV !== "production" && typeof r.extraReducers == "object")
+        throw new Error(process.env.NODE_ENV === "production" ? N(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
+      const [f = {}, y = [], b = void 0] = typeof r.extraReducers == "function" ? Be(r.extraReducers) : [r.extraReducers], m = {
+        ...f,
+        ...s.sliceCaseReducersByType
+      };
+      return Mt(r.initialState, (v) => {
+        for (let w in m)
+          v.addCase(w, m[w]);
+        for (let w of s.sliceMatchers)
+          v.addMatcher(w.matcher, w.reducer);
+        for (let w of y)
+          v.addMatcher(w.matcher, w.reducer);
+        b && v.addDefaultCase(b);
+      });
+    }
+    const l = (f) => f, p = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new WeakMap();
+    let d;
+    function _(f, y) {
+      return d || (d = u()), d(f, y);
+    }
+    function g() {
+      return d || (d = u()), d.getInitialState();
+    }
+    function O(f, y = !1) {
+      function b(v) {
+        let w = v[f];
+        if (typeof w > "u") {
+          if (y)
+            w = B(h, b, g);
+          else if (process.env.NODE_ENV !== "production")
+            throw new Error(process.env.NODE_ENV === "production" ? N(15) : "selectSlice returned undefined for an uninjected slice reducer");
+        }
+        return w;
+      }
+      function m(v = l) {
+        const w = B(p, y, () => /* @__PURE__ */ new WeakMap());
+        return B(w, v, () => {
+          const M = {};
+          for (const [J, Ye] of Object.entries(r.selectors ?? {}))
+            M[J] = Lt(Ye, v, () => B(h, v, g), y);
+          return M;
+        });
+      }
+      return {
+        reducerPath: f,
+        getSelectors: m,
+        get selectors() {
+          return m(b);
+        },
+        selectSlice: b
+      };
+    }
+    const C = {
+      name: n,
+      reducer: _,
+      actions: s.actionCreators,
+      caseReducers: s.sliceCaseReducersByName,
+      getInitialState: g,
+      ...O(o),
+      injectInto(f, {
+        reducerPath: y,
+        ...b
+      } = {}) {
+        const m = y ?? o;
+        return f.inject({
+          reducerPath: m,
+          reducer: _
+        }, b), {
+          ...C,
+          ...O(m, !0)
+        };
+      }
+    };
+    return C;
+  };
+}
+function Lt(e, t, r, n) {
+  function o(i, ...c) {
+    let s = t(i);
+    if (typeof s > "u") {
+      if (n)
+        s = r();
+      else if (process.env.NODE_ENV !== "production")
+        throw new Error(process.env.NODE_ENV === "production" ? N(16) : "selectState returned undefined for an uninjected slice reducer");
+    }
+    return e(s, ...c);
+  }
+  return o.unwrapped = e, o;
+}
+var $t = /* @__PURE__ */ It();
+function Ft() {
+  function e(t, r) {
+    return {
+      _reducerDefinitionType: "asyncThunk",
+      payloadCreator: t,
+      ...r
+    };
+  }
+  return e.withTypes = () => e, {
+    reducer(t) {
+      return Object.assign({
+        // hack so the wrapping function has the same name as the original
+        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
+        [t.name](...r) {
+          return t(...r);
+        }
+      }[t.name], {
+        _reducerDefinitionType: "reducer"
+        /* reducer */
+      });
+    },
+    preparedReducer(t, r) {
+      return {
+        _reducerDefinitionType: "reducerWithPrepare",
+        prepare: t,
+        reducer: r
+      };
+    },
+    asyncThunk: e
+  };
+}
+function Wt({
+  type: e,
+  reducerName: t,
+  createNotation: r
+}, n, o) {
+  let i, c;
+  if ("reducer" in n) {
+    if (r && !Ut(n))
+      throw new Error(process.env.NODE_ENV === "production" ? N(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+    i = n.reducer, c = n.prepare;
+  } else
+    i = n;
+  o.addCase(e, i).exposeCaseReducer(t, i).exposeAction(t, c ? ke(e, c) : ke(e));
+}
+function Bt(e) {
+  return e._reducerDefinitionType === "asyncThunk";
+}
+function Ut(e) {
+  return e._reducerDefinitionType === "reducerWithPrepare";
+}
+function Kt({
+  type: e,
+  reducerName: t
+}, r, n, o) {
+  if (!o)
+    throw new Error(process.env.NODE_ENV === "production" ? N(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
+  const {
+    payloadCreator: i,
+    fulfilled: c,
+    pending: s,
+    rejected: a,
+    settled: u,
+    options: l
+  } = r, p = o(e, i, l);
+  n.exposeAction(t, p), c && n.addCase(p.fulfilled, c), s && n.addCase(p.pending, s), a && n.addCase(p.rejected, a), u && n.addMatcher(p.settled, u), n.exposeCaseReducer(t, {
+    fulfilled: c || U,
+    pending: s || U,
+    rejected: a || U,
+    settled: u || U
+  });
+}
+function U() {
+}
+function N(e) {
+  return `Minified Redux Toolkit error #${e}; visit https://redux-toolkit.js.org/Errors?code=${e} for the full message or use the non-minified dev environment for full errors. `;
+}
+const Ht = {
+  maxNotifications: 5,
+  autoDismiss: !0,
+  dismissTimeout: 5e3
+}, Gt = {
+  notifications: [],
+  config: Ht
+}, Yt = (e, t) => {
+  const r = {
+    ...t.payload,
+    id: Date.now().toString(),
+    timestamp: Date.now(),
+    dismissed: !1
+  };
+  e.notifications.unshift(r), e.config.maxNotifications && e.notifications.length > e.config.maxNotifications && (e.notifications = e.notifications.slice(
+    0,
+    e.config.maxNotifications
+  ));
+}, Xt = (e, t) => {
+  const r = e.notifications.find((n) => n.id === t.payload);
+  r && (r.dismissed = !0);
+}, qt = (e, t) => {
+  e.notifications = e.notifications.filter(
+    (r) => r.id !== t.payload
+  );
+}, Jt = (e) => {
+  e.notifications = [];
+}, Qt = (e, t) => {
+  e.config = { ...e.config, ...t.payload };
+}, Ue = $t({
+  name: "notifications",
+  initialState: Gt,
+  reducers: {
+    addNotification: Yt,
+    dismissNotification: Xt,
+    removeNotification: qt,
+    clearNotifications: Jt,
+    updateConfig: Qt
+  }
+}), {
+  addNotification: ir,
+  dismissNotification: je,
+  removeNotification: Re,
+  clearNotifications: sr,
+  updateConfig: cr
+} = Ue.actions;
+Ue.reducer;
+const Zt = "notifications", Ke = (e) => e[Zt], He = z(
+  [Ke],
+  (e) => e.notifications
+), Ge = z(
+  [He],
+  (e) => e.filter((t) => !t.dismissed)
+);
+z(
+  [He],
+  (e) => e.length
+);
+z(
+  [Ge],
+  (e) => e.length
+);
+const er = z(
+  [Ke],
+  (e) => e.config
+);
+function tr({
+  notification: e,
+  onDismissed: t,
+  onRemoved: r
+}) {
+  const [n, o] = re(!1), [i, c] = re(!1);
+  ne(() => {
+    const h = setTimeout(() => o(!0), 10);
+    return () => clearTimeout(h);
+  }, []);
+  const s = () => {
+    c(!0), t(e.id), setTimeout(() => {
+      r(e.id);
+    }, 300);
+  }, a = (h) => {
+    const d = "p-4 rounded-lg border shadow-lg transition-all duration-300 ease-in-out transform";
+    switch (h) {
+      case "success":
+        return `${d} bg-success-50 dark:bg-success-900/20 border-success-200 dark:border-success-700`;
+      case "warning":
+        return `${d} bg-warning-50 dark:bg-warning-900/20 border-warning-200 dark:border-warning-700`;
+      case "error":
+        return `${d} bg-error-50 dark:bg-error-900/20 border-error-200 dark:border-error-700`;
+      default:
+        return d;
+    }
+  }, u = (h) => {
+    switch (h) {
+      case "success":
+        return "text-success-800 dark:text-success-200";
+      case "warning":
+        return "text-warning-800 dark:text-warning-200";
+      case "error":
+        return "text-error-800 dark:text-error-200";
+      default:
+        return "";
+    }
+  }, l = (h) => {
+    switch (h) {
+      case "success":
+        return "text-success-600 dark:text-success-400";
+      case "warning":
+        return "text-warning-600 dark:text-warning-400";
+      case "error":
+        return "text-error-600 dark:text-error-400";
+      default:
+        return "";
+    }
+  }, p = (h) => {
+    switch (h) {
+      case "success":
+        return /* @__PURE__ */ E(
+          "svg",
+          {
+            className: "w-5 h-5 text-success-600 dark:text-success-400",
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /* @__PURE__ */ E(
+              "path",
+              {
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeWidth: 2,
+                d: "M5 13l4 4L19 7"
+              }
+            )
+          }
+        );
+      case "warning":
+        return /* @__PURE__ */ E(
+          "svg",
+          {
+            className: "w-5 h-5 text-warning-600 dark:text-warning-400",
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /* @__PURE__ */ E(
+              "path",
+              {
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeWidth: 2,
+                d: "M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-2.5L13.732 4c-.77-.833-1.964-.833-2.732 0L3.732 16.5c-.77.833.192 2.5 1.732 2.5z"
+              }
+            )
+          }
+        );
+      case "error":
+        return /* @__PURE__ */ E(
+          "svg",
+          {
+            className: "w-5 h-5 text-error-600 dark:text-error-400",
+            fill: "none",
+            stroke: "currentColor",
+            viewBox: "0 0 24 24",
+            children: /* @__PURE__ */ E(
+              "path",
+              {
+                strokeLinecap: "round",
+                strokeLinejoin: "round",
+                strokeWidth: 2,
+                d: "M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
+              }
+            )
+          }
+        );
+      default:
+        return null;
+    }
+  };
+  return /* @__PURE__ */ E(
+    "div",
+    {
+      className: `
+        ${a(e.type)}
+        ${n ? "translate-x-0 opacity-100" : "translate-x-full opacity-0"}
+        ${i ? "translate-x-full opacity-0" : ""}
+        min-w-[320px] max-w-[480px] w-full
+      `,
+      role: "alert",
+      "aria-live": "assertive",
+      children: /* @__PURE__ */ he("div", { className: "flex items-start gap-3", children: [
+        /* @__PURE__ */ E("div", { className: "flex-shrink-0 mt-0.5", children: p(e.type) }),
+        /* @__PURE__ */ he("div", { className: "flex-1 min-w-0", children: [
+          /* @__PURE__ */ E(
+            "h4",
+            {
+              className: `text-sm font-semibold ${u(
+                e.type
+              )}`,
+              children: e.type.charAt(0).toUpperCase() + e.type.slice(1)
+            }
+          ),
+          /* @__PURE__ */ E(
+            "p",
+            {
+              "data-testid": "notification",
+              className: `text-sm mt-1 ${l(
+                e.type
+              )}`,
+              children: e.message
+            }
+          )
+        ] }),
+        /* @__PURE__ */ E(
+          "button",
+          {
+            "data-testid": "dismiss-button",
+            onClick: s,
+            className: "flex-shrink-0 p-1 text-neutral-400 hover:text-neutral-600 dark:hover:text-neutral-300 transition-colors",
+            "aria-label": "Dismiss notification",
+            children: /* @__PURE__ */ E(
+              "svg",
+              {
+                className: "w-4 h-4",
+                fill: "none",
+                stroke: "currentColor",
+                viewBox: "0 0 24 24",
+                children: /* @__PURE__ */ E(
+                  "path",
+                  {
+                    strokeLinecap: "round",
+                    strokeLinejoin: "round",
+                    strokeWidth: 2,
+                    d: "M6 18L18 6M6 6l12 12"
+                  }
+                )
+              }
+            )
+          }
+        )
+      ] })
+    }
+  );
+}
+function rr() {
+  const e = be(Ge), t = be(er), r = ot(), [n, o] = re(
+    []
+  );
+  ne(() => {
+    if (!t.autoDismiss || !t.dismissTimeout) return;
+    const a = [];
+    return e.forEach((u) => {
+      const l = setTimeout(() => {
+        r(je(u.id)), setTimeout(() => {
+          r(Re(u.id));
+        }, 300);
+      }, t.dismissTimeout);
+      a.push(l);
+    }), () => {
+      a.forEach(clearTimeout);
+    };
+  }, [e, t.autoDismiss, t.dismissTimeout, r]), ne(() => {
+    const a = e.map((u) => u.id);
+    o((u) => {
+      const l = [...u];
+      return a.forEach((p) => {
+        l.includes(p) || l.push(p);
+      }), l;
+    });
+  }, [e]);
+  const i = (a) => {
+    r(je(a));
+  }, c = (a) => {
+    r(Re(a)), o(
+      (u) => u.filter((l) => l !== a)
+    );
+  }, s = e.filter(
+    (a) => n.includes(a.id)
+  );
+  return s.length === 0 ? null : /* @__PURE__ */ E(
+    "div",
+    {
+      className: "fixed bottom-4 right-4 z-50 flex flex-col gap-3 pointer-events-none",
+      "aria-live": "polite",
+      "aria-label": "Notifications",
+      children: s.map((a) => /* @__PURE__ */ E("div", { className: "pointer-events-auto", children: /* @__PURE__ */ E(
+        tr,
+        {
+          notification: a,
+          onDismissed: i,
+          onRemoved: c
+        }
+      ) }, a.id))
+    }
+  );
+}
+function ar() {
+  return /* @__PURE__ */ E(rr, {});
+}
+export {
+  rr as NotificationToastContainer,
+  ar as SharedFeatureNotifications
+};