@open-kingdom/shared-frontend-data-access-notifications 0.0.2-0

package/dist/index.js

@@ -0,0 +1,1170 @@
+function Te(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 Me(e) {
+  return Te(e) && "type" in e && typeof e.type == "string";
+}
+var we = Symbol.for("immer-nothing"), ue = Symbol.for("immer-draftable"), E = Symbol.for("immer-state"), ze = 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 N(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const n = ze[e], r = typeof n == "function" ? n.apply(null, t) : n;
+    throw new Error(`[Immer] ${r}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var M = Object.getPrototypeOf;
+function R(e) {
+  return !!e && !!e[E];
+}
+function S(e) {
+  return e ? Ne(e) || Array.isArray(e) || !!e[ue] || !!e.constructor?.[ue] || A(e) || G(e) : !1;
+}
+var je = Object.prototype.constructor.toString(), ae = /* @__PURE__ */ new WeakMap();
+function Ne(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  if (t === null || t === Object.prototype)
+    return !0;
+  const n = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  if (n === Object)
+    return !0;
+  if (typeof n != "function")
+    return !1;
+  let r = ae.get(n);
+  return r === void 0 && (r = Function.toString.call(n), ae.set(n, r)), r === je;
+}
+function B(e, t, n = !0) {
+  q(e) === 0 ? (n ? Reflect.ownKeys(e) : Object.keys(e)).forEach((o) => {
+    t(o, e[o], e);
+  }) : e.forEach((r, o) => t(o, r, e));
+}
+function q(e) {
+  const t = e[E];
+  return t ? t.type_ : Array.isArray(e) ? 1 : A(e) ? 2 : G(e) ? 3 : 0;
+}
+function Z(e, t) {
+  return q(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function Ee(e, t, n) {
+  const r = q(e);
+  r === 2 ? e.set(t, n) : r === 3 ? e.add(n) : e[t] = n;
+}
+function Ae(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function A(e) {
+  return e instanceof Map;
+}
+function G(e) {
+  return e instanceof Set;
+}
+function O(e) {
+  return e.copy_ || e.base_;
+}
+function L(e, t) {
+  if (A(e))
+    return new Map(e);
+  if (G(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const n = Ne(e);
+  if (t === !0 || t === "class_only" && !n) {
+    const r = Object.getOwnPropertyDescriptors(e);
+    delete r[E];
+    let o = Reflect.ownKeys(r);
+    for (let i = 0; i < o.length; i++) {
+      const c = o[i], s = r[c];
+      s.writable === !1 && (s.writable = !0, s.configurable = !0), (s.get || s.set) && (r[c] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: s.enumerable,
+        value: e[c]
+      });
+    }
+    return Object.create(M(e), r);
+  } else {
+    const r = M(e);
+    if (r !== null && n)
+      return { ...e };
+    const o = Object.create(r);
+    return Object.assign(o, e);
+  }
+}
+function ie(e, t = !1) {
+  return Y(e) || R(e) || !S(e) || (q(e) > 1 && Object.defineProperties(e, {
+    set: F,
+    add: F,
+    clear: F,
+    delete: F
+  }), Object.freeze(e), t && Object.values(e).forEach((n) => ie(n, !0))), e;
+}
+function xe() {
+  N(2);
+}
+var F = {
+  value: xe
+};
+function Y(e) {
+  return e === null || typeof e != "object" ? !0 : Object.isFrozen(e);
+}
+var Fe = {};
+function k(e) {
+  const t = Fe[e];
+  return t || N(0, e), t;
+}
+var z;
+function be() {
+  return z;
+}
+function Ve(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 fe(e, t) {
+  t && (k("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function ee(e) {
+  te(e), e.drafts_.forEach($e), e.drafts_ = null;
+}
+function te(e) {
+  e === z && (z = e.parent_);
+}
+function le(e) {
+  return z = Ve(z, e);
+}
+function $e(e) {
+  const t = e[E];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function de(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const n = t.drafts_[0];
+  return e !== void 0 && e !== n ? (n[E].modified_ && (ee(t), N(4)), S(e) && (e = U(t, e), t.parent_ || K(t, e)), t.patches_ && k("Patches").generateReplacementPatches_(
+    n[E].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = U(t, n, []), ee(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== we ? e : void 0;
+}
+function U(e, t, n) {
+  if (Y(t))
+    return t;
+  const r = e.immer_.shouldUseStrictIteration(), o = t[E];
+  if (!o)
+    return B(
+      t,
+      (i, c) => pe(e, o, t, i, c, n),
+      r
+    ), t;
+  if (o.scope_ !== e)
+    return t;
+  if (!o.modified_)
+    return K(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), B(
+      c,
+      (f, a) => pe(
+        e,
+        o,
+        i,
+        f,
+        a,
+        n,
+        s
+      ),
+      r
+    ), K(e, i, !1), n && e.patches_ && k("Patches").generatePatches_(
+      o,
+      n,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return o.copy_;
+}
+function pe(e, t, n, r, o, i, c) {
+  if (o == null || typeof o != "object" && !c)
+    return;
+  const s = Y(o);
+  if (!(s && !c)) {
+    if (process.env.NODE_ENV !== "production" && o === n && N(5), R(o)) {
+      const f = i && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+      !Z(t.assigned_, r) ? i.concat(r) : void 0, a = U(e, o, f);
+      if (Ee(n, r, a), R(a))
+        e.canAutoFreeze_ = !1;
+      else
+        return;
+    } else c && n.add(o);
+    if (S(o) && !s) {
+      if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1 || t && t.base_ && t.base_[r] === o && s)
+        return;
+      U(e, o), (!t || !t.scope_.parent_) && typeof r != "symbol" && (A(n) ? n.has(r) : Object.prototype.propertyIsEnumerable.call(n, r)) && K(e, o);
+    }
+  }
+}
+function K(e, t, n = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && ie(t, n);
+}
+function We(e, t) {
+  const n = Array.isArray(e), r = {
+    type_: n ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : be(),
+    // 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 = r, i = ce;
+  n && (o = [r], i = j);
+  const { revoke: c, proxy: s } = Proxy.revocable(o, i);
+  return r.draft_ = s, r.revoke_ = c, s;
+}
+var ce = {
+  get(e, t) {
+    if (t === E)
+      return e;
+    const n = O(e);
+    if (!Z(n, t))
+      return Be(e, n, t);
+    const r = n[t];
+    return e.finalized_ || !S(r) ? r : r === J(e.base_, t) ? (Q(e), e.copy_[t] = re(r, e)) : r;
+  },
+  has(e, t) {
+    return t in O(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(O(e));
+  },
+  set(e, t, n) {
+    const r = ve(O(e), t);
+    if (r?.set)
+      return r.set.call(e.draft_, n), !0;
+    if (!e.modified_) {
+      const o = J(O(e), t), i = o?.[E];
+      if (i && i.base_ === n)
+        return e.copy_[t] = n, e.assigned_[t] = !1, !0;
+      if (Ae(n, o) && (n !== void 0 || Z(e.base_, t)))
+        return !0;
+      Q(e), ne(e);
+    }
+    return e.copy_[t] === n && // special case: handle new props with value 'undefined'
+    (n !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(n) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = n, e.assigned_[t] = !0), !0;
+  },
+  deleteProperty(e, t) {
+    return J(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, Q(e), ne(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 n = O(e), r = Reflect.getOwnPropertyDescriptor(n, t);
+    return r && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: r.enumerable,
+      value: n[t]
+    };
+  },
+  defineProperty() {
+    N(11);
+  },
+  getPrototypeOf(e) {
+    return M(e.base_);
+  },
+  setPrototypeOf() {
+    N(12);
+  }
+}, j = {};
+B(ce, (e, t) => {
+  j[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+j.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && N(13), j.set.call(this, e, t, void 0);
+};
+j.set = function(e, t, n) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && N(14), ce.set.call(this, e[0], t, n, e[0]);
+};
+function J(e, t) {
+  const n = e[E];
+  return (n ? O(n) : e)[t];
+}
+function Be(e, t, n) {
+  const r = ve(t, n);
+  return r ? "value" in r ? r.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!
+    r.get?.call(e.draft_)
+  ) : void 0;
+}
+function ve(e, t) {
+  if (!(t in e))
+    return;
+  let n = M(e);
+  for (; n; ) {
+    const r = Object.getOwnPropertyDescriptor(n, t);
+    if (r)
+      return r;
+    n = M(n);
+  }
+}
+function ne(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && ne(e.parent_));
+}
+function Q(e) {
+  e.copy_ || (e.copy_ = L(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var Ue = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !0, this.produce = (t, n, r) => {
+      if (typeof t == "function" && typeof n != "function") {
+        const i = n;
+        n = t;
+        const c = this;
+        return function(f = i, ...a) {
+          return c.produce(f, (u) => n.call(this, u, ...a));
+        };
+      }
+      typeof n != "function" && N(6), r !== void 0 && typeof r != "function" && N(7);
+      let o;
+      if (S(t)) {
+        const i = le(this), c = re(t, void 0);
+        let s = !0;
+        try {
+          o = n(c), s = !1;
+        } finally {
+          s ? ee(i) : te(i);
+        }
+        return fe(i, r), de(o, i);
+      } else if (!t || typeof t != "object") {
+        if (o = n(t), o === void 0 && (o = t), o === we && (o = void 0), this.autoFreeze_ && ie(o, !0), r) {
+          const i = [], c = [];
+          k("Patches").generateReplacementPatches_(t, o, i, c), r(i, c);
+        }
+        return o;
+      } else
+        N(1, t);
+    }, this.produceWithPatches = (t, n) => {
+      if (typeof t == "function")
+        return (c, ...s) => this.produceWithPatches(c, (f) => t(f, ...s));
+      let r, o;
+      return [this.produce(t, n, (c, s) => {
+        r = c, o = s;
+      }), r, 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) {
+    S(e) || N(8), R(e) && (e = Ke(e));
+    const t = le(this), n = re(e, void 0);
+    return n[E].isManual_ = !0, te(t), n;
+  }
+  finishDraft(e, t) {
+    const n = e && e[E];
+    (!n || !n.isManual_) && N(9);
+    const { scope_: r } = n;
+    return fe(r, t), de(void 0, r);
+  }
+  /**
+   * 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 n;
+    for (n = t.length - 1; n >= 0; n--) {
+      const o = t[n];
+      if (o.path.length === 0 && o.op === "replace") {
+        e = o.value;
+        break;
+      }
+    }
+    n > -1 && (t = t.slice(n + 1));
+    const r = k("Patches").applyPatches_;
+    return R(e) ? r(e, t) : this.produce(
+      e,
+      (o) => r(o, t)
+    );
+  }
+};
+function re(e, t) {
+  const n = A(e) ? k("MapSet").proxyMap_(e, t) : G(e) ? k("MapSet").proxySet_(e, t) : We(e, t);
+  return (t ? t.scope_ : be()).drafts_.push(n), n;
+}
+function Ke(e) {
+  return R(e) || N(10, e), Ce(e);
+}
+function Ce(e) {
+  if (!S(e) || Y(e))
+    return e;
+  const t = e[E];
+  let n, r = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, n = L(e, t.scope_.immer_.useStrictShallowCopy_), r = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    n = L(e, !0);
+  return B(
+    n,
+    (o, i) => {
+      Ee(n, o, Ce(i));
+    },
+    r
+  ), t && (t.finalized_ = !1), n;
+}
+var oe = new Ue(), Se = oe.produce, qe = /* @__PURE__ */ oe.setUseStrictIteration.bind(
+  oe
+), Ge = (e, t, n) => {
+  if (t.length === 1 && t[0] === n) {
+    let r = !1;
+    try {
+      const o = {};
+      e(o) === o && (r = !0);
+    } catch {
+    }
+    if (r) {
+      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 }
+      );
+    }
+  }
+}, Ye = (e, t, n) => {
+  const { memoize: r, memoizeOptions: o } = t, { inputSelectorResults: i, inputSelectorResultsCopy: c } = e, s = r(() => ({}), ...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: n,
+        firstInputs: i,
+        secondInputs: c,
+        stack: a
+      }
+    );
+  }
+}, He = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+};
+function Xe(e, t = `expected a function, instead received ${typeof e}`) {
+  if (typeof e != "function")
+    throw new TypeError(t);
+}
+function Je(e, t = `expected an object, instead received ${typeof e}`) {
+  if (typeof e != "object")
+    throw new TypeError(t);
+}
+function Qe(e, t = "expected all items to be functions, instead received the following types: ") {
+  if (!e.every((n) => typeof n == "function")) {
+    const n = e.map(
+      (r) => typeof r == "function" ? `function ${r.name || "unnamed"}()` : typeof r
+    ).join(", ");
+    throw new TypeError(`${t}[${n}]`);
+  }
+}
+var ye = (e) => Array.isArray(e) ? e : [e];
+function Ze(e) {
+  const t = Array.isArray(e[0]) ? e[0] : e;
+  return Qe(
+    t,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), t;
+}
+function he(e, t) {
+  const n = [], { length: r } = e;
+  for (let o = 0; o < r; o++)
+    n.push(e[o].apply(null, t));
+  return n;
+}
+var Le = (e, t) => {
+  const { identityFunctionCheck: n, inputStabilityCheck: r } = {
+    ...He,
+    ...t
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: n === "always" || n === "once" && e,
+      run: Ge
+    },
+    inputStabilityCheck: {
+      shouldRun: r === "always" || r === "once" && e,
+      run: Ye
+    }
+  };
+}, et = class {
+  constructor(e) {
+    this.value = e;
+  }
+  deref() {
+    return this.value;
+  }
+}, tt = typeof WeakRef < "u" ? WeakRef : et, nt = 0, me = 1;
+function V() {
+  return {
+    s: nt,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function De(e, t = {}) {
+  let n = V();
+  const { resultEqualityCheck: r } = t;
+  let o, i = 0;
+  function c() {
+    let s = n;
+    const { length: f } = arguments;
+    for (let p = 0, b = f; p < b; p++) {
+      const g = arguments[p];
+      if (typeof g == "function" || typeof g == "object" && g !== null) {
+        let y = s.o;
+        y === null && (s.o = y = /* @__PURE__ */ new WeakMap());
+        const v = y.get(g);
+        v === void 0 ? (s = V(), y.set(g, s)) : s = v;
+      } else {
+        let y = s.p;
+        y === null && (s.p = y = /* @__PURE__ */ new Map());
+        const v = y.get(g);
+        v === void 0 ? (s = V(), y.set(g, s)) : s = v;
+      }
+    }
+    const a = s;
+    let u;
+    if (s.s === me)
+      u = s.v;
+    else if (u = e.apply(null, arguments), i++, r) {
+      const p = o?.deref?.() ?? o;
+      p != null && r(p, u) && (u = p, i !== 0 && i--), o = typeof u == "object" && u !== null || typeof u == "function" ? new tt(u) : u;
+    }
+    return a.s = me, a.v = u, u;
+  }
+  return c.clearCache = () => {
+    n = V(), c.resetResultsCount();
+  }, c.resultsCount = () => i, c.resetResultsCount = () => {
+    i = 0;
+  }, c;
+}
+function rt(e, ...t) {
+  const n = typeof e == "function" ? {
+    memoize: e,
+    memoizeOptions: t
+  } : e, r = (...o) => {
+    let i = 0, c = 0, s, f = {}, a = o.pop();
+    typeof a == "object" && (f = a, a = o.pop()), Xe(
+      a,
+      `createSelector expects an output function after the inputs, but received: [${typeof a}]`
+    );
+    const u = {
+      ...n,
+      ...f
+    }, {
+      memoize: p,
+      memoizeOptions: b = [],
+      argsMemoize: g = De,
+      argsMemoizeOptions: y = [],
+      devModeChecks: v = {}
+    } = u, P = ye(b), x = ye(y), I = Ze(o), l = p(function() {
+      return i++, a.apply(
+        null,
+        arguments
+      );
+    }, ...P);
+    let d = !0;
+    const h = g(function() {
+      c++;
+      const w = he(
+        I,
+        arguments
+      );
+      if (s = l.apply(null, w), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: m, inputStabilityCheck: T } = Le(d, v);
+        if (m.shouldRun && m.run(
+          a,
+          w,
+          s
+        ), T.shouldRun) {
+          const X = he(
+            I,
+            arguments
+          );
+          T.run(
+            { inputSelectorResults: w, inputSelectorResultsCopy: X },
+            { memoize: p, memoizeOptions: P },
+            arguments
+          );
+        }
+        d && (d = !1);
+      }
+      return s;
+    }, ...x);
+    return Object.assign(h, {
+      resultFunc: a,
+      memoizedResultFunc: l,
+      dependencies: I,
+      dependencyRecomputations: () => c,
+      resetDependencyRecomputations: () => {
+        c = 0;
+      },
+      lastResult: () => s,
+      recomputations: () => i,
+      resetRecomputations: () => {
+        i = 0;
+      },
+      memoize: p,
+      argsMemoize: g
+    });
+  };
+  return Object.assign(r, {
+    withTypes: () => r
+  }), r;
+}
+var D = /* @__PURE__ */ rt(De), ot = Object.assign(
+  (e, t = D) => {
+    Je(
+      e,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof e}`
+    );
+    const n = Object.keys(e), r = n.map(
+      (i) => e[i]
+    );
+    return t(
+      r,
+      (...i) => i.reduce((c, s, f) => (c[n[f]] = s, c), {})
+    );
+  },
+  { withTypes: () => ot }
+);
+function _e(e, t) {
+  function n(...r) {
+    if (t) {
+      let o = t(...r);
+      if (!o)
+        throw new Error(process.env.NODE_ENV === "production" ? _(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: r[0]
+    };
+  }
+  return n.toString = () => `${e}`, n.type = e, n.match = (r) => Me(r) && r.type === e, n;
+}
+function ge(e) {
+  return S(e) ? Se(e, () => {
+  }) : e;
+}
+function $(e, t, n) {
+  return e.has(t) ? e.get(t) : e.set(t, n(t)).get(t);
+}
+function Oe(e) {
+  const t = {}, n = [];
+  let r;
+  const o = {
+    addCase(i, c) {
+      if (process.env.NODE_ENV !== "production") {
+        if (n.length > 0)
+          throw new Error(process.env.NODE_ENV === "production" ? _(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        if (r)
+          throw new Error(process.env.NODE_ENV === "production" ? _(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" ? _(28) : "`builder.addCase` cannot be called with an empty action type");
+      if (s in t)
+        throw new Error(process.env.NODE_ENV === "production" ? _(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" && r)
+        throw new Error(process.env.NODE_ENV === "production" ? _(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 && n.push({
+        matcher: i.settled,
+        reducer: c.settled
+      }), o;
+    },
+    addMatcher(i, c) {
+      if (process.env.NODE_ENV !== "production" && r)
+        throw new Error(process.env.NODE_ENV === "production" ? _(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+      return n.push({
+        matcher: i,
+        reducer: c
+      }), o;
+    },
+    addDefaultCase(i) {
+      if (process.env.NODE_ENV !== "production" && r)
+        throw new Error(process.env.NODE_ENV === "production" ? _(31) : "`builder.addDefaultCase` can only be called once");
+      return r = i, o;
+    }
+  };
+  return e(o), [t, n, r];
+}
+qe(!1);
+function it(e) {
+  return typeof e == "function";
+}
+function ct(e, t) {
+  if (process.env.NODE_ENV !== "production" && typeof t == "object")
+    throw new Error(process.env.NODE_ENV === "production" ? _(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
+  let [n, r, o] = Oe(t), i;
+  if (it(e))
+    i = () => ge(e());
+  else {
+    const s = ge(e);
+    i = () => s;
+  }
+  function c(s = i(), f) {
+    let a = [n[f.type], ...r.filter(({
+      matcher: u
+    }) => u(f)).map(({
+      reducer: u
+    }) => u)];
+    return a.filter((u) => !!u).length === 0 && (a = [o]), a.reduce((u, p) => {
+      if (p)
+        if (R(u)) {
+          const g = p(u, f);
+          return g === void 0 ? u : g;
+        } else {
+          if (S(u))
+            return Se(u, (b) => p(b, f));
+          {
+            const b = p(u, f);
+            if (b === void 0) {
+              if (u === null)
+                return u;
+              throw Error("A case reducer on a non-draftable value must not return undefined");
+            }
+            return b;
+          }
+        }
+      return u;
+    }, s);
+  }
+  return c.getInitialState = i, c;
+}
+var st = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+function ut(e, t) {
+  return `${e}/${t}`;
+}
+function at({
+  creators: e
+} = {}) {
+  const t = e?.asyncThunk?.[st];
+  return function(r) {
+    const {
+      name: o,
+      reducerPath: i = o
+    } = r;
+    if (!o)
+      throw new Error(process.env.NODE_ENV === "production" ? _(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 c = (typeof r.reducers == "function" ? r.reducers(dt()) : r.reducers) || {}, s = Object.keys(c), f = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    }, a = {
+      addCase(l, d) {
+        const h = typeof l == "string" ? l : l.type;
+        if (!h)
+          throw new Error(process.env.NODE_ENV === "production" ? _(12) : "`context.addCase` cannot be called with an empty action type");
+        if (h in f.sliceCaseReducersByType)
+          throw new Error(process.env.NODE_ENV === "production" ? _(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + h);
+        return f.sliceCaseReducersByType[h] = d, a;
+      },
+      addMatcher(l, d) {
+        return f.sliceMatchers.push({
+          matcher: l,
+          reducer: d
+        }), a;
+      },
+      exposeAction(l, d) {
+        return f.actionCreators[l] = d, a;
+      },
+      exposeCaseReducer(l, d) {
+        return f.sliceCaseReducersByName[l] = d, a;
+      }
+    };
+    s.forEach((l) => {
+      const d = c[l], h = {
+        reducerName: l,
+        type: ut(o, l),
+        createNotation: typeof r.reducers == "function"
+      };
+      yt(d) ? mt(h, d, a, t) : pt(h, d, a);
+    });
+    function u() {
+      if (process.env.NODE_ENV !== "production" && typeof r.extraReducers == "object")
+        throw new Error(process.env.NODE_ENV === "production" ? _(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 [l = {}, d = [], h = void 0] = typeof r.extraReducers == "function" ? Oe(r.extraReducers) : [r.extraReducers], C = {
+        ...l,
+        ...f.sliceCaseReducersByType
+      };
+      return ct(r.initialState, (w) => {
+        for (let m in C)
+          w.addCase(m, C[m]);
+        for (let m of f.sliceMatchers)
+          w.addMatcher(m.matcher, m.reducer);
+        for (let m of d)
+          w.addMatcher(m.matcher, m.reducer);
+        h && w.addDefaultCase(h);
+      });
+    }
+    const p = (l) => l, b = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new WeakMap();
+    let y;
+    function v(l, d) {
+      return y || (y = u()), y(l, d);
+    }
+    function P() {
+      return y || (y = u()), y.getInitialState();
+    }
+    function x(l, d = !1) {
+      function h(w) {
+        let m = w[l];
+        if (typeof m > "u") {
+          if (d)
+            m = $(g, h, P);
+          else if (process.env.NODE_ENV !== "production")
+            throw new Error(process.env.NODE_ENV === "production" ? _(15) : "selectSlice returned undefined for an uninjected slice reducer");
+        }
+        return m;
+      }
+      function C(w = p) {
+        const m = $(b, d, () => /* @__PURE__ */ new WeakMap());
+        return $(m, w, () => {
+          const T = {};
+          for (const [X, Ie] of Object.entries(r.selectors ?? {}))
+            T[X] = ft(Ie, w, () => $(g, w, P), d);
+          return T;
+        });
+      }
+      return {
+        reducerPath: l,
+        getSelectors: C,
+        get selectors() {
+          return C(h);
+        },
+        selectSlice: h
+      };
+    }
+    const I = {
+      name: o,
+      reducer: v,
+      actions: f.actionCreators,
+      caseReducers: f.sliceCaseReducersByName,
+      getInitialState: P,
+      ...x(i),
+      injectInto(l, {
+        reducerPath: d,
+        ...h
+      } = {}) {
+        const C = d ?? i;
+        return l.inject({
+          reducerPath: C,
+          reducer: v
+        }, h), {
+          ...I,
+          ...x(C, !0)
+        };
+      }
+    };
+    return I;
+  };
+}
+function ft(e, t, n, r) {
+  function o(i, ...c) {
+    let s = t(i);
+    if (typeof s > "u") {
+      if (r)
+        s = n();
+      else if (process.env.NODE_ENV !== "production")
+        throw new Error(process.env.NODE_ENV === "production" ? _(16) : "selectState returned undefined for an uninjected slice reducer");
+    }
+    return e(s, ...c);
+  }
+  return o.unwrapped = e, o;
+}
+var lt = /* @__PURE__ */ at();
+function dt() {
+  function e(t, n) {
+    return {
+      _reducerDefinitionType: "asyncThunk",
+      payloadCreator: t,
+      ...n
+    };
+  }
+  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](...n) {
+          return t(...n);
+        }
+      }[t.name], {
+        _reducerDefinitionType: "reducer"
+        /* reducer */
+      });
+    },
+    preparedReducer(t, n) {
+      return {
+        _reducerDefinitionType: "reducerWithPrepare",
+        prepare: t,
+        reducer: n
+      };
+    },
+    asyncThunk: e
+  };
+}
+function pt({
+  type: e,
+  reducerName: t,
+  createNotation: n
+}, r, o) {
+  let i, c;
+  if ("reducer" in r) {
+    if (n && !ht(r))
+      throw new Error(process.env.NODE_ENV === "production" ? _(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+    i = r.reducer, c = r.prepare;
+  } else
+    i = r;
+  o.addCase(e, i).exposeCaseReducer(t, i).exposeAction(t, c ? _e(e, c) : _e(e));
+}
+function yt(e) {
+  return e._reducerDefinitionType === "asyncThunk";
+}
+function ht(e) {
+  return e._reducerDefinitionType === "reducerWithPrepare";
+}
+function mt({
+  type: e,
+  reducerName: t
+}, n, r, o) {
+  if (!o)
+    throw new Error(process.env.NODE_ENV === "production" ? _(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: f,
+    settled: a,
+    options: u
+  } = n, p = o(e, i, u);
+  r.exposeAction(t, p), c && r.addCase(p.fulfilled, c), s && r.addCase(p.pending, s), f && r.addCase(p.rejected, f), a && r.addMatcher(p.settled, a), r.exposeCaseReducer(t, {
+    fulfilled: c || W,
+    pending: s || W,
+    rejected: f || W,
+    settled: a || W
+  });
+}
+function W() {
+}
+function _(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 _t = {
+  maxNotifications: 5,
+  autoDismiss: !0,
+  dismissTimeout: 5e3
+}, gt = {
+  notifications: [],
+  config: _t
+}, wt = (e, t) => {
+  const n = {
+    ...t.payload,
+    id: Date.now().toString(),
+    timestamp: Date.now(),
+    dismissed: !1
+  };
+  e.notifications.unshift(n), e.config.maxNotifications && e.notifications.length > e.config.maxNotifications && (e.notifications = e.notifications.slice(
+    0,
+    e.config.maxNotifications
+  ));
+}, Nt = (e, t) => {
+  const n = e.notifications.find((r) => r.id === t.payload);
+  n && (n.dismissed = !0);
+}, Et = (e, t) => {
+  e.notifications = e.notifications.filter(
+    (n) => n.id !== t.payload
+  );
+}, bt = (e) => {
+  e.notifications = [];
+}, vt = (e, t) => {
+  e.config = { ...e.config, ...t.payload };
+}, Re = lt({
+  name: "notifications",
+  initialState: gt,
+  reducers: {
+    addNotification: wt,
+    dismissNotification: Nt,
+    removeNotification: Et,
+    clearNotifications: bt,
+    updateConfig: vt
+  }
+}), {
+  addNotification: H,
+  dismissNotification: St,
+  removeNotification: Dt,
+  clearNotifications: Ot,
+  updateConfig: Rt
+} = Re.actions, kt = Re.reducer, Pt = (e) => H({ message: e, type: "success" }), It = (e) => H({ message: e, type: "warning" }), Tt = (e) => H({ message: e, type: "error" }), Mt = (e, t) => H({ message: e, type: t }), Ct = "notifications", ke = (e) => e[Ct], se = D(
+  [ke],
+  (e) => e.notifications
+), Pe = D(
+  [se],
+  (e) => e.filter((t) => !t.dismissed)
+), zt = (e) => D(
+  [se],
+  (t) => t.filter((n) => n.type === e)
+), jt = (e) => D(
+  [Pe],
+  (t) => t.filter((n) => n.type === e)
+), At = D(
+  [se],
+  (e) => e.length
+), xt = D(
+  [Pe],
+  (e) => e.length
+), Ft = D(
+  [ke],
+  (e) => e.config
+);
+export {
+  Ct as NotificationKey,
+  H as addNotification,
+  Ot as clearNotifications,
+  St as dismissNotification,
+  kt as notificationReducer,
+  Dt as removeNotification,
+  xt as selectActiveNotificationCount,
+  Pe as selectActiveNotifications,
+  jt as selectActiveNotificationsByType,
+  se as selectAllNotifications,
+  Ft as selectNotificationConfig,
+  At as selectNotificationCount,
+  zt as selectNotificationsByType,
+  ke as selectNotificationsState,
+  Tt as showErrorNotification,
+  Mt as showNotification,
+  Pt as showSuccessNotification,
+  It as showWarningNotification,
+  Rt as updateConfig
+};