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

package/dist/index.js

@@ -0,0 +1,1442 @@
+function tt(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 tt(e) && "type" in e && typeof e.type == "string";
+}
+var Ie = Symbol.for("immer-nothing"), we = Symbol.for("immer-draftable"), S = Symbol.for("immer-state"), rt = 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 r = rt[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 F = Object.getPrototypeOf;
+function M(e) {
+  return !!e && !!e[S];
+}
+function D(e) {
+  return e ? je(e) || Array.isArray(e) || !!e[we] || !!e.constructor?.[we] || x(e) || Q(e) : !1;
+}
+var nt = Object.prototype.constructor.toString(), ve = /* @__PURE__ */ new WeakMap();
+function je(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 = ve.get(r);
+  return n === void 0 && (n = Function.toString.call(r), ve.set(r, n)), n === nt;
+}
+function q(e, t, r = !0) {
+  X(e) === 0 ? (r ? Reflect.ownKeys(e) : Object.keys(e)).forEach((o) => {
+    t(o, e[o], e);
+  }) : e.forEach((n, o) => t(o, n, e));
+}
+function X(e) {
+  const t = e[S];
+  return t ? t.type_ : Array.isArray(e) ? 1 : x(e) ? 2 : Q(e) ? 3 : 0;
+}
+function se(e, t) {
+  return X(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function ze(e, t, r) {
+  const n = X(e);
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+}
+function ot(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function x(e) {
+  return e instanceof Map;
+}
+function Q(e) {
+  return e instanceof Set;
+}
+function R(e) {
+  return e.copy_ || e.base_;
+}
+function ce(e, t) {
+  if (x(e))
+    return new Map(e);
+  if (Q(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const r = je(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = Object.getOwnPropertyDescriptors(e);
+    delete n[S];
+    let o = Reflect.ownKeys(n);
+    for (let i = 0; i < o.length; i++) {
+      const s = o[i], c = n[s];
+      c.writable === !1 && (c.writable = !0, c.configurable = !0), (c.get || c.set) && (n[s] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: c.enumerable,
+        value: e[s]
+      });
+    }
+    return Object.create(F(e), n);
+  } else {
+    const n = F(e);
+    if (n !== null && r)
+      return { ...e };
+    const o = Object.create(n);
+    return Object.assign(o, e);
+  }
+}
+function he(e, t = !1) {
+  return Z(e) || M(e) || !D(e) || (X(e) > 1 && Object.defineProperties(e, {
+    set: W,
+    add: W,
+    clear: W,
+    delete: W
+  }), Object.freeze(e), t && Object.values(e).forEach((r) => he(r, !0))), e;
+}
+function it() {
+  N(2);
+}
+var W = {
+  value: it
+};
+function Z(e) {
+  return e === null || typeof e != "object" ? !0 : Object.isFrozen(e);
+}
+var st = {};
+function I(e) {
+  const t = st[e];
+  return t || N(0, e), t;
+}
+var $;
+function Ae() {
+  return $;
+}
+function ct(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 Ee(e, t) {
+  t && (I("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function ae(e) {
+  ue(e), e.drafts_.forEach(at), e.drafts_ = null;
+}
+function ue(e) {
+  e === $ && ($ = e.parent_);
+}
+function be(e) {
+  return $ = ct($, e);
+}
+function at(e) {
+  const t = e[S];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function Ce(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  return e !== void 0 && e !== r ? (r[S].modified_ && (ae(t), N(4)), D(e) && (e = H(t, e), t.parent_ || G(t, e)), t.patches_ && I("Patches").generateReplacementPatches_(
+    r[S].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = H(t, r, []), ae(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== Ie ? e : void 0;
+}
+function H(e, t, r) {
+  if (Z(t))
+    return t;
+  const n = e.immer_.shouldUseStrictIteration(), o = t[S];
+  if (!o)
+    return q(
+      t,
+      (i, s) => Ne(e, o, t, i, s, 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 s = i, c = !1;
+    o.type_ === 3 && (s = new Set(i), i.clear(), c = !0), q(
+      s,
+      (u, l) => Ne(
+        e,
+        o,
+        i,
+        u,
+        l,
+        r,
+        c
+      ),
+      n
+    ), G(e, i, !1), r && e.patches_ && I("Patches").generatePatches_(
+      o,
+      r,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return o.copy_;
+}
+function Ne(e, t, r, n, o, i, s) {
+  if (o == null || typeof o != "object" && !s)
+    return;
+  const c = Z(o);
+  if (!(c && !s)) {
+    if (process.env.NODE_ENV !== "production" && o === r && N(5), M(o)) {
+      const u = i && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+      !se(t.assigned_, n) ? i.concat(n) : void 0, l = H(e, o, u);
+      if (ze(r, n, l), M(l))
+        e.canAutoFreeze_ = !1;
+      else
+        return;
+    } else s && r.add(o);
+    if (D(o) && !c) {
+      if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1 || t && t.base_ && t.base_[n] === o && c)
+        return;
+      H(e, o), (!t || !t.scope_.parent_) && typeof n != "symbol" && (x(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_ && he(t, r);
+}
+function ut(e, t) {
+  const r = Array.isArray(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : Ae(),
+    // 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 = me;
+  r && (o = [n], i = L);
+  const { revoke: s, proxy: c } = Proxy.revocable(o, i);
+  return n.draft_ = c, n.revoke_ = s, c;
+}
+var me = {
+  get(e, t) {
+    if (t === S)
+      return e;
+    const r = R(e);
+    if (!se(r, t))
+      return lt(e, r, t);
+    const n = r[t];
+    return e.finalized_ || !D(n) ? n : n === oe(e.base_, t) ? (ie(e), e.copy_[t] = fe(n, e)) : n;
+  },
+  has(e, t) {
+    return t in R(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(R(e));
+  },
+  set(e, t, r) {
+    const n = Fe(R(e), t);
+    if (n?.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const o = oe(R(e), t), i = o?.[S];
+      if (i && i.base_ === r)
+        return e.copy_[t] = r, e.assigned_[t] = !1, !0;
+      if (ot(r, o) && (r !== void 0 || se(e.base_, t)))
+        return !0;
+      ie(e), le(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 oe(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, ie(e), le(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 = R(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: n.enumerable,
+      value: r[t]
+    };
+  },
+  defineProperty() {
+    N(11);
+  },
+  getPrototypeOf(e) {
+    return F(e.base_);
+  },
+  setPrototypeOf() {
+    N(12);
+  }
+}, L = {};
+q(me, (e, t) => {
+  L[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+L.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && N(13), L.set.call(this, e, t, void 0);
+};
+L.set = function(e, t, r) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && N(14), me.set.call(this, e[0], t, r, e[0]);
+};
+function oe(e, t) {
+  const r = e[S];
+  return (r ? R(r) : e)[t];
+}
+function lt(e, t, r) {
+  const n = Fe(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 Fe(e, t) {
+  if (!(t in e))
+    return;
+  let r = F(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = F(r);
+  }
+}
+function le(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && le(e.parent_));
+}
+function ie(e) {
+  e.copy_ || (e.copy_ = ce(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var ft = 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 s = this;
+        return function(u = i, ...l) {
+          return s.produce(u, (f) => r.call(this, f, ...l));
+        };
+      }
+      typeof r != "function" && N(6), n !== void 0 && typeof n != "function" && N(7);
+      let o;
+      if (D(t)) {
+        const i = be(this), s = fe(t, void 0);
+        let c = !0;
+        try {
+          o = r(s), c = !1;
+        } finally {
+          c ? ae(i) : ue(i);
+        }
+        return Ee(i, n), Ce(o, i);
+      } else if (!t || typeof t != "object") {
+        if (o = r(t), o === void 0 && (o = t), o === Ie && (o = void 0), this.autoFreeze_ && he(o, !0), n) {
+          const i = [], s = [];
+          I("Patches").generateReplacementPatches_(t, o, i, s), n(i, s);
+        }
+        return o;
+      } else
+        N(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (typeof t == "function")
+        return (s, ...c) => this.produceWithPatches(s, (u) => t(u, ...c));
+      let n, o;
+      return [this.produce(t, r, (s, c) => {
+        n = s, 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) {
+    D(e) || N(8), M(e) && (e = dt(e));
+    const t = be(this), r = fe(e, void 0);
+    return r[S].isManual_ = !0, ue(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[S];
+    (!r || !r.isManual_) && N(9);
+    const { scope_: n } = r;
+    return Ee(n, t), Ce(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 = I("Patches").applyPatches_;
+    return M(e) ? n(e, t) : this.produce(
+      e,
+      (o) => n(o, t)
+    );
+  }
+};
+function fe(e, t) {
+  const r = x(e) ? I("MapSet").proxyMap_(e, t) : Q(e) ? I("MapSet").proxySet_(e, t) : ut(e, t);
+  return (t ? t.scope_ : Ae()).drafts_.push(r), r;
+}
+function dt(e) {
+  return M(e) || N(10, e), $e(e);
+}
+function $e(e) {
+  if (!D(e) || Z(e))
+    return e;
+  const t = e[S];
+  let r, n = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = ce(e, t.scope_.immer_.useStrictShallowCopy_), n = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    r = ce(e, !0);
+  return q(
+    r,
+    (o, i) => {
+      ze(r, o, $e(i));
+    },
+    n
+  ), t && (t.finalized_ = !1), r;
+}
+var de = new ft(), Le = de.produce, pt = /* @__PURE__ */ de.setUseStrictIteration.bind(
+  de
+), yt = (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 }
+      );
+    }
+  }
+}, ht = (e, t, r) => {
+  const { memoize: n, memoizeOptions: o } = t, { inputSelectorResults: i, inputSelectorResultsCopy: s } = e, c = n(() => ({}), ...o);
+  if (!(c.apply(null, i) === c.apply(null, s))) {
+    let l;
+    try {
+      throw new Error();
+    } catch (f) {
+      ({ stack: l } = f);
+    }
+    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: s,
+        stack: l
+      }
+    );
+  }
+}, mt = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+};
+function gt(e, t = `expected a function, instead received ${typeof e}`) {
+  if (typeof e != "function")
+    throw new TypeError(t);
+}
+function _t(e, t = `expected an object, instead received ${typeof e}`) {
+  if (typeof e != "object")
+    throw new TypeError(t);
+}
+function wt(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 vt(e) {
+  const t = Array.isArray(e[0]) ? e[0] : e;
+  return wt(
+    t,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), t;
+}
+function Se(e, t) {
+  const r = [], { length: n } = e;
+  for (let o = 0; o < n; o++)
+    r.push(e[o].apply(null, t));
+  return r;
+}
+var Et = (e, t) => {
+  const { identityFunctionCheck: r, inputStabilityCheck: n } = {
+    ...mt,
+    ...t
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: r === "always" || r === "once" && e,
+      run: yt
+    },
+    inputStabilityCheck: {
+      shouldRun: n === "always" || n === "once" && e,
+      run: ht
+    }
+  };
+}, bt = class {
+  constructor(e) {
+    this.value = e;
+  }
+  deref() {
+    return this.value;
+  }
+}, Ct = typeof WeakRef < "u" ? WeakRef : bt, Nt = 0, ke = 1;
+function B() {
+  return {
+    s: Nt,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function xe(e, t = {}) {
+  let r = B();
+  const { resultEqualityCheck: n } = t;
+  let o, i = 0;
+  function s() {
+    let c = r;
+    const { length: u } = arguments;
+    for (let h = 0, v = u; h < v; h++) {
+      const a = arguments[h];
+      if (typeof a == "function" || typeof a == "object" && a !== null) {
+        let d = c.o;
+        d === null && (c.o = d = /* @__PURE__ */ new WeakMap());
+        const g = d.get(a);
+        g === void 0 ? (c = B(), d.set(a, c)) : c = g;
+      } else {
+        let d = c.p;
+        d === null && (c.p = d = /* @__PURE__ */ new Map());
+        const g = d.get(a);
+        g === void 0 ? (c = B(), d.set(a, c)) : c = g;
+      }
+    }
+    const l = c;
+    let f;
+    if (c.s === ke)
+      f = c.v;
+    else if (f = e.apply(null, arguments), i++, n) {
+      const h = o?.deref?.() ?? o;
+      h != null && n(h, f) && (f = h, i !== 0 && i--), o = typeof f == "object" && f !== null || typeof f == "function" ? new Ct(f) : f;
+    }
+    return l.s = ke, l.v = f, f;
+  }
+  return s.clearCache = () => {
+    r = B(), s.resetResultsCount();
+  }, s.resultsCount = () => i, s.resetResultsCount = () => {
+    i = 0;
+  }, s;
+}
+function Ot(e, ...t) {
+  const r = typeof e == "function" ? {
+    memoize: e,
+    memoizeOptions: t
+  } : e, n = (...o) => {
+    let i = 0, s = 0, c, u = {}, l = o.pop();
+    typeof l == "object" && (u = l, l = o.pop()), gt(
+      l,
+      `createSelector expects an output function after the inputs, but received: [${typeof l}]`
+    );
+    const f = {
+      ...r,
+      ...u
+    }, {
+      memoize: h,
+      memoizeOptions: v = [],
+      argsMemoize: a = xe,
+      argsMemoizeOptions: d = [],
+      devModeChecks: g = {}
+    } = f, O = Oe(v), w = Oe(d), k = vt(o), y = h(function() {
+      return i++, l.apply(
+        null,
+        arguments
+      );
+    }, ...O);
+    let p = !0;
+    const m = a(function() {
+      s++;
+      const C = Se(
+        k,
+        arguments
+      );
+      if (c = y.apply(null, C), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: E, inputStabilityCheck: A } = Et(p, g);
+        if (E.shouldRun && E.run(
+          l,
+          C,
+          c
+        ), A.shouldRun) {
+          const ne = Se(
+            k,
+            arguments
+          );
+          A.run(
+            { inputSelectorResults: C, inputSelectorResultsCopy: ne },
+            { memoize: h, memoizeOptions: O },
+            arguments
+          );
+        }
+        p && (p = !1);
+      }
+      return c;
+    }, ...w);
+    return Object.assign(m, {
+      resultFunc: l,
+      memoizedResultFunc: y,
+      dependencies: k,
+      dependencyRecomputations: () => s,
+      resetDependencyRecomputations: () => {
+        s = 0;
+      },
+      lastResult: () => c,
+      recomputations: () => i,
+      resetRecomputations: () => {
+        i = 0;
+      },
+      memoize: h,
+      argsMemoize: a
+    });
+  };
+  return Object.assign(n, {
+    withTypes: () => n
+  }), n;
+}
+var ee = /* @__PURE__ */ Ot(xe), St = Object.assign(
+  (e, t = ee) => {
+    _t(
+      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(
+      (i) => e[i]
+    );
+    return t(
+      n,
+      (...i) => i.reduce((s, c, u) => (s[r[u]] = c, s), {})
+    );
+  },
+  { withTypes: () => St }
+);
+function z(e, t) {
+  function r(...n) {
+    if (t) {
+      let o = t(...n);
+      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: n[0]
+    };
+  }
+  return r.toString = () => `${e}`, r.type = e, r.match = (n) => Me(n) && n.type === e, r;
+}
+function De(e) {
+  return D(e) ? Le(e, () => {
+  }) : e;
+}
+function U(e, t, r) {
+  return e.has(t) ? e.get(t) : e.set(t, r(t)).get(t);
+}
+function Ve(e) {
+  const t = {}, r = [];
+  let n;
+  const o = {
+    addCase(i, s) {
+      if (process.env.NODE_ENV !== "production") {
+        if (r.length > 0)
+          throw new Error(process.env.NODE_ENV === "production" ? _(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        if (n)
+          throw new Error(process.env.NODE_ENV === "production" ? _(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
+      }
+      const c = typeof i == "string" ? i : i.type;
+      if (!c)
+        throw new Error(process.env.NODE_ENV === "production" ? _(28) : "`builder.addCase` cannot be called with an empty action type");
+      if (c in t)
+        throw new Error(process.env.NODE_ENV === "production" ? _(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${c}'`);
+      return t[c] = s, o;
+    },
+    addAsyncThunk(i, s) {
+      if (process.env.NODE_ENV !== "production" && n)
+        throw new Error(process.env.NODE_ENV === "production" ? _(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
+      return s.pending && (t[i.pending.type] = s.pending), s.rejected && (t[i.rejected.type] = s.rejected), s.fulfilled && (t[i.fulfilled.type] = s.fulfilled), s.settled && r.push({
+        matcher: i.settled,
+        reducer: s.settled
+      }), o;
+    },
+    addMatcher(i, s) {
+      if (process.env.NODE_ENV !== "production" && n)
+        throw new Error(process.env.NODE_ENV === "production" ? _(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+      return r.push({
+        matcher: i,
+        reducer: s
+      }), o;
+    },
+    addDefaultCase(i) {
+      if (process.env.NODE_ENV !== "production" && n)
+        throw new Error(process.env.NODE_ENV === "production" ? _(31) : "`builder.addDefaultCase` can only be called once");
+      return n = i, o;
+    }
+  };
+  return e(o), [t, r, n];
+}
+pt(!1);
+function kt(e) {
+  return typeof e == "function";
+}
+function Dt(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 [r, n, o] = Ve(t), i;
+  if (kt(e))
+    i = () => De(e());
+  else {
+    const c = De(e);
+    i = () => c;
+  }
+  function s(c = i(), u) {
+    let l = [r[u.type], ...n.filter(({
+      matcher: f
+    }) => f(u)).map(({
+      reducer: f
+    }) => f)];
+    return l.filter((f) => !!f).length === 0 && (l = [o]), l.reduce((f, h) => {
+      if (h)
+        if (M(f)) {
+          const a = h(f, u);
+          return a === void 0 ? f : a;
+        } else {
+          if (D(f))
+            return Le(f, (v) => h(v, u));
+          {
+            const v = h(f, u);
+            if (v === void 0) {
+              if (f === null)
+                return f;
+              throw Error("A case reducer on a non-draftable value must not return undefined");
+            }
+            return v;
+          }
+        }
+      return f;
+    }, c);
+  }
+  return s.getInitialState = i, s;
+}
+var Rt = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW", Pt = (e = 21) => {
+  let t = "", r = e;
+  for (; r--; )
+    t += Rt[Math.random() * 64 | 0];
+  return t;
+}, Tt = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+function Mt(e, t) {
+  return `${e}/${t}`;
+}
+function It({
+  creators: e
+} = {}) {
+  const t = e?.asyncThunk?.[Tt];
+  return function(n) {
+    const {
+      name: o,
+      reducerPath: i = o
+    } = n;
+    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" && n.initialState === void 0 && console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+    const s = (typeof n.reducers == "function" ? n.reducers(At()) : n.reducers) || {}, c = Object.keys(s), u = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    }, l = {
+      addCase(y, p) {
+        const m = typeof y == "string" ? y : y.type;
+        if (!m)
+          throw new Error(process.env.NODE_ENV === "production" ? _(12) : "`context.addCase` cannot be called with an empty action type");
+        if (m in u.sliceCaseReducersByType)
+          throw new Error(process.env.NODE_ENV === "production" ? _(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + m);
+        return u.sliceCaseReducersByType[m] = p, l;
+      },
+      addMatcher(y, p) {
+        return u.sliceMatchers.push({
+          matcher: y,
+          reducer: p
+        }), l;
+      },
+      exposeAction(y, p) {
+        return u.actionCreators[y] = p, l;
+      },
+      exposeCaseReducer(y, p) {
+        return u.sliceCaseReducersByName[y] = p, l;
+      }
+    };
+    c.forEach((y) => {
+      const p = s[y], m = {
+        reducerName: y,
+        type: Mt(o, y),
+        createNotation: typeof n.reducers == "function"
+      };
+      $t(p) ? xt(m, p, l, t) : Ft(m, p, l);
+    });
+    function f() {
+      if (process.env.NODE_ENV !== "production" && typeof n.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 [y = {}, p = [], m = void 0] = typeof n.extraReducers == "function" ? Ve(n.extraReducers) : [n.extraReducers], b = {
+        ...y,
+        ...u.sliceCaseReducersByType
+      };
+      return Dt(n.initialState, (C) => {
+        for (let E in b)
+          C.addCase(E, b[E]);
+        for (let E of u.sliceMatchers)
+          C.addMatcher(E.matcher, E.reducer);
+        for (let E of p)
+          C.addMatcher(E.matcher, E.reducer);
+        m && C.addDefaultCase(m);
+      });
+    }
+    const h = (y) => y, v = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new WeakMap();
+    let d;
+    function g(y, p) {
+      return d || (d = f()), d(y, p);
+    }
+    function O() {
+      return d || (d = f()), d.getInitialState();
+    }
+    function w(y, p = !1) {
+      function m(C) {
+        let E = C[y];
+        if (typeof E > "u") {
+          if (p)
+            E = U(a, m, O);
+          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 E;
+      }
+      function b(C = h) {
+        const E = U(v, p, () => /* @__PURE__ */ new WeakMap());
+        return U(E, C, () => {
+          const A = {};
+          for (const [ne, et] of Object.entries(n.selectors ?? {}))
+            A[ne] = jt(et, C, () => U(a, C, O), p);
+          return A;
+        });
+      }
+      return {
+        reducerPath: y,
+        getSelectors: b,
+        get selectors() {
+          return b(m);
+        },
+        selectSlice: m
+      };
+    }
+    const k = {
+      name: o,
+      reducer: g,
+      actions: u.actionCreators,
+      caseReducers: u.sliceCaseReducersByName,
+      getInitialState: O,
+      ...w(i),
+      injectInto(y, {
+        reducerPath: p,
+        ...m
+      } = {}) {
+        const b = p ?? i;
+        return y.inject({
+          reducerPath: b,
+          reducer: g
+        }, m), {
+          ...k,
+          ...w(b, !0)
+        };
+      }
+    };
+    return k;
+  };
+}
+function jt(e, t, r, n) {
+  function o(i, ...s) {
+    let c = t(i);
+    if (typeof c > "u") {
+      if (n)
+        c = r();
+      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(c, ...s);
+  }
+  return o.unwrapped = e, o;
+}
+var zt = /* @__PURE__ */ It();
+function At() {
+  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 Ft({
+  type: e,
+  reducerName: t,
+  createNotation: r
+}, n, o) {
+  let i, s;
+  if ("reducer" in n) {
+    if (r && !Lt(n))
+      throw new Error(process.env.NODE_ENV === "production" ? _(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+    i = n.reducer, s = n.prepare;
+  } else
+    i = n;
+  o.addCase(e, i).exposeCaseReducer(t, i).exposeAction(t, s ? z(e, s) : z(e));
+}
+function $t(e) {
+  return e._reducerDefinitionType === "asyncThunk";
+}
+function Lt(e) {
+  return e._reducerDefinitionType === "reducerWithPrepare";
+}
+function xt({
+  type: e,
+  reducerName: t
+}, r, n, 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: s,
+    pending: c,
+    rejected: u,
+    settled: l,
+    options: f
+  } = r, h = o(e, i, f);
+  n.exposeAction(t, h), s && n.addCase(h.fulfilled, s), c && n.addCase(h.pending, c), u && n.addCase(h.rejected, u), l && n.addMatcher(h.settled, l), n.exposeCaseReducer(t, {
+    fulfilled: s || K,
+    pending: c || K,
+    rejected: u || K,
+    settled: l || K
+  });
+}
+function K() {
+}
+var Vt = "task", We = "listener", Be = "completed", ge = "cancelled", Wt = `task-${ge}`, Bt = `task-${Be}`, pe = `${We}-${ge}`, Ut = `${We}-${Be}`, te = class {
+  constructor(e) {
+    this.code = e, this.message = `${Vt} ${ge} (reason: ${e})`;
+  }
+  name = "TaskAbortError";
+  message;
+}, _e = (e, t) => {
+  if (typeof e != "function")
+    throw new TypeError(process.env.NODE_ENV === "production" ? _(32) : `${t} is not a function`);
+}, J = () => {
+}, Ue = (e, t = J) => (e.catch(t), e), Ke = (e, t) => (e.addEventListener("abort", t, {
+  once: !0
+}), () => e.removeEventListener("abort", t)), P = (e, t) => {
+  const r = e.signal;
+  r.aborted || ("reason" in r || Object.defineProperty(r, "reason", {
+    enumerable: !0,
+    value: t,
+    configurable: !0,
+    writable: !0
+  }), e.abort(t));
+}, T = (e) => {
+  if (e.aborted) {
+    const {
+      reason: t
+    } = e;
+    throw new te(t);
+  }
+};
+function qe(e, t) {
+  let r = J;
+  return new Promise((n, o) => {
+    const i = () => o(new te(e.reason));
+    if (e.aborted) {
+      i();
+      return;
+    }
+    r = Ke(e, i), t.finally(() => r()).then(n, o);
+  }).finally(() => {
+    r = J;
+  });
+}
+var Kt = async (e, t) => {
+  try {
+    return await Promise.resolve(), {
+      status: "ok",
+      value: await e()
+    };
+  } catch (r) {
+    return {
+      status: r instanceof te ? "cancelled" : "rejected",
+      error: r
+    };
+  } finally {
+    t?.();
+  }
+}, Y = (e) => (t) => Ue(qe(e, t).then((r) => (T(e), r))), He = (e) => {
+  const t = Y(e);
+  return (r) => t(new Promise((n) => setTimeout(n, r)));
+}, {
+  assign: j
+} = Object, Re = {}, V = "listenerMiddleware", qt = (e, t) => {
+  const r = (n) => Ke(e, () => P(n, e.reason));
+  return (n, o) => {
+    _e(n, "taskExecutor");
+    const i = new AbortController();
+    r(i);
+    const s = Kt(async () => {
+      T(e), T(i.signal);
+      const c = await n({
+        pause: Y(i.signal),
+        delay: He(i.signal),
+        signal: i.signal
+      });
+      return T(i.signal), c;
+    }, () => P(i, Bt));
+    return o?.autoJoin && t.push(s.catch(J)), {
+      result: Y(e)(s),
+      cancel() {
+        P(i, Wt);
+      }
+    };
+  };
+}, Ht = (e, t) => {
+  const r = async (n, o) => {
+    T(t);
+    let i = () => {
+    };
+    const c = [new Promise((u, l) => {
+      let f = e({
+        predicate: n,
+        effect: (h, v) => {
+          v.unsubscribe(), u([h, v.getState(), v.getOriginalState()]);
+        }
+      });
+      i = () => {
+        f(), l();
+      };
+    })];
+    o != null && c.push(new Promise((u) => setTimeout(u, o, null)));
+    try {
+      const u = await qe(t, Promise.race(c));
+      return T(t), u;
+    } finally {
+      i();
+    }
+  };
+  return (n, o) => Ue(r(n, o));
+}, Ge = (e) => {
+  let {
+    type: t,
+    actionCreator: r,
+    matcher: n,
+    predicate: o,
+    effect: i
+  } = e;
+  if (t)
+    o = z(t).match;
+  else if (r)
+    t = r.type, o = r.match;
+  else if (n)
+    o = n;
+  else if (!o) throw new Error(process.env.NODE_ENV === "production" ? _(21) : "Creating or removing a listener requires one of the known fields for matching an action");
+  return _e(i, "options.listener"), {
+    predicate: o,
+    type: t,
+    effect: i
+  };
+}, Je = /* @__PURE__ */ j((e) => {
+  const {
+    type: t,
+    predicate: r,
+    effect: n
+  } = Ge(e);
+  return {
+    id: Pt(),
+    effect: n,
+    type: t,
+    predicate: r,
+    pending: /* @__PURE__ */ new Set(),
+    unsubscribe: () => {
+      throw new Error(process.env.NODE_ENV === "production" ? _(22) : "Unsubscribe not initialized");
+    }
+  };
+}, {
+  withTypes: () => Je
+}), Pe = (e, t) => {
+  const {
+    type: r,
+    effect: n,
+    predicate: o
+  } = Ge(t);
+  return Array.from(e.values()).find((i) => (typeof r == "string" ? i.type === r : i.predicate === o) && i.effect === n);
+}, ye = (e) => {
+  e.pending.forEach((t) => {
+    P(t, pe);
+  });
+}, Gt = (e, t) => () => {
+  for (const r of t.keys())
+    ye(r);
+  e.clear();
+}, Te = (e, t, r) => {
+  try {
+    e(t, r);
+  } catch (n) {
+    setTimeout(() => {
+      throw n;
+    }, 0);
+  }
+}, Ye = /* @__PURE__ */ j(/* @__PURE__ */ z(`${V}/add`), {
+  withTypes: () => Ye
+}), Jt = /* @__PURE__ */ z(`${V}/removeAll`), Xe = /* @__PURE__ */ j(/* @__PURE__ */ z(`${V}/remove`), {
+  withTypes: () => Xe
+}), Yt = (...e) => {
+  console.error(`${V}/error`, ...e);
+}, Xt = (e = {}) => {
+  const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), n = (a) => {
+    const d = r.get(a) ?? 0;
+    r.set(a, d + 1);
+  }, o = (a) => {
+    const d = r.get(a) ?? 1;
+    d === 1 ? r.delete(a) : r.set(a, d - 1);
+  }, {
+    extra: i,
+    onError: s = Yt
+  } = e;
+  _e(s, "onError");
+  const c = (a) => (a.unsubscribe = () => t.delete(a.id), t.set(a.id, a), (d) => {
+    a.unsubscribe(), d?.cancelActive && ye(a);
+  }), u = (a) => {
+    const d = Pe(t, a) ?? Je(a);
+    return c(d);
+  };
+  j(u, {
+    withTypes: () => u
+  });
+  const l = (a) => {
+    const d = Pe(t, a);
+    return d && (d.unsubscribe(), a.cancelActive && ye(d)), !!d;
+  };
+  j(l, {
+    withTypes: () => l
+  });
+  const f = async (a, d, g, O) => {
+    const w = new AbortController(), k = Ht(u, w.signal), y = [];
+    try {
+      a.pending.add(w), n(a), await Promise.resolve(a.effect(
+        d,
+        // Use assign() rather than ... to avoid extra helper functions added to bundle
+        j({}, g, {
+          getOriginalState: O,
+          condition: (p, m) => k(p, m).then(Boolean),
+          take: k,
+          delay: He(w.signal),
+          pause: Y(w.signal),
+          extra: i,
+          signal: w.signal,
+          fork: qt(w.signal, y),
+          unsubscribe: a.unsubscribe,
+          subscribe: () => {
+            t.set(a.id, a);
+          },
+          cancelActiveListeners: () => {
+            a.pending.forEach((p, m, b) => {
+              p !== w && (P(p, pe), b.delete(p));
+            });
+          },
+          cancel: () => {
+            P(w, pe), a.pending.delete(w);
+          },
+          throwIfCancelled: () => {
+            T(w.signal);
+          }
+        })
+      ));
+    } catch (p) {
+      p instanceof te || Te(s, p, {
+        raisedBy: "effect"
+      });
+    } finally {
+      await Promise.all(y), P(w, Ut), o(a), a.pending.delete(w);
+    }
+  }, h = Gt(t, r);
+  return {
+    middleware: (a) => (d) => (g) => {
+      if (!Me(g))
+        return d(g);
+      if (Ye.match(g))
+        return u(g.payload);
+      if (Jt.match(g)) {
+        h();
+        return;
+      }
+      if (Xe.match(g))
+        return l(g.payload);
+      let O = a.getState();
+      const w = () => {
+        if (O === Re)
+          throw new Error(process.env.NODE_ENV === "production" ? _(23) : `${V}: getOriginalState can only be called synchronously`);
+        return O;
+      };
+      let k;
+      try {
+        if (k = d(g), t.size > 0) {
+          const y = a.getState(), p = Array.from(t.values());
+          for (const m of p) {
+            let b = !1;
+            try {
+              b = m.predicate(g, y, O);
+            } catch (C) {
+              b = !1, Te(s, C, {
+                raisedBy: "predicate"
+              });
+            }
+            b && f(m, g, a, w);
+          }
+        }
+      } finally {
+        O = Re;
+      }
+      return k;
+    },
+    startListening: u,
+    stopListening: l,
+    clearListeners: h
+  };
+};
+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 Qt = {
+  logs: []
+}, Qe = zt({
+  name: "logger",
+  initialState: Qt,
+  reducers: {
+    addLog: (e, t) => {
+      const r = {
+        ...t.payload,
+        id: Date.now().toString(),
+        timestamp: Date.now()
+      };
+      e.logs.push(r);
+    },
+    clearLogs: (e) => {
+      e.logs = [];
+    }
+  }
+}), { addLog: re, clearLogs: rr } = Qe.actions, nr = Qe.reducer, or = (e) => re({ message: e, level: "info" }), ir = (e) => re({ message: e, level: "warn" }), sr = (e) => re({ message: e, level: "error" }), Zt = "logger", er = (e) => e[Zt], Ze = ee(
+  [er],
+  (e) => e.logs
+), cr = ee(
+  [Ze, (e, t) => t],
+  (e, t) => e.filter((r) => r.level === t)
+), ar = ee(
+  [Ze, (e, t) => t],
+  (e, t) => t === 0 ? [] : e.slice(-t)
+), tr = () => {
+  const e = Xt();
+  return e.startListening({
+    actionCreator: re,
+    effect: (t, r) => {
+      const n = t.payload, { message: o, level: i } = n;
+      switch (i) {
+        case "info":
+          console.info(`[INFO] ${o}`);
+          break;
+        case "warn":
+          console.warn(`[WARN] ${o}`);
+          break;
+        case "error":
+          console.error(`[ERROR] ${o}`);
+          break;
+      }
+    }
+  }), e.middleware;
+}, ur = (e) => {
+  switch (e.destination) {
+    case "console":
+      return tr();
+    default:
+      throw new Error(`Unsupported logger destination: ${e.destination}`);
+  }
+};
+export {
+  Zt as LoggerKey,
+  re as addLog,
+  rr as clearLogs,
+  ur as createLoggerMiddleware,
+  sr as logError,
+  or as logInfo,
+  ir as logWarn,
+  nr as loggerReducer,
+  Qe as loggerSlice,
+  er as selectLoggerState,
+  Ze as selectLogs,
+  cr as selectLogsByLevel,
+  ar as selectRecentLogs
+};