hasting-swatchcart-module 0.0.2 → 0.0.3

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

@@ -0,0 +1,877 @@
+import { isAction as P, isPlainObject as q, combineReducers as Z, applyMiddleware as ee, compose as A, createStore as te } from "../../../redux/dist/redux.js";
+import { __DO_NOT_USE__ActionTypes as Ue } from "../../../redux/dist/redux.js";
+import { produce as B, isDraftable as W, isDraft as re } from "../../../immer/dist/immer.js";
+import { current as Ge, freeze as Xe } from "../../../immer/dist/immer.js";
+import { thunk as ne, withExtraArgument as oe } from "../../../redux-thunk/dist/redux-thunk.js";
+var ie = typeof window < "u" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
+  if (arguments.length !== 0)
+    return typeof arguments[0] == "object" ? A : A.apply(null, arguments);
+}, F = (e) => e && typeof e.match == "function";
+function k(e, t) {
+  function n(...r) {
+    if (t) {
+      let s = t(...r);
+      if (!s)
+        throw new Error(process.env.NODE_ENV === "production" ? w(0) : "prepareAction did not return an object");
+      return {
+        type: e,
+        payload: s.payload,
+        ..."meta" in s && {
+          meta: s.meta
+        },
+        ..."error" in s && {
+          error: s.error
+        }
+      };
+    }
+    return {
+      type: e,
+      payload: r[0]
+    };
+  }
+  return n.toString = () => `${e}`, n.type = e, n.match = (r) => P(r) && r.type === e, n;
+}
+function ae(e) {
+  return typeof e == "function" && "type" in e && // hasMatchFunction only wants Matchers but I don't see the point in rewriting it
+  F(e);
+}
+function se(e) {
+  const t = e ? `${e}`.split("/") : [], n = 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(${n}())\` instead of \`dispatch(${n})\`. This is necessary even if the action has no payload.`;
+}
+function ce(e = {}) {
+  if (process.env.NODE_ENV === "production")
+    return () => (n) => (r) => n(r);
+  const {
+    isActionCreator: t = ae
+  } = e;
+  return () => (n) => (r) => (t(r) && console.warn(se(r.type)), n(r));
+}
+function U(e, t) {
+  let n = 0;
+  return {
+    measureTime(r) {
+      const s = Date.now();
+      try {
+        return r();
+      } finally {
+        const c = Date.now();
+        n += c - s;
+      }
+    },
+    warnIfExceeded() {
+      n > e && console.warn(`${t} took ${n}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 L = class C extends Array {
+  constructor(...t) {
+    super(...t), Object.setPrototypeOf(this, C.prototype);
+  }
+  static get [Symbol.species]() {
+    return C;
+  }
+  concat(...t) {
+    return super.concat.apply(this, t);
+  }
+  prepend(...t) {
+    return t.length === 1 && Array.isArray(t[0]) ? new C(...t[0].concat(this)) : new C(...t.concat(this));
+  }
+};
+function x(e) {
+  return W(e) ? B(e, () => {
+  }) : e;
+}
+function V(e, t, n) {
+  return e.has(t) ? e.get(t) : e.set(t, n(t)).get(t);
+}
+function ue(e) {
+  return typeof e != "object" || e == null || Object.isFrozen(e);
+}
+function de(e, t, n) {
+  const r = G(e, t, n);
+  return {
+    detectMutations() {
+      return X(e, t, r, n);
+    }
+  };
+}
+function G(e, t = [], n, r = "", s = /* @__PURE__ */ new Set()) {
+  const c = {
+    value: n
+  };
+  if (!e(n) && !s.has(n)) {
+    s.add(n), c.children = {};
+    for (const i in n) {
+      const u = r ? r + "." + i : i;
+      t.length && t.indexOf(u) !== -1 || (c.children[i] = G(e, t, n[i], u));
+    }
+  }
+  return c;
+}
+function X(e, t = [], n, r, s = !1, c = "") {
+  const i = n ? n.value : void 0, u = i === r;
+  if (s && !u && !Number.isNaN(r))
+    return {
+      wasMutated: !0,
+      path: c
+    };
+  if (e(i) || e(r))
+    return {
+      wasMutated: !1
+    };
+  const a = {};
+  for (let o in n.children)
+    a[o] = !0;
+  for (let o in r)
+    a[o] = !0;
+  const d = t.length > 0;
+  for (let o in a) {
+    const l = c ? c + "." + o : o;
+    if (d && t.some((m) => m instanceof RegExp ? m.test(l) : l === m))
+      continue;
+    const p = X(e, t, n.children[o], r[o], u, l);
+    if (p.wasMutated)
+      return p;
+  }
+  return {
+    wasMutated: !1
+  };
+}
+function le(e = {}) {
+  if (process.env.NODE_ENV === "production")
+    return () => (t) => (n) => t(n);
+  {
+    let t = function(u, a, d, o) {
+      return JSON.stringify(u, n(a, o), d);
+    }, n = function(u, a) {
+      let d = [], o = [];
+      return a || (a = function(l, p) {
+        return d[0] === p ? "[Circular ~]" : "[Circular ~." + o.slice(0, d.indexOf(p)).join(".") + "]";
+      }), function(l, p) {
+        if (d.length > 0) {
+          var f = d.indexOf(this);
+          ~f ? d.splice(f + 1) : d.push(this), ~f ? o.splice(f, 1 / 0, l) : o.push(l), ~d.indexOf(p) && (p = a.call(this, l, p));
+        } else d.push(p);
+        return u == null ? p : u.call(this, l, p);
+      };
+    }, {
+      isImmutable: r = ue,
+      ignoredPaths: s,
+      warnAfter: c = 32
+    } = e;
+    const i = de.bind(null, r, s);
+    return ({
+      getState: u
+    }) => {
+      let a = u(), d = i(a), o;
+      return (l) => (p) => {
+        const f = U(c, "ImmutableStateInvariantMiddleware");
+        f.measureTime(() => {
+          if (a = u(), o = d.detectMutations(), d = i(a), o.wasMutated)
+            throw new Error(process.env.NODE_ENV === "production" ? w(19) : `A state mutation was detected between dispatches, in the path '${o.path || ""}'.  This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);
+        });
+        const m = l(p);
+        return f.measureTime(() => {
+          if (a = u(), o = d.detectMutations(), d = i(a), o.wasMutated)
+            throw new Error(process.env.NODE_ENV === "production" ? w(20) : `A state mutation was detected inside a dispatch, in the path: ${o.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)`);
+        }), f.warnIfExceeded(), m;
+      };
+    };
+  }
+}
+function H(e) {
+  const t = typeof e;
+  return e == null || t === "string" || t === "boolean" || t === "number" || Array.isArray(e) || q(e);
+}
+function j(e, t = "", n = H, r, s = [], c) {
+  let i;
+  if (!n(e))
+    return {
+      keyPath: t || "<root>",
+      value: e
+    };
+  if (typeof e != "object" || e === null || c?.has(e)) return !1;
+  const u = r != null ? r(e) : Object.entries(e), a = s.length > 0;
+  for (const [d, o] of u) {
+    const l = t ? t + "." + d : d;
+    if (!(a && s.some((f) => f instanceof RegExp ? f.test(l) : l === f))) {
+      if (!n(o))
+        return {
+          keyPath: l,
+          value: o
+        };
+      if (typeof o == "object" && (i = j(o, l, n, r, s, c), i))
+        return i;
+    }
+  }
+  return c && Q(e) && c.add(e), !1;
+}
+function Q(e) {
+  if (!Object.isFrozen(e)) return !1;
+  for (const t of Object.values(e))
+    if (!(typeof t != "object" || t === null) && !Q(t))
+      return !1;
+  return !0;
+}
+function fe(e = {}) {
+  if (process.env.NODE_ENV === "production")
+    return () => (t) => (n) => t(n);
+  {
+    const {
+      isSerializable: t = H,
+      getEntries: n,
+      ignoredActions: r = [],
+      ignoredActionPaths: s = ["meta.arg", "meta.baseQueryMeta"],
+      ignoredPaths: c = [],
+      warnAfter: i = 32,
+      ignoreState: u = !1,
+      ignoreActions: a = !1,
+      disableCache: d = !1
+    } = e, o = !d && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0;
+    return (l) => (p) => (f) => {
+      if (!P(f))
+        return p(f);
+      const m = p(f), g = U(i, "SerializableStateInvariantMiddleware");
+      return !a && !(r.length && r.indexOf(f.type) !== -1) && g.measureTime(() => {
+        const D = j(f, "", t, n, s, o);
+        if (D) {
+          const {
+            keyPath: v,
+            value: _
+          } = D;
+          console.error(`A non-serializable value was detected in an action, in the path: \`${v}\`. Value:`, _, `
+Take a look at the logic that dispatched this action: `, f, `
+(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-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)`);
+        }
+      }), u || (g.measureTime(() => {
+        const D = l.getState(), v = j(D, "", t, n, c, o);
+        if (v) {
+          const {
+            keyPath: _,
+            value: h
+          } = v;
+          console.error(`A non-serializable value was detected in the state, in the path: \`${_}\`. Value:`, h, `
+Take a look at the reducer(s) handling this action type: ${f.type}.
+(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)`);
+        }
+      }), g.warnIfExceeded()), m;
+    };
+  }
+}
+function M(e) {
+  return typeof e == "boolean";
+}
+var pe = () => function(t) {
+  const {
+    thunk: n = !0,
+    immutableCheck: r = !0,
+    serializableCheck: s = !0,
+    actionCreatorCheck: c = !0
+  } = t ?? {};
+  let i = new L();
+  if (n && (M(n) ? i.push(ne) : i.push(oe(n.extraArgument))), process.env.NODE_ENV !== "production") {
+    if (r) {
+      let u = {};
+      M(r) || (u = r), i.unshift(le(u));
+    }
+    if (s) {
+      let u = {};
+      M(s) || (u = s), i.push(fe(u));
+    }
+    if (c) {
+      let u = {};
+      M(c) || (u = c), i.unshift(ce(u));
+    }
+  }
+  return i;
+}, he = "RTK_autoBatch", I = (e) => (t) => {
+  setTimeout(t, e);
+}, we = (e = {
+  type: "raf"
+}) => (t) => (...n) => {
+  const r = t(...n);
+  let s = !0, c = !1, i = !1;
+  const u = /* @__PURE__ */ new Set(), a = e.type === "tick" ? queueMicrotask : e.type === "raf" ? (
+    // requestAnimationFrame won't exist in SSR environments. Fall back to a vague approximation just to keep from erroring.
+    typeof window < "u" && window.requestAnimationFrame ? window.requestAnimationFrame : I(10)
+  ) : e.type === "callback" ? e.queueNotification : I(e.timeout), d = () => {
+    i = !1, c && (c = !1, u.forEach((o) => o()));
+  };
+  return Object.assign({}, r, {
+    // Override the base `store.subscribe` method to keep original listeners
+    // from running if we're delaying notifications
+    subscribe(o) {
+      const l = () => s && o(), p = r.subscribe(l);
+      return u.add(o), () => {
+        p(), u.delete(o);
+      };
+    },
+    // Override the base `store.dispatch` method so that we can check actions
+    // for the `shouldAutoBatch` flag and determine if batching is active
+    dispatch(o) {
+      try {
+        return s = !o?.meta?.[he], c = !s, c && (i || (i = !0, a(d))), r.dispatch(o);
+      } finally {
+        s = !0;
+      }
+    }
+  });
+}, Ee = (e) => function(n) {
+  const {
+    autoBatch: r = !0
+  } = n ?? {};
+  let s = new L(e);
+  return r && s.push(we(typeof r == "object" ? r : void 0)), s;
+};
+function Pe(e) {
+  const t = pe(), {
+    reducer: n = void 0,
+    middleware: r,
+    devTools: s = !0,
+    duplicateMiddlewareCheck: c = !0,
+    preloadedState: i = void 0,
+    enhancers: u = void 0
+  } = e || {};
+  let a;
+  if (typeof n == "function")
+    a = n;
+  else if (q(n))
+    a = Z(n);
+  else
+    throw new Error(process.env.NODE_ENV === "production" ? w(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" && r && typeof r != "function")
+    throw new Error(process.env.NODE_ENV === "production" ? w(2) : "`middleware` field must be a callback");
+  let d;
+  if (typeof r == "function") {
+    if (d = r(t), process.env.NODE_ENV !== "production" && !Array.isArray(d))
+      throw new Error(process.env.NODE_ENV === "production" ? w(3) : "when using a middleware builder function, an array of middleware must be returned");
+  } else
+    d = t();
+  if (process.env.NODE_ENV !== "production" && d.some((g) => typeof g != "function"))
+    throw new Error(process.env.NODE_ENV === "production" ? w(4) : "each middleware provided to configureStore must be a function");
+  if (process.env.NODE_ENV !== "production" && c) {
+    let g = /* @__PURE__ */ new Set();
+    d.forEach((D) => {
+      if (g.has(D))
+        throw new Error(process.env.NODE_ENV === "production" ? w(42) : "Duplicate middleware references found when creating the store. Ensure that each middleware is only included once.");
+      g.add(D);
+    });
+  }
+  let o = A;
+  s && (o = ie({
+    // Enable capture of stack traces for dispatched Redux actions
+    trace: process.env.NODE_ENV !== "production",
+    ...typeof s == "object" && s
+  }));
+  const l = ee(...d), p = Ee(l);
+  if (process.env.NODE_ENV !== "production" && u && typeof u != "function")
+    throw new Error(process.env.NODE_ENV === "production" ? w(5) : "`enhancers` field must be a callback");
+  let f = typeof u == "function" ? u(p) : p();
+  if (process.env.NODE_ENV !== "production" && !Array.isArray(f))
+    throw new Error(process.env.NODE_ENV === "production" ? w(6) : "`enhancers` callback must return an array");
+  if (process.env.NODE_ENV !== "production" && f.some((g) => typeof g != "function"))
+    throw new Error(process.env.NODE_ENV === "production" ? w(7) : "each enhancer provided to configureStore must be a function");
+  process.env.NODE_ENV !== "production" && d.length && !f.includes(l) && console.error("middlewares were provided, but middleware enhancer was not included in final enhancers - make sure to call `getDefaultEnhancers`");
+  const m = o(...f);
+  return te(a, i, m);
+}
+function Y(e) {
+  const t = {}, n = [];
+  let r;
+  const s = {
+    addCase(c, i) {
+      if (process.env.NODE_ENV !== "production") {
+        if (n.length > 0)
+          throw new Error(process.env.NODE_ENV === "production" ? w(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        if (r)
+          throw new Error(process.env.NODE_ENV === "production" ? w(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
+      }
+      const u = typeof c == "string" ? c : c.type;
+      if (!u)
+        throw new Error(process.env.NODE_ENV === "production" ? w(28) : "`builder.addCase` cannot be called with an empty action type");
+      if (u in t)
+        throw new Error(process.env.NODE_ENV === "production" ? w(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${u}'`);
+      return t[u] = i, s;
+    },
+    addAsyncThunk(c, i) {
+      if (process.env.NODE_ENV !== "production" && r)
+        throw new Error(process.env.NODE_ENV === "production" ? w(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
+      return i.pending && (t[c.pending.type] = i.pending), i.rejected && (t[c.rejected.type] = i.rejected), i.fulfilled && (t[c.fulfilled.type] = i.fulfilled), i.settled && n.push({
+        matcher: c.settled,
+        reducer: i.settled
+      }), s;
+    },
+    addMatcher(c, i) {
+      if (process.env.NODE_ENV !== "production" && r)
+        throw new Error(process.env.NODE_ENV === "production" ? w(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+      return n.push({
+        matcher: c,
+        reducer: i
+      }), s;
+    },
+    addDefaultCase(c) {
+      if (process.env.NODE_ENV !== "production" && r)
+        throw new Error(process.env.NODE_ENV === "production" ? w(31) : "`builder.addDefaultCase` can only be called once");
+      return r = c, s;
+    }
+  };
+  return e(s), [t, n, r];
+}
+function me(e) {
+  return typeof e == "function";
+}
+function ye(e, t) {
+  if (process.env.NODE_ENV !== "production" && typeof t == "object")
+    throw new Error(process.env.NODE_ENV === "production" ? w(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, s] = Y(t), c;
+  if (me(e))
+    c = () => x(e());
+  else {
+    const u = x(e);
+    c = () => u;
+  }
+  function i(u = c(), a) {
+    let d = [n[a.type], ...r.filter(({
+      matcher: o
+    }) => o(a)).map(({
+      reducer: o
+    }) => o)];
+    return d.filter((o) => !!o).length === 0 && (d = [s]), d.reduce((o, l) => {
+      if (l)
+        if (re(o)) {
+          const f = l(o, a);
+          return f === void 0 ? o : f;
+        } else {
+          if (W(o))
+            return B(o, (p) => l(p, a));
+          {
+            const p = l(o, a);
+            if (p === void 0) {
+              if (o === null)
+                return o;
+              throw Error("A case reducer on a non-draftable value must not return undefined");
+            }
+            return p;
+          }
+        }
+      return o;
+    }, u);
+  }
+  return i.getInitialState = c, i;
+}
+var be = (e, t) => F(e) ? e.match(t) : e(t);
+function Ne(...e) {
+  return (t) => e.some((n) => be(n, t));
+}
+var ge = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW", De = (e = 21) => {
+  let t = "", n = e;
+  for (; n--; )
+    t += ge[Math.random() * 64 | 0];
+  return t;
+}, ve = ["name", "message", "stack", "code"], T = class {
+  constructor(e, t) {
+    this.payload = e, this.meta = t;
+  }
+  /*
+  type-only property to distinguish between RejectWithValue and FulfillWithMeta
+  does not exist at runtime
+  */
+  _type;
+}, z = class {
+  constructor(e, t) {
+    this.payload = e, this.meta = t;
+  }
+  /*
+  type-only property to distinguish between RejectWithValue and FulfillWithMeta
+  does not exist at runtime
+  */
+  _type;
+}, Oe = (e) => {
+  if (typeof e == "object" && e !== null) {
+    const t = {};
+    for (const n of ve)
+      typeof e[n] == "string" && (t[n] = e[n]);
+    return t;
+  }
+  return {
+    message: String(e)
+  };
+}, $ = "External signal was aborted", qe = /* @__PURE__ */ (() => {
+  function e(t, n, r) {
+    const s = k(t + "/fulfilled", (a, d, o, l) => ({
+      payload: a,
+      meta: {
+        ...l || {},
+        arg: o,
+        requestId: d,
+        requestStatus: "fulfilled"
+      }
+    })), c = k(t + "/pending", (a, d, o) => ({
+      payload: void 0,
+      meta: {
+        ...o || {},
+        arg: d,
+        requestId: a,
+        requestStatus: "pending"
+      }
+    })), i = k(t + "/rejected", (a, d, o, l, p) => ({
+      payload: l,
+      error: (r && r.serializeError || Oe)(a || "Rejected"),
+      meta: {
+        ...p || {},
+        arg: o,
+        requestId: d,
+        rejectedWithValue: !!l,
+        requestStatus: "rejected",
+        aborted: a?.name === "AbortError",
+        condition: a?.name === "ConditionError"
+      }
+    }));
+    function u(a, {
+      signal: d
+    } = {}) {
+      return (o, l, p) => {
+        const f = r?.idGenerator ? r.idGenerator(a) : De(), m = new AbortController();
+        let g, D;
+        function v(h) {
+          D = h, m.abort();
+        }
+        d && (d.aborted ? v($) : d.addEventListener("abort", () => v($), {
+          once: !0
+        }));
+        const _ = (async function() {
+          let h;
+          try {
+            let E = r?.condition?.(a, {
+              getState: l,
+              extra: p
+            });
+            if (Ce(E) && (E = await E), E === !1 || m.signal.aborted)
+              throw {
+                name: "ConditionError",
+                message: "Aborted due to condition callback returning false."
+              };
+            const O = new Promise((b, N) => {
+              g = () => {
+                N({
+                  name: "AbortError",
+                  message: D || "Aborted"
+                });
+              }, m.signal.addEventListener("abort", g);
+            });
+            o(c(f, a, r?.getPendingMeta?.({
+              requestId: f,
+              arg: a
+            }, {
+              getState: l,
+              extra: p
+            }))), h = await Promise.race([O, Promise.resolve(n(a, {
+              dispatch: o,
+              getState: l,
+              extra: p,
+              requestId: f,
+              signal: m.signal,
+              abort: v,
+              rejectWithValue: (b, N) => new T(b, N),
+              fulfillWithValue: (b, N) => new z(b, N)
+            })).then((b) => {
+              if (b instanceof T)
+                throw b;
+              return b instanceof z ? s(b.payload, f, a, b.meta) : s(b, f, a);
+            })]);
+          } catch (E) {
+            h = E instanceof T ? i(null, f, a, E.payload, E.meta) : i(E, f, a);
+          } finally {
+            g && m.signal.removeEventListener("abort", g);
+          }
+          return r && !r.dispatchConditionRejection && i.match(h) && h.meta.condition || o(h), h;
+        })();
+        return Object.assign(_, {
+          abort: v,
+          requestId: f,
+          arg: a,
+          unwrap() {
+            return _.then(_e);
+          }
+        });
+      };
+    }
+    return Object.assign(u, {
+      pending: c,
+      rejected: i,
+      fulfilled: s,
+      settled: Ne(i, s),
+      typePrefix: t
+    });
+  }
+  return e.withTypes = () => e, e;
+})();
+function _e(e) {
+  if (e.meta && e.meta.rejectedWithValue)
+    throw e.payload;
+  if (e.error)
+    throw e.error;
+  return e.payload;
+}
+function Ce(e) {
+  return e !== null && typeof e == "object" && typeof e.then == "function";
+}
+var ke = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+function Ve(e, t) {
+  return `${e}/${t}`;
+}
+function Me({
+  creators: e
+} = {}) {
+  const t = e?.asyncThunk?.[ke];
+  return function(r) {
+    const {
+      name: s,
+      reducerPath: c = s
+    } = r;
+    if (!s)
+      throw new Error(process.env.NODE_ENV === "production" ? w(11) : "`name` is a required option for createSlice");
+    typeof process < "u" && process.env.NODE_ENV === "development" && r.initialState === void 0 && console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+    const i = (typeof r.reducers == "function" ? r.reducers(Te()) : r.reducers) || {}, u = Object.keys(i), a = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    }, d = {
+      addCase(h, y) {
+        const E = typeof h == "string" ? h : h.type;
+        if (!E)
+          throw new Error(process.env.NODE_ENV === "production" ? w(12) : "`context.addCase` cannot be called with an empty action type");
+        if (E in a.sliceCaseReducersByType)
+          throw new Error(process.env.NODE_ENV === "production" ? w(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + E);
+        return a.sliceCaseReducersByType[E] = y, d;
+      },
+      addMatcher(h, y) {
+        return a.sliceMatchers.push({
+          matcher: h,
+          reducer: y
+        }), d;
+      },
+      exposeAction(h, y) {
+        return a.actionCreators[h] = y, d;
+      },
+      exposeCaseReducer(h, y) {
+        return a.sliceCaseReducersByName[h] = y, d;
+      }
+    };
+    u.forEach((h) => {
+      const y = i[h], E = {
+        reducerName: h,
+        type: Ve(s, h),
+        createNotation: typeof r.reducers == "function"
+      };
+      je(y) ? xe(E, y, d, t) : Ae(E, y, d);
+    });
+    function o() {
+      if (process.env.NODE_ENV !== "production" && typeof r.extraReducers == "object")
+        throw new Error(process.env.NODE_ENV === "production" ? w(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 = {}, y = [], E = void 0] = typeof r.extraReducers == "function" ? Y(r.extraReducers) : [r.extraReducers], O = {
+        ...h,
+        ...a.sliceCaseReducersByType
+      };
+      return ye(r.initialState, (b) => {
+        for (let N in O)
+          b.addCase(N, O[N]);
+        for (let N of a.sliceMatchers)
+          b.addMatcher(N.matcher, N.reducer);
+        for (let N of y)
+          b.addMatcher(N.matcher, N.reducer);
+        E && b.addDefaultCase(E);
+      });
+    }
+    const l = (h) => h, p = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new WeakMap();
+    let m;
+    function g(h, y) {
+      return m || (m = o()), m(h, y);
+    }
+    function D() {
+      return m || (m = o()), m.getInitialState();
+    }
+    function v(h, y = !1) {
+      function E(b) {
+        let N = b[h];
+        if (typeof N > "u") {
+          if (y)
+            N = V(f, E, D);
+          else if (process.env.NODE_ENV !== "production")
+            throw new Error(process.env.NODE_ENV === "production" ? w(15) : "selectSlice returned undefined for an uninjected slice reducer");
+        }
+        return N;
+      }
+      function O(b = l) {
+        const N = V(p, y, () => /* @__PURE__ */ new WeakMap());
+        return V(N, b, () => {
+          const R = {};
+          for (const [J, K] of Object.entries(r.selectors ?? {}))
+            R[J] = Se(K, b, () => V(f, b, D), y);
+          return R;
+        });
+      }
+      return {
+        reducerPath: h,
+        getSelectors: O,
+        get selectors() {
+          return O(E);
+        },
+        selectSlice: E
+      };
+    }
+    const _ = {
+      name: s,
+      reducer: g,
+      actions: a.actionCreators,
+      caseReducers: a.sliceCaseReducersByName,
+      getInitialState: D,
+      ...v(c),
+      injectInto(h, {
+        reducerPath: y,
+        ...E
+      } = {}) {
+        const O = y ?? c;
+        return h.inject({
+          reducerPath: O,
+          reducer: g
+        }, E), {
+          ..._,
+          ...v(O, !0)
+        };
+      }
+    };
+    return _;
+  };
+}
+function Se(e, t, n, r) {
+  function s(c, ...i) {
+    let u = t(c);
+    if (typeof u > "u") {
+      if (r)
+        u = n();
+      else if (process.env.NODE_ENV !== "production")
+        throw new Error(process.env.NODE_ENV === "production" ? w(16) : "selectState returned undefined for an uninjected slice reducer");
+    }
+    return e(u, ...i);
+  }
+  return s.unwrapped = e, s;
+}
+var Be = /* @__PURE__ */ Me();
+function Te() {
+  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 Ae({
+  type: e,
+  reducerName: t,
+  createNotation: n
+}, r, s) {
+  let c, i;
+  if ("reducer" in r) {
+    if (n && !Re(r))
+      throw new Error(process.env.NODE_ENV === "production" ? w(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+    c = r.reducer, i = r.prepare;
+  } else
+    c = r;
+  s.addCase(e, c).exposeCaseReducer(t, c).exposeAction(t, i ? k(e, i) : k(e));
+}
+function je(e) {
+  return e._reducerDefinitionType === "asyncThunk";
+}
+function Re(e) {
+  return e._reducerDefinitionType === "reducerWithPrepare";
+}
+function xe({
+  type: e,
+  reducerName: t
+}, n, r, s) {
+  if (!s)
+    throw new Error(process.env.NODE_ENV === "production" ? w(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
+  const {
+    payloadCreator: c,
+    fulfilled: i,
+    pending: u,
+    rejected: a,
+    settled: d,
+    options: o
+  } = n, l = s(e, c, o);
+  r.exposeAction(t, l), i && r.addCase(l.fulfilled, i), u && r.addCase(l.pending, u), a && r.addCase(l.rejected, a), d && r.addMatcher(l.settled, d), r.exposeCaseReducer(t, {
+    fulfilled: i || S,
+    pending: u || S,
+    rejected: a || S,
+    settled: d || S
+  });
+}
+function S() {
+}
+function w(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 {
+  he as SHOULD_AUTOBATCH,
+  L as Tuple,
+  Ue as __DO_NOT_USE__ActionTypes,
+  ee as applyMiddleware,
+  we as autoBatchEnhancer,
+  Me as buildCreateSlice,
+  Z as combineReducers,
+  A as compose,
+  Pe as configureStore,
+  k as createAction,
+  ce as createActionCreatorInvariantMiddleware,
+  qe as createAsyncThunk,
+  le as createImmutableStateInvariantMiddleware,
+  B as createNextState,
+  ye as createReducer,
+  fe as createSerializableStateInvariantMiddleware,
+  Be as createSlice,
+  te as createStore,
+  Ge as current,
+  j as findNonSerializableValue,
+  w as formatProdErrorMessage,
+  Xe as freeze,
+  P as isAction,
+  ae as isActionCreator,
+  Ne as isAnyOf,
+  re as isDraft,
+  ue as isImmutableDefault,
+  H as isPlain,
+  q as isPlainObject,
+  Oe as miniSerializeError,
+  De as nanoid,
+  _e as unwrapResult
+};