@pibit.ai/cure-design-system 0.6.42 → 0.6.44

package/dist/node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.js

@@ -0,0 +1,846 @@
+var Ne = Object.defineProperty;
+var ge = (e, t, r) => t in e ? Ne(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var A = (e, t, r) => ge(e, typeof t != "symbol" ? t + "" : t, r);
+import { isPlainObject as K, combineReducers as De, applyMiddleware as ve, compose as P, createStore as Oe, isAction as q } from "../../../redux/dist/redux.js";
+import { __DO_NOT_USE__ActionTypes as Nt } from "../../../redux/dist/redux.js";
+import { produce as Y, isDraftable as Z, isDraft as ke } from "../../../immer/dist/immer.js";
+import { current as Dt, freeze as vt } from "../../../immer/dist/immer.js";
+import { thunk as _e, withExtraArgument as Ce } from "../../../redux-thunk/dist/redux-thunk.js";
+const Te = typeof window < "u" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
+  if (arguments.length !== 0)
+    return typeof arguments[0] == "object" ? P : P.apply(null, arguments);
+}, Me = (e) => e && typeof e.match == "function";
+function M(e, t) {
+  function r(...n) {
+    if (t) {
+      let o = t(...n);
+      if (!o) throw new Error(process.env.NODE_ENV === "production" ? y(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) => q(n) && n.type === e, r;
+}
+function Se(e) {
+  return typeof e == "function" && "type" in e && Me(e);
+}
+function Ve(e) {
+  const t = e ? `${e}`.split("/") : [], r = t[t.length - 1] || "actionCreator";
+  return `Detected an action creator with type "${e || "unknown"}" being dispatched.
+Make sure you're calling the action creator before dispatching, i.e. \`dispatch(${r}())\` instead of \`dispatch(${r})\`. This is necessary even if the action has no payload.`;
+}
+function Ae(e = {}) {
+  if (process.env.NODE_ENV === "production") return () => (r) => (n) => r(n);
+  const { isActionCreator: t = Se } = e;
+  return () => (r) => (n) => (t(n) && console.warn(Ve(n.type)), r(n));
+}
+function ee(e, t) {
+  let r = 0;
+  return {
+    measureTime(n) {
+      const o = Date.now();
+      try {
+        return n();
+      } finally {
+        r += Date.now() - o;
+      }
+    },
+    warnIfExceeded() {
+      r > e && console.warn(`${t} took ${r}ms, which is more than the warning threshold of ${e}ms. 
+If your state or actions are very large, you may want to disable the middleware as it might cause too much of a slowdown in development mode. See https://redux-toolkit.js.org/api/getDefaultMiddleware for instructions.
+It is disabled in production builds, so you don't need to worry about that.`);
+    }
+  };
+}
+var te = class S extends Array {
+  constructor(...t) {
+    super(...t), Object.setPrototypeOf(this, S.prototype);
+  }
+  static get [Symbol.species]() {
+    return S;
+  }
+  concat(...t) {
+    return super.concat.apply(this, t);
+  }
+  prepend(...t) {
+    return t.length === 1 && Array.isArray(t[0]) ? new S(...t[0].concat(this)) : new S(...t.concat(this));
+  }
+};
+function H(e) {
+  return Z(e) ? Y(e, () => {
+  }) : e;
+}
+function R(e, t, r) {
+  return e.has(t) ? e.get(t) : e.set(t, r(t)).get(t);
+}
+function Re(e) {
+  return typeof e != "object" || e == null || Object.isFrozen(e);
+}
+function xe(e, t, r) {
+  const n = re(e, t, r);
+  return { detectMutations() {
+    return ne(e, t, n, r);
+  } };
+}
+function re(e, t = [], r, n = "", o = /* @__PURE__ */ new Map()) {
+  const i = { value: r };
+  if (!e(r)) {
+    const s = o.get(r);
+    if (s) return s;
+    i.children = {}, o.set(r, i);
+    const c = t.length > 0;
+    for (const d in r) {
+      const u = n ? n + "." + d : d;
+      c && t.some((a) => a instanceof RegExp ? a.test(u) : u === a) || (i.children[d] = re(e, t, r[d], u, o));
+    }
+    o.delete(r);
+  }
+  return i;
+}
+function ne(e, t = [], r, n, o = !1, i = "", s = /* @__PURE__ */ new Map()) {
+  const c = r ? r.value : void 0, d = c === n;
+  if (o && !d && !Number.isNaN(n)) return {
+    wasMutated: !0,
+    path: i
+  };
+  if (e(c) || e(n)) return { wasMutated: !1 };
+  let u = s.get(r);
+  if (!u)
+    u = /* @__PURE__ */ new Set(), s.set(r, u);
+  else if (u.has(n)) return { wasMutated: !1 };
+  u.add(n);
+  const a = {};
+  for (let p in r.children) a[p] = !0;
+  for (let p in n) a[p] = !0;
+  const f = t.length > 0;
+  for (let p in a) {
+    const l = i ? i + "." + p : p;
+    if (f && t.some((w) => w instanceof RegExp ? w.test(l) : l === w))
+      continue;
+    const E = ne(e, t, r.children[p], n[p], d, l, s);
+    if (E.wasMutated) return E;
+  }
+  return { wasMutated: !1 };
+}
+function $e(e = {}) {
+  if (process.env.NODE_ENV === "production") return () => (t) => (r) => t(r);
+  {
+    let t = function(c, d, u, a) {
+      return JSON.stringify(c, r(d, a), u);
+    }, r = function(c, d) {
+      let u = [], a = [];
+      return d || (d = function(f, p) {
+        return u[0] === p ? "[Circular ~]" : "[Circular ~." + a.slice(0, u.indexOf(p)).join(".") + "]";
+      }), function(f, p) {
+        if (u.length > 0) {
+          var l = u.indexOf(this);
+          ~l ? (u.splice(l + 1), a.splice(l, 1 / 0, f)) : (u.push(this), a.push(f)), ~u.indexOf(p) && (p = d.call(this, f, p));
+        } else u.push(p);
+        return c == null ? p : c.call(this, f, p);
+      };
+    }, { isImmutable: n = Re, ignoredPaths: o, warnAfter: i = 32 } = e;
+    const s = xe.bind(null, n, o);
+    return ({ getState: c }) => {
+      let d = c(), u = s(d), a;
+      return (f) => (p) => {
+        const l = ee(i, "ImmutableStateInvariantMiddleware");
+        l.measureTime(() => {
+          if (d = c(), a = u.detectMutations(), u = s(d), a.wasMutated) throw new Error(process.env.NODE_ENV === "production" ? y(19) : `A state mutation was detected between dispatches, in the path '${a.path || ""}'.  This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);
+        });
+        const E = f(p);
+        return l.measureTime(() => {
+          if (d = c(), a = u.detectMutations(), u = s(d), a.wasMutated) throw new Error(process.env.NODE_ENV === "production" ? y(20) : `A state mutation was detected inside a dispatch, in the path: ${a.path || ""}. Take a look at the reducer(s) handling the action ${t(p)}. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);
+        }), l.warnIfExceeded(), E;
+      };
+    };
+  }
+}
+function oe(e) {
+  const t = typeof e;
+  return e == null || t === "string" || t === "boolean" || t === "number" || Array.isArray(e) || K(e);
+}
+function z(e, t = "", r = oe, n, o = [], i) {
+  let s;
+  if (!r(e)) return {
+    keyPath: t || "<root>",
+    value: e
+  };
+  if (typeof e != "object" || e === null || i != null && i.has(e)) return !1;
+  const c = n != null ? n(e) : Object.entries(e), d = o.length > 0;
+  for (const [u, a] of c) {
+    const f = t ? t + "." + u : u;
+    if (!(d && o.some((p) => p instanceof RegExp ? p.test(f) : f === p))) {
+      if (!r(a)) return {
+        keyPath: f,
+        value: a
+      };
+      if (typeof a == "object" && (s = z(a, f, r, n, o, i), s))
+        return s;
+    }
+  }
+  return i && ie(e) && i.add(e), !1;
+}
+function ie(e) {
+  if (!Object.isFrozen(e)) return !1;
+  for (const t of Object.values(e))
+    if (!(typeof t != "object" || t === null) && !ie(t))
+      return !1;
+  return !0;
+}
+function je(e = {}) {
+  if (process.env.NODE_ENV === "production") return () => (t) => (r) => t(r);
+  {
+    const { isSerializable: t = oe, getEntries: r, ignoredActions: n = [], ignoredActionPaths: o = ["meta.arg", "meta.baseQueryMeta"], ignoredPaths: i = [], warnAfter: s = 32, ignoreState: c = !1, ignoreActions: d = !1, disableCache: u = !1 } = e, a = !u && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0;
+    return (f) => (p) => (l) => {
+      if (!q(l)) return p(l);
+      const E = p(l), w = ee(s, "SerializableStateInvariantMiddleware");
+      return !d && !(n.length && n.indexOf(l.type) !== -1) && w.measureTime(() => {
+        const g = z(l, "", t, r, o, a);
+        if (g) {
+          const { keyPath: b, value: v } = g;
+          console.error(`A non-serializable value was detected in an action, in the path: \`${b}\`. Value:`, v, `
+Take a look at the logic that dispatched this action: `, l, `
+(See https://redux.js.org/faq/actions#why-should-type-be-a-string-why-should-my-action-types-be-constants)`, `
+(To allow non-serializable values see: https://redux-toolkit.js.org/usage/usage-guide#working-with-non-serializable-data)`);
+        }
+      }), c || (w.measureTime(() => {
+        const g = z(f.getState(), "", t, r, i, a);
+        if (g) {
+          const { keyPath: b, value: v } = g;
+          console.error(`A non-serializable value was detected in the state, in the path: \`${b}\`. Value:`, v, `
+Take a look at the reducer(s) handling this action type: ${l.type}.
+(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)`);
+        }
+      }), w.warnIfExceeded()), E;
+    };
+  }
+}
+function x(e) {
+  return typeof e == "boolean";
+}
+const Le = () => function(t) {
+  const { thunk: r = !0, immutableCheck: n = !0, serializableCheck: o = !0, actionCreatorCheck: i = !0 } = t ?? {};
+  let s = new te();
+  if (r && (x(r) ? s.push(_e) : s.push(Ce(r.extraArgument))), process.env.NODE_ENV !== "production") {
+    if (n) {
+      let c = {};
+      x(n) || (c = n), s.unshift($e(c));
+    }
+    if (o) {
+      let c = {};
+      x(o) || (c = o), s.push(je(c));
+    }
+    if (i) {
+      let c = {};
+      x(i) || (c = i), s.unshift(Ae(c));
+    }
+  }
+  return s;
+}, se = "RTK_autoBatch", ht = () => (e) => ({
+  payload: e,
+  meta: { [se]: !0 }
+}), X = (e) => (t) => {
+  setTimeout(t, e);
+}, Ie = (e, t) => (r) => {
+  let n = !1, o, i;
+  const s = () => {
+    n || (n = !0, cancelAnimationFrame(o), clearTimeout(i), r());
+  };
+  o = e(s), i = setTimeout(s, t);
+}, Pe = (e = { type: "raf" }) => (t) => (...r) => {
+  const n = t(...r);
+  let o = !0, i = !1, s = !1;
+  const c = /* @__PURE__ */ new Set(), d = e.type === "tick" ? queueMicrotask : e.type === "raf" ? typeof window < "u" && window.requestAnimationFrame ? Ie(window.requestAnimationFrame, 100) : X(10) : e.type === "callback" ? e.queueNotification : X(e.timeout), u = () => {
+    s = !1, i && (i = !1, c.forEach((a) => a()));
+  };
+  return Object.assign({}, n, {
+    subscribe(a) {
+      const f = () => o && a(), p = n.subscribe(f);
+      return c.add(a), () => {
+        p(), c.delete(a);
+      };
+    },
+    dispatch(a) {
+      var f;
+      try {
+        return o = !((f = a == null ? void 0 : a.meta) != null && f[se]), i = !o, i && (s || (s = !0, d(u))), n.dispatch(a);
+      } finally {
+        o = !0;
+      }
+    }
+  });
+}, ze = (e) => function(r) {
+  const { autoBatch: n = !0 } = r ?? {};
+  let o = new te(e);
+  return n && o.push(Pe(typeof n == "object" ? n : void 0)), o;
+};
+function wt(e) {
+  const t = Le(), { reducer: r = void 0, middleware: n, devTools: o = !0, duplicateMiddlewareCheck: i = !0, preloadedState: s = void 0, enhancers: c = void 0 } = e || {};
+  let d;
+  if (typeof r == "function") d = r;
+  else if (K(r)) d = De(r);
+  else throw new Error(process.env.NODE_ENV === "production" ? y(1) : "`reducer` is a required argument, and must be a function or an object of functions that can be passed to combineReducers");
+  if (process.env.NODE_ENV !== "production" && n && typeof n != "function") throw new Error(process.env.NODE_ENV === "production" ? y(2) : "`middleware` field must be a callback");
+  let u;
+  if (typeof n == "function") {
+    if (u = n(t), process.env.NODE_ENV !== "production" && !Array.isArray(u)) throw new Error(process.env.NODE_ENV === "production" ? y(3) : "when using a middleware builder function, an array of middleware must be returned");
+  } else u = t();
+  if (process.env.NODE_ENV !== "production" && u.some((w) => typeof w != "function")) throw new Error(process.env.NODE_ENV === "production" ? y(4) : "each middleware provided to configureStore must be a function");
+  if (process.env.NODE_ENV !== "production" && i) {
+    let w = /* @__PURE__ */ new Set();
+    u.forEach((g) => {
+      if (w.has(g)) throw new Error(process.env.NODE_ENV === "production" ? y(42) : "Duplicate middleware references found when creating the store. Ensure that each middleware is only included once.");
+      w.add(g);
+    });
+  }
+  let a = P;
+  o && (a = Te({
+    trace: process.env.NODE_ENV !== "production",
+    ...typeof o == "object" && o
+  }));
+  const f = ve(...u), p = ze(f);
+  if (process.env.NODE_ENV !== "production" && c && typeof c != "function") throw new Error(process.env.NODE_ENV === "production" ? y(5) : "`enhancers` field must be a callback");
+  let l = typeof c == "function" ? c(p) : p();
+  if (process.env.NODE_ENV !== "production" && !Array.isArray(l)) throw new Error(process.env.NODE_ENV === "production" ? y(6) : "`enhancers` callback must return an array");
+  if (process.env.NODE_ENV !== "production" && l.some((w) => typeof w != "function")) throw new Error(process.env.NODE_ENV === "production" ? y(7) : "each enhancer provided to configureStore must be a function");
+  process.env.NODE_ENV !== "production" && u.length && !l.includes(f) && console.error("middlewares were provided, but middleware enhancer was not included in final enhancers - make sure to call `getDefaultEnhancers`");
+  const E = a(...l);
+  return Oe(d, s, E);
+}
+function ae(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" ? y(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        if (n) throw new Error(process.env.NODE_ENV === "production" ? y(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" ? y(28) : "`builder.addCase` cannot be called with an empty action type");
+      if (c in t) throw new Error(process.env.NODE_ENV === "production" ? y(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" ? y(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" ? y(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" ? y(31) : "`builder.addDefaultCase` can only be called once");
+      return n = i, o;
+    }
+  };
+  return e(o), [
+    t,
+    r,
+    n
+  ];
+}
+function Be(e) {
+  return typeof e == "function";
+}
+function Fe(e, t) {
+  if (process.env.NODE_ENV !== "production" && typeof t == "object")
+    throw new Error(process.env.NODE_ENV === "production" ? y(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] = ae(t), i;
+  if (Be(e)) i = () => H(e());
+  else {
+    const c = H(e);
+    i = () => c;
+  }
+  function s(c = i(), d) {
+    let u = [r[d.type], ...n.filter(({ matcher: a }) => a(d)).map(({ reducer: a }) => a)];
+    return u.filter((a) => !!a).length === 0 && (u = [o]), u.reduce((a, f) => {
+      if (f)
+        if (ke(a)) {
+          const p = f(a, d);
+          return p === void 0 ? a : p;
+        } else {
+          if (Z(a))
+            return Y(a, (p) => f(p, d));
+          {
+            const p = f(a, d);
+            if (p === void 0) {
+              if (a === null) return a;
+              throw new Error(process.env.NODE_ENV === "production" ? y(9) : "A case reducer on a non-draftable value must not return undefined");
+            }
+            return p;
+          }
+        }
+      return a;
+    }, c);
+  }
+  return s.getInitialState = i, s;
+}
+let qe = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW", We = (e = 21) => {
+  let t = "", r = e;
+  for (; r--; ) t += qe[Math.random() * 64 | 0];
+  return t;
+};
+const Ue = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+function He(e, t) {
+  return `${e}/${t}`;
+}
+function Xe({ creators: e } = {}) {
+  var r;
+  const t = (r = e == null ? void 0 : e.asyncThunk) == null ? void 0 : r[Ue];
+  return function(o) {
+    const { name: i, reducerPath: s = i } = o;
+    if (!i) throw new Error(process.env.NODE_ENV === "production" ? y(11) : "`name` is a required option for createSlice");
+    typeof process < "u" && process.env.NODE_ENV === "development" && o.initialState === void 0 && console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+    const c = (typeof o.reducers == "function" ? o.reducers(Qe()) : o.reducers) || {}, d = Object.keys(c), u = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    }, a = {
+      addCase(h, m) {
+        const N = typeof h == "string" ? h : h.type;
+        if (!N) throw new Error(process.env.NODE_ENV === "production" ? y(12) : "`context.addCase` cannot be called with an empty action type");
+        if (N in u.sliceCaseReducersByType) throw new Error(process.env.NODE_ENV === "production" ? y(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + N);
+        return u.sliceCaseReducersByType[N] = m, a;
+      },
+      addMatcher(h, m) {
+        return u.sliceMatchers.push({
+          matcher: h,
+          reducer: m
+        }), a;
+      },
+      exposeAction(h, m) {
+        return u.actionCreators[h] = m, a;
+      },
+      exposeCaseReducer(h, m) {
+        return u.sliceCaseReducersByName[h] = m, a;
+      }
+    };
+    d.forEach((h) => {
+      const m = c[h], N = {
+        reducerName: h,
+        type: He(i, h),
+        createNotation: typeof o.reducers == "function"
+      };
+      Ke(m) ? Ze(N, m, a, t) : Ge(N, m, a);
+    });
+    function f() {
+      if (process.env.NODE_ENV !== "production" && typeof o.extraReducers == "object")
+        throw new Error(process.env.NODE_ENV === "production" ? y(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 [h = {}, m = [], N = void 0] = typeof o.extraReducers == "function" ? ae(o.extraReducers) : [o.extraReducers], O = {
+        ...h,
+        ...u.sliceCaseReducersByType
+      };
+      return Fe(o.initialState, (k) => {
+        for (let D in O) k.addCase(D, O[D]);
+        for (let D of u.sliceMatchers) k.addMatcher(D.matcher, D.reducer);
+        for (let D of m) k.addMatcher(D.matcher, D.reducer);
+        N && k.addDefaultCase(N);
+      });
+    }
+    const p = (h) => h, l = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new WeakMap();
+    let w;
+    function g(h, m) {
+      return w || (w = f()), w(h, m);
+    }
+    function b() {
+      return w || (w = f()), w.getInitialState();
+    }
+    function v(h, m = !1) {
+      function N(k) {
+        let D = k[h];
+        if (typeof D > "u") {
+          if (m) D = R(E, N, b);
+          else if (process.env.NODE_ENV !== "production") throw new Error(process.env.NODE_ENV === "production" ? y(15) : "selectSlice returned undefined for an uninjected slice reducer");
+        }
+        return D;
+      }
+      function O(k = p) {
+        return R(R(l, m, () => /* @__PURE__ */ new WeakMap()), k, () => {
+          const D = {};
+          for (const [me, be] of Object.entries(o.selectors ?? {})) D[me] = Je(be, k, () => R(E, k, b), m);
+          return D;
+        });
+      }
+      return {
+        reducerPath: h,
+        getSelectors: O,
+        get selectors() {
+          return O(N);
+        },
+        selectSlice: N
+      };
+    }
+    const _ = {
+      name: i,
+      reducer: g,
+      actions: u.actionCreators,
+      caseReducers: u.sliceCaseReducersByName,
+      getInitialState: b,
+      ...v(s),
+      injectInto(h, { reducerPath: m, ...N } = {}) {
+        const O = m ?? s;
+        return h.inject({
+          reducerPath: O,
+          reducer: g
+        }, N), {
+          ..._,
+          ...v(O, !0)
+        };
+      }
+    };
+    return _;
+  };
+}
+function Je(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" ? y(16) : "selectState returned undefined for an uninjected slice reducer");
+    }
+    return e(c, ...s);
+  }
+  return o.unwrapped = e, o;
+}
+const Et = /* @__PURE__ */ Xe();
+function Qe() {
+  function e(t, r) {
+    return {
+      _reducerDefinitionType: "asyncThunk",
+      payloadCreator: t,
+      ...r
+    };
+  }
+  return e.withTypes = () => e, {
+    reducer(t) {
+      return Object.assign({ [t.name](...r) {
+        return t(...r);
+      } }[t.name], { _reducerDefinitionType: "reducer" });
+    },
+    preparedReducer(t, r) {
+      return {
+        _reducerDefinitionType: "reducerWithPrepare",
+        prepare: t,
+        reducer: r
+      };
+    },
+    asyncThunk: e
+  };
+}
+function Ge({ type: e, reducerName: t, createNotation: r }, n, o) {
+  let i, s;
+  if ("reducer" in n) {
+    if (r && !Ye(n)) throw new Error(process.env.NODE_ENV === "production" ? y(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 ? M(e, s) : M(e));
+}
+function Ke(e) {
+  return e._reducerDefinitionType === "asyncThunk";
+}
+function Ye(e) {
+  return e._reducerDefinitionType === "reducerWithPrepare";
+}
+function Ze({ type: e, reducerName: t }, r, n, o) {
+  if (!o) throw new Error(process.env.NODE_ENV === "production" ? y(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: d, settled: u, options: a } = r, f = o(e, i, a);
+  n.exposeAction(t, f), s && n.addCase(f.fulfilled, s), c && n.addCase(f.pending, c), d && n.addCase(f.rejected, d), u && n.addMatcher(f.settled, u), n.exposeCaseReducer(t, {
+    fulfilled: s || $,
+    pending: c || $,
+    rejected: d || $,
+    settled: u || $
+  });
+}
+function $() {
+}
+const et = "task", ce = "listener", ue = "completed", W = "cancelled", tt = `task-${W}`, rt = `task-${ue}`, B = `${ce}-${W}`, nt = `${ce}-${ue}`;
+var I = class {
+  constructor(e) {
+    A(this, "code");
+    A(this, "name", "TaskAbortError");
+    A(this, "message");
+    this.code = e, this.message = `${et} ${W} (reason: ${e})`;
+  }
+};
+const U = (e, t) => {
+  if (typeof e != "function") throw new TypeError(process.env.NODE_ENV === "production" ? y(32) : `${t} is not a function`);
+}, j = () => {
+}, le = (e, t = j) => (e.catch(t), e), de = (e, t) => (e.addEventListener("abort", t, { once: !0 }), () => e.removeEventListener("abort", t)), C = (e) => {
+  if (e.aborted) throw new I(e.reason);
+};
+function fe(e, t) {
+  let r = j;
+  return new Promise((n, o) => {
+    const i = () => o(new I(e.reason));
+    if (e.aborted) {
+      i();
+      return;
+    }
+    r = de(e, i), t.finally(() => r()).then(n, o);
+  }).finally(() => {
+    r = j;
+  });
+}
+const ot = async (e, t) => {
+  try {
+    return await Promise.resolve(), {
+      status: "ok",
+      value: await e()
+    };
+  } catch (r) {
+    return {
+      status: r instanceof I ? "cancelled" : "rejected",
+      error: r
+    };
+  } finally {
+    t == null || t();
+  }
+}, L = (e) => (t) => le(fe(e, t).then((r) => (C(e), r))), pe = (e) => {
+  const t = L(e);
+  return (r) => t(new Promise((n) => setTimeout(n, r)));
+}, { assign: T } = Object, J = {}, V = "listenerMiddleware", it = (e, t) => {
+  const r = (n) => de(e, () => n.abort(e.reason));
+  return (n, o) => {
+    U(n, "taskExecutor");
+    const i = new AbortController();
+    r(i);
+    const s = ot(async () => {
+      C(e), C(i.signal);
+      const c = await n({
+        pause: L(i.signal),
+        delay: pe(i.signal),
+        signal: i.signal
+      });
+      return C(i.signal), c;
+    }, () => i.abort(rt));
+    return o != null && o.autoJoin && t.push(s.catch(j)), {
+      result: L(e)(s),
+      cancel() {
+        i.abort(tt);
+      }
+    };
+  };
+}, st = (e, t) => {
+  const r = async (n, o) => {
+    C(t);
+    let i = () => {
+    };
+    const s = [new Promise((c, d) => {
+      let u = e({
+        predicate: n,
+        effect: (a, f) => {
+          f.unsubscribe(), c([
+            a,
+            f.getState(),
+            f.getOriginalState()
+          ]);
+        }
+      });
+      i = () => {
+        u(), d();
+      };
+    })];
+    o != null && s.push(new Promise((c) => setTimeout(c, o, null)));
+    try {
+      const c = await fe(t, Promise.race(s));
+      return C(t), c;
+    } finally {
+      i();
+    }
+  };
+  return ((n, o) => le(r(n, o)));
+}, he = (e) => {
+  let { type: t, actionCreator: r, matcher: n, predicate: o, effect: i } = e;
+  if (t) o = M(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" ? y(21) : "Creating or removing a listener requires one of the known fields for matching an action");
+  return U(i, "options.listener"), {
+    predicate: o,
+    type: t,
+    effect: i
+  };
+}, we = /* @__PURE__ */ T((e) => {
+  const { type: t, predicate: r, effect: n } = he(e);
+  return {
+    id: We(),
+    effect: n,
+    type: t,
+    predicate: r,
+    pending: /* @__PURE__ */ new Set(),
+    unsubscribe: () => {
+      throw new Error(process.env.NODE_ENV === "production" ? y(22) : "Unsubscribe not initialized");
+    }
+  };
+}, { withTypes: () => we }), Q = (e, t) => {
+  const { type: r, effect: n, predicate: o } = he(t);
+  return Array.from(e.values()).find((i) => (typeof r == "string" ? i.type === r : i.predicate === o) && i.effect === n);
+}, F = (e) => {
+  e.pending.forEach((t) => {
+    t.abort(B);
+  });
+}, at = (e, t) => () => {
+  for (const r of t.keys()) F(r);
+  e.clear();
+}, G = (e, t, r) => {
+  try {
+    e(t, r);
+  } catch (n) {
+    setTimeout(() => {
+      throw n;
+    }, 0);
+  }
+}, Ee = /* @__PURE__ */ T(/* @__PURE__ */ M(`${V}/add`), { withTypes: () => Ee }), ct = /* @__PURE__ */ M(`${V}/removeAll`), ye = /* @__PURE__ */ T(/* @__PURE__ */ M(`${V}/remove`), { withTypes: () => ye }), ut = (...e) => {
+  console.error(`${V}/error`, ...e);
+}, yt = (e = {}) => {
+  const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), n = (l) => {
+    const E = r.get(l) ?? 0;
+    r.set(l, E + 1);
+  }, o = (l) => {
+    const E = r.get(l) ?? 1;
+    E === 1 ? r.delete(l) : r.set(l, E - 1);
+  }, { extra: i, onError: s = ut } = e;
+  U(s, "onError");
+  const c = (l) => (l.unsubscribe = () => t.delete(l.id), t.set(l.id, l), (E) => {
+    l.unsubscribe(), E != null && E.cancelActive && F(l);
+  }), d = ((l) => {
+    const E = Q(t, l) ?? we(l);
+    return c(E);
+  });
+  T(d, { withTypes: () => d });
+  const u = (l) => {
+    const E = Q(t, l);
+    return E && (E.unsubscribe(), l.cancelActive && F(E)), !!E;
+  };
+  T(u, { withTypes: () => u });
+  const a = async (l, E, w, g) => {
+    const b = new AbortController(), v = st(d, b.signal), _ = [];
+    try {
+      l.pending.add(b), n(l), await Promise.resolve(l.effect(E, T({}, w, {
+        getOriginalState: g,
+        condition: (h, m) => v(h, m).then(Boolean),
+        take: v,
+        delay: pe(b.signal),
+        pause: L(b.signal),
+        extra: i,
+        signal: b.signal,
+        fork: it(b.signal, _),
+        unsubscribe: l.unsubscribe,
+        subscribe: () => {
+          t.set(l.id, l);
+        },
+        cancelActiveListeners: () => {
+          l.pending.forEach((h, m, N) => {
+            h !== b && (h.abort(B), N.delete(h));
+          });
+        },
+        cancel: () => {
+          b.abort(B), l.pending.delete(b);
+        },
+        throwIfCancelled: () => {
+          C(b.signal);
+        }
+      })));
+    } catch (h) {
+      h instanceof I || G(s, h, { raisedBy: "effect" });
+    } finally {
+      await Promise.all(_), b.abort(nt), o(l), l.pending.delete(b);
+    }
+  }, f = at(t, r);
+  return {
+    middleware: (l) => (E) => (w) => {
+      if (!q(w)) return E(w);
+      if (Ee.match(w)) return d(w.payload);
+      if (ct.match(w)) {
+        f();
+        return;
+      }
+      if (ye.match(w)) return u(w.payload);
+      let g = l.getState();
+      const b = () => {
+        if (g === J) throw new Error(process.env.NODE_ENV === "production" ? y(23) : `${V}: getOriginalState can only be called synchronously`);
+        return g;
+      };
+      let v;
+      try {
+        if (v = E(w), t.size > 0) {
+          const _ = l.getState(), h = Array.from(t.values());
+          for (const m of h) {
+            let N = !1;
+            try {
+              N = m.predicate(w, _, g);
+            } catch (O) {
+              N = !1, G(s, O, { raisedBy: "predicate" });
+            }
+            N && a(m, w, l, b);
+          }
+        }
+      } finally {
+        g = J;
+      }
+      return v;
+    },
+    startListening: d,
+    stopListening: u,
+    clearListeners: f
+  };
+};
+function y(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. `;
+}
+export {
+  se as SHOULD_AUTOBATCH,
+  I as TaskAbortError,
+  te as Tuple,
+  Nt as __DO_NOT_USE__ActionTypes,
+  Ee as addListener,
+  ve as applyMiddleware,
+  Pe as autoBatchEnhancer,
+  Xe as buildCreateSlice,
+  ct as clearAllListeners,
+  De as combineReducers,
+  P as compose,
+  wt as configureStore,
+  M as createAction,
+  Ae as createActionCreatorInvariantMiddleware,
+  $e as createImmutableStateInvariantMiddleware,
+  yt as createListenerMiddleware,
+  Y as createNextState,
+  Fe as createReducer,
+  je as createSerializableStateInvariantMiddleware,
+  Et as createSlice,
+  Oe as createStore,
+  Dt as current,
+  z as findNonSerializableValue,
+  y as formatProdErrorMessage,
+  vt as freeze,
+  q as isAction,
+  Se as isActionCreator,
+  ke as isDraft,
+  Re as isImmutableDefault,
+  oe as isPlain,
+  K as isPlainObject,
+  We as nanoid,
+  ht as prepareAutoBatched,
+  ye as removeListener
+};