nolo-cli 0.96.0-alpha.1 → 0.96.0

package/{chunk-UKWGR5SS.js → chunk-WIWM4FE3.js}

@@ -941,7 +941,7 @@ var objectTraps = {
       const currentState = current2?.[DRAFT_STATE];
       if (currentState && currentState.base_ === value) {
         state.copy_[prop] = value;
-        state.assigned_.set(prop, false);
+        state.assigned_.delete(prop);
         return true;
       }
       if (is(value, current2) && (value !== void 0 || has(state.base_, prop, state.type_)))
@@ -1268,9 +1268,7 @@ var createDraftSafeSelectorCreator = (...args) => {
     const wrappedSelector = (value, ...rest) => selector(isDraft(value) ? current(value) : value, ...rest);
     Object.assign(wrappedSelector, selector);
     return wrappedSelector;
-  }, {
-    withTypes: () => createDraftSafeSelector2
-  });
+  }, { withTypes: () => createDraftSafeSelector2 });
   return createDraftSafeSelector2;
 };
 var createDraftSafeSelector = /* @__PURE__ */ createDraftSafeSelectorCreator(weakMapMemoize);
@@ -1279,11 +1277,7 @@ var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOO
   if (typeof arguments[0] === "object") return compose;
   return compose.apply(null, arguments);
 };
-var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {
-  return function(noop3) {
-    return noop3;
-  };
-};
+typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__;
 var hasMatchFunction = (v) => {
   return v && typeof v.match === "function";
 };
@@ -1291,18 +1285,12 @@ function createAction(type, prepareAction) {
   function actionCreator(...args) {
     if (prepareAction) {
       let prepared = prepareAction(...args);
-      if (!prepared) {
-        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : "prepareAction did not return an object");
-      }
+      if (!prepared) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : "prepareAction did not return an object");
       return {
         type,
         payload: prepared.payload,
-        ..."meta" in prepared && {
-          meta: prepared.meta
-        },
-        ..."error" in prepared && {
-          error: prepared.error
-        }
+        ..."meta" in prepared && { meta: prepared.meta },
+        ..."error" in prepared && { error: prepared.error }
       };
     }
     return {
@@ -1319,7 +1307,12 @@ function isFSA(action) {
   return isAction(action) && Object.keys(action).every(isValidKey);
 }
 function isValidKey(key) {
-  return ["type", "payload", "error", "meta"].indexOf(key) > -1;
+  return [
+    "type",
+    "payload",
+    "error",
+    "meta"
+  ].indexOf(key) > -1;
 }
 function freezeDraftable(val) {
   return isDraftable(val) ? produce(val, () => {
@@ -1336,28 +1329,18 @@ function executeReducerBuilderCallback(builderCallback) {
   const builder = {
     addCase(typeOrActionCreator, reducer) {
       if (process.env.NODE_ENV !== "production") {
-        if (actionMatchers.length > 0) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
-        }
-        if (defaultCaseReducer) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
-        }
+        if (actionMatchers.length > 0) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
+        if (defaultCaseReducer) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
       }
       const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
-      if (!type) {
-        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(28) : "`builder.addCase` cannot be called with an empty action type");
-      }
-      if (type in actionsMap) {
-        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
-      }
+      if (!type) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(28) : "`builder.addCase` cannot be called with an empty action type");
+      if (type in actionsMap) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
       actionsMap[type] = reducer;
       return builder;
     },
     addAsyncThunk(asyncThunk, reducers) {
       if (process.env.NODE_ENV !== "production") {
-        if (defaultCaseReducer) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
-        }
+        if (defaultCaseReducer) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
       }
       if (reducers.pending) actionsMap[asyncThunk.pending.type] = reducers.pending;
       if (reducers.rejected) actionsMap[asyncThunk.rejected.type] = reducers.rejected;
@@ -1370,9 +1353,7 @@ function executeReducerBuilderCallback(builderCallback) {
     },
     addMatcher(matcher, reducer) {
       if (process.env.NODE_ENV !== "production") {
-        if (defaultCaseReducer) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
-        }
+        if (defaultCaseReducer) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
       }
       actionMatchers.push({
         matcher,
@@ -1382,66 +1363,52 @@ function executeReducerBuilderCallback(builderCallback) {
     },
     addDefaultCase(reducer) {
       if (process.env.NODE_ENV !== "production") {
-        if (defaultCaseReducer) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(31) : "`builder.addDefaultCase` can only be called once");
-        }
+        if (defaultCaseReducer) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(31) : "`builder.addDefaultCase` can only be called once");
       }
       defaultCaseReducer = reducer;
       return builder;
     }
   };
   builderCallback(builder);
-  return [actionsMap, actionMatchers, defaultCaseReducer];
+  return [
+    actionsMap,
+    actionMatchers,
+    defaultCaseReducer
+  ];
 }
 function isStateFunction(x) {
   return typeof x === "function";
 }
 function createReducer(initialState, mapOrBuilderCallback) {
   if (process.env.NODE_ENV !== "production") {
-    if (typeof mapOrBuilderCallback === "object") {
-      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
-    }
+    if (typeof mapOrBuilderCallback === "object") throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
   }
   let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
   let getInitialState;
-  if (isStateFunction(initialState)) {
-    getInitialState = () => freezeDraftable(initialState());
-  } else {
+  if (isStateFunction(initialState)) getInitialState = () => freezeDraftable(initialState());
+  else {
     const frozenInitialState = freezeDraftable(initialState);
     getInitialState = () => frozenInitialState;
   }
   function reducer(state = getInitialState(), action) {
-    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
-      matcher
-    }) => matcher(action)).map(({
-      reducer: reducer2
-    }) => reducer2)];
-    if (caseReducers.filter((cr) => !!cr).length === 0) {
-      caseReducers = [finalDefaultCaseReducer];
-    }
+    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({ matcher }) => matcher(action)).map(({ reducer: reducer2 }) => reducer2)];
+    if (caseReducers.filter((cr) => !!cr).length === 0) caseReducers = [finalDefaultCaseReducer];
     return caseReducers.reduce((previousState, caseReducer) => {
       if (caseReducer) {
         if (isDraft(previousState)) {
-          const draft = previousState;
-          const result = caseReducer(draft, action);
-          if (result === void 0) {
-            return previousState;
-          }
+          const result = caseReducer(previousState, action);
+          if (result === void 0) return previousState;
           return result;
         } else if (!isDraftable(previousState)) {
           const result = caseReducer(previousState, action);
           if (result === void 0) {
-            if (previousState === null) {
-              return previousState;
-            }
-            throw Error("A case reducer on a non-draftable value must not return undefined");
+            if (previousState === null) return previousState;
+            throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(9) : "A case reducer on a non-draftable value must not return undefined");
           }
           return result;
-        } else {
-          return produce(previousState, (draft) => {
-            return caseReducer(draft, action);
-          });
-        }
+        } else return produce(previousState, (draft) => {
+          return caseReducer(draft, action);
+        });
       }
       return previousState;
     }, state);
@@ -1450,11 +1417,8 @@ function createReducer(initialState, mapOrBuilderCallback) {
   return reducer;
 }
 var matches = (matcher, action) => {
-  if (hasMatchFunction(matcher)) {
-    return matcher.match(action);
-  } else {
-    return matcher(action);
-  }
+  if (hasMatchFunction(matcher)) return matcher.match(action);
+  else return matcher(action);
 };
 function isAnyOf(...matchers) {
   return (action) => {
@@ -1465,51 +1429,40 @@ var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXI
 var nanoid = (size = 21) => {
   let id = "";
   let i = size;
-  while (i--) {
-    id += urlAlphabet[Math.random() * 64 | 0];
-  }
+  while (i--) id += urlAlphabet[Math.random() * 64 | 0];
   return id;
 };
-var commonProperties = ["name", "message", "stack", "code"];
+var commonProperties = [
+  "name",
+  "message",
+  "stack",
+  "code"
+];
 var RejectWithValue = class {
+  payload;
+  meta;
+  _type;
   constructor(payload, meta) {
     this.payload = payload;
     this.meta = meta;
   }
+};
+var FulfillWithMeta = class {
   payload;
   meta;
-  /*
-  type-only property to distinguish between RejectWithValue and FulfillWithMeta
-  does not exist at runtime
-  */
   _type;
-};
-var FulfillWithMeta = class {
   constructor(payload, meta) {
     this.payload = payload;
     this.meta = meta;
   }
-  payload;
-  meta;
-  /*
-  type-only property to distinguish between RejectWithValue and FulfillWithMeta
-  does not exist at runtime
-  */
-  _type;
 };
 var miniSerializeError = (value) => {
   if (typeof value === "object" && value !== null) {
     const simpleError = {};
-    for (const property of commonProperties) {
-      if (typeof value[property] === "string") {
-        simpleError[property] = value[property];
-      }
-    }
+    for (const property of commonProperties) if (typeof value[property] === "string") simpleError[property] = value[property];
     return simpleError;
   }
-  return {
-    message: String(value)
-  };
+  return { message: String(value) };
 };
 var externalAbortMessage = "External signal was aborted";
 var createAsyncThunk = /* @__PURE__ */ (() => {
@@ -1539,15 +1492,13 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
         ...meta || {},
         arg,
         requestId,
-        rejectedWithValue: !!payload,
+        rejectedWithValue: payload !== void 0,
         requestStatus: "rejected",
         aborted: error?.name === "AbortError",
         condition: error?.name === "ConditionError"
       }
     }));
-    function actionCreator(arg, {
-      signal
-    } = {}) {
+    function actionCreator(arg, { signal } = {}) {
       return (dispatch, getState, extra) => {
         const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
         const abortController = new AbortController();
@@ -1558,13 +1509,8 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
           abortController.abort();
         }
         if (signal) {
-          if (signal.aborted) {
-            abort(externalAbortMessage);
-          } else {
-            signal.addEventListener("abort", () => abort(externalAbortMessage), {
-              once: true
-            });
-          }
+          if (signal.aborted) abort(externalAbortMessage);
+          else signal.addEventListener("abort", () => abort(externalAbortMessage), { once: true });
         }
         const promise = async function() {
           let finalAction;
@@ -1573,15 +1519,15 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
               getState,
               extra
             });
-            if (isThenable(conditionResult)) {
-              conditionResult = await conditionResult;
-            }
-            if (conditionResult === false || abortController.signal.aborted) {
-              throw {
-                name: "ConditionError",
-                message: "Aborted due to condition callback returning false."
-              };
-            }
+            if (isThenable(conditionResult)) conditionResult = await conditionResult;
+            if (conditionResult === false) throw {
+              name: "ConditionError",
+              message: "Aborted due to condition callback returning false."
+            };
+            if (abortController.signal.aborted) throw {
+              name: "AbortError",
+              message: abortReason || "Aborted"
+            };
             const abortedPromise = new Promise((_, reject) => {
               abortHandler = () => {
                 reject({
@@ -1589,9 +1535,7 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
                   message: abortReason || "Aborted"
                 });
               };
-              abortController.signal.addEventListener("abort", abortHandler, {
-                once: true
-              });
+              abortController.signal.addEventListener("abort", abortHandler, { once: true });
             });
             dispatch(pending(requestId, arg, options?.getPendingMeta?.({
               requestId,
@@ -1614,25 +1558,16 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
                 return new FulfillWithMeta(value, meta);
               }
             })).then((result) => {
-              if (result instanceof RejectWithValue) {
-                throw result;
-              }
-              if (result instanceof FulfillWithMeta) {
-                return fulfilled(result.payload, requestId, arg, result.meta);
-              }
+              if (result instanceof RejectWithValue) throw result;
+              if (result instanceof FulfillWithMeta) return fulfilled(result.payload, requestId, arg, result.meta);
               return fulfilled(result, requestId, arg);
             })]);
           } catch (err) {
             finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
           } finally {
-            if (abortHandler) {
-              abortController.signal.removeEventListener("abort", abortHandler);
-            }
-          }
-          const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
-          if (!skipDispatch) {
-            dispatch(finalAction);
+            if (abortHandler) abortController.signal.removeEventListener("abort", abortHandler);
           }
+          if (!(options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition)) dispatch(finalAction);
           return finalAction;
         }();
         return Object.assign(promise, {
@@ -1657,40 +1592,25 @@ var createAsyncThunk = /* @__PURE__ */ (() => {
   return createAsyncThunk2;
 })();
 function unwrapResult(action) {
-  if (action.meta && action.meta.rejectedWithValue) {
-    throw action.payload;
-  }
-  if (action.error) {
-    throw action.error;
-  }
+  if (action.meta && action.meta.rejectedWithValue) throw action.payload;
+  if (action.error) throw action.error;
   return action.payload;
 }
 function isThenable(value) {
   return value !== null && typeof value === "object" && typeof value.then === "function";
 }
 var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
-var asyncThunkCreator = {
-  [asyncThunkSymbol]: createAsyncThunk
-};
+var asyncThunkCreator = { [asyncThunkSymbol]: createAsyncThunk };
 function getType(slice, actionKey) {
   return `${slice}/${actionKey}`;
 }
-function buildCreateSlice({
-  creators
-} = {}) {
+function buildCreateSlice({ creators } = {}) {
   const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
-  return function createSlice2(options) {
-    const {
-      name,
-      reducerPath = name
-    } = options;
-    if (!name) {
-      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(11) : "`name` is a required option for createSlice");
-    }
+  return function createSlice(options) {
+    const { name, reducerPath = name } = options;
+    if (!name) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(11) : "`name` is a required option for createSlice");
     if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
-      if (options.initialState === void 0) {
-        console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
-      }
+      if (options.initialState === void 0) console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
     }
     const reducers = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
     const reducerNames = Object.keys(reducers);
@@ -1703,12 +1623,8 @@ function buildCreateSlice({
     const contextMethods = {
       addCase(typeOrActionCreator, reducer2) {
         const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
-        if (!type) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : "`context.addCase` cannot be called with an empty action type");
-        }
-        if (type in context.sliceCaseReducersByType) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
-        }
+        if (!type) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : "`context.addCase` cannot be called with an empty action type");
+        if (type in context.sliceCaseReducersByType) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
         context.sliceCaseReducersByType[type] = reducer2;
         return contextMethods;
       },
@@ -1735,17 +1651,12 @@ function buildCreateSlice({
         type: getType(name, reducerName),
         createNotation: typeof options.reducers === "function"
       };
-      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
-        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
-      } else {
-        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
-      }
+      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
+      else handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
     });
     function buildReducer() {
       if (process.env.NODE_ENV !== "production") {
-        if (typeof options.extraReducers === "object") {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
-        }
+        if (typeof options.extraReducers === "object") throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(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 [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
       const finalCaseReducers = {
@@ -1753,18 +1664,10 @@ function buildCreateSlice({
         ...context.sliceCaseReducersByType
       };
       return createReducer(options.initialState, (builder) => {
-        for (let key in finalCaseReducers) {
-          builder.addCase(key, finalCaseReducers[key]);
-        }
-        for (let sM of context.sliceMatchers) {
-          builder.addMatcher(sM.matcher, sM.reducer);
-        }
-        for (let m of actionMatchers) {
-          builder.addMatcher(m.matcher, m.reducer);
-        }
-        if (defaultCaseReducer) {
-          builder.addDefaultCase(defaultCaseReducer);
-        }
+        for (let key in finalCaseReducers) builder.addCase(key, finalCaseReducers[key]);
+        for (let sM of context.sliceMatchers) builder.addMatcher(sM.matcher, sM.reducer);
+        for (let m of actionMatchers) builder.addMatcher(m.matcher, m.reducer);
+        if (defaultCaseReducer) builder.addDefaultCase(defaultCaseReducer);
       });
     }
     const selectSelf = (state) => state;
@@ -1783,21 +1686,15 @@ function buildCreateSlice({
       function selectSlice(state) {
         let sliceState = state[reducerPath2];
         if (typeof sliceState === "undefined") {
-          if (injected) {
-            sliceState = getOrInsertComputed(injectedStateCache, selectSlice, getInitialState);
-          } else if (process.env.NODE_ENV !== "production") {
-            throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(15) : "selectSlice returned undefined for an uninjected slice reducer");
-          }
+          if (injected) sliceState = getOrInsertComputed(injectedStateCache, selectSlice, getInitialState);
+          else if (process.env.NODE_ENV !== "production") throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(15) : "selectSlice returned undefined for an uninjected slice reducer");
         }
         return sliceState;
       }
       function getSelectors(selectState = selectSelf) {
-        const selectorCache = getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap());
-        return getOrInsertComputed(selectorCache, selectState, () => {
+        return getOrInsertComputed(getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap()), selectState, () => {
           const map = {};
-          for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
-            map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
-          }
+          for (const [name2, selector] of Object.entries(options.selectors ?? {})) map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
           return map;
         });
       }
@@ -1817,10 +1714,7 @@ function buildCreateSlice({
       caseReducers: context.sliceCaseReducersByName,
       getInitialState,
       ...makeSelectorProps(reducerPath),
-      injectInto(injectable, {
-        reducerPath: pathOpt,
-        ...config
-      } = {}) {
+      injectInto(injectable, { reducerPath: pathOpt, ...config } = {}) {
         const newReducerPath = pathOpt ?? reducerPath;
         injectable.inject({
           reducerPath: newReducerPath,
@@ -1839,11 +1733,8 @@ function wrapSelector(selector, selectState, getInitialState, injected) {
   function wrapper(rootState, ...args) {
     let sliceState = selectState(rootState);
     if (typeof sliceState === "undefined") {
-      if (injected) {
-        sliceState = getInitialState();
-      } else if (process.env.NODE_ENV !== "production") {
-        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(16) : "selectState returned undefined for an uninjected slice reducer");
-      }
+      if (injected) sliceState = getInitialState();
+      else if (process.env.NODE_ENV !== "production") throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(16) : "selectState returned undefined for an uninjected slice reducer");
     }
     return selector(sliceState, ...args);
   }
@@ -1861,16 +1752,9 @@ function buildReducerCreators() {
   asyncThunk.withTypes = () => asyncThunk;
   return {
     reducer(caseReducer) {
-      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
-        [caseReducer.name](...args) {
-          return caseReducer(...args);
-        }
-      }[caseReducer.name], {
-        _reducerDefinitionType: "reducer"
-        /* reducer */
-      });
+      return Object.assign({ [caseReducer.name](...args) {
+        return caseReducer(...args);
+      } }[caseReducer.name], { _reducerDefinitionType: "reducer" });
     },
     preparedReducer(prepare, reducer) {
       return {
@@ -1882,22 +1766,14 @@ function buildReducerCreators() {
     asyncThunk
   };
 }
-function handleNormalReducerDefinition({
-  type,
-  reducerName,
-  createNotation
-}, maybeReducerWithPrepare, context) {
+function handleNormalReducerDefinition({ type, reducerName, createNotation }, maybeReducerWithPrepare, context) {
   let caseReducer;
   let prepareCallback;
   if ("reducer" in maybeReducerWithPrepare) {
-    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
-      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
-    }
+    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
     caseReducer = maybeReducerWithPrepare.reducer;
     prepareCallback = maybeReducerWithPrepare.prepare;
-  } else {
-    caseReducer = maybeReducerWithPrepare;
-  }
+  } else caseReducer = maybeReducerWithPrepare;
   context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
 }
 function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
@@ -1906,43 +1782,23 @@ function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
 function isCaseReducerWithPrepareDefinition(reducerDefinition) {
   return reducerDefinition._reducerDefinitionType === "reducerWithPrepare";
 }
-function handleThunkCaseReducerDefinition({
-  type,
-  reducerName
-}, reducerDefinition, context, cAT) {
-  if (!cAT) {
-    throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
-  }
-  const {
-    payloadCreator,
-    fulfilled,
-    pending,
-    rejected,
-    settled,
-    options
-  } = reducerDefinition;
+function handleThunkCaseReducerDefinition({ type, reducerName }, reducerDefinition, context, cAT) {
+  if (!cAT) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
+  const { payloadCreator, fulfilled, pending, rejected, settled, options } = reducerDefinition;
   const thunk = cAT(type, payloadCreator, options);
   context.exposeAction(reducerName, thunk);
-  if (fulfilled) {
-    context.addCase(thunk.fulfilled, fulfilled);
-  }
-  if (pending) {
-    context.addCase(thunk.pending, pending);
-  }
-  if (rejected) {
-    context.addCase(thunk.rejected, rejected);
-  }
-  if (settled) {
-    context.addMatcher(thunk.settled, settled);
-  }
+  if (fulfilled) context.addCase(thunk.fulfilled, fulfilled);
+  if (pending) context.addCase(thunk.pending, pending);
+  if (rejected) context.addCase(thunk.rejected, rejected);
+  if (settled) context.addMatcher(thunk.settled, settled);
   context.exposeCaseReducer(reducerName, {
-    fulfilled: fulfilled || noop,
-    pending: pending || noop,
-    rejected: rejected || noop,
-    settled: settled || noop
+    fulfilled: fulfilled || noop$1,
+    pending: pending || noop$1,
+    rejected: rejected || noop$1,
+    settled: settled || noop$1
   });
 }
-function noop() {
+function noop$1() {
 }
 function getInitialEntityState() {
   return {
@@ -1955,30 +1811,24 @@ function createInitialStateFactory(stateAdapter) {
     const state = Object.assign(getInitialEntityState(), additionalState);
     return entities ? stateAdapter.setAll(state, entities) : state;
   }
-  return {
-    getInitialState
-  };
+  return { getInitialState };
 }
 function createSelectorsFactory() {
   function getSelectors(selectState, options = {}) {
-    const {
-      createSelector: createSelector2 = createDraftSafeSelector
-    } = options;
+    const { createSelector: createSelector2 = createDraftSafeSelector } = options;
     const selectIds = (state) => state.ids;
     const selectEntities = (state) => state.entities;
     const selectAll = createSelector2(selectIds, selectEntities, (ids, entities) => ids.map((id) => entities[id]));
     const selectId = (_, id) => id;
     const selectById = (entities, id) => entities[id];
     const selectTotal = createSelector2(selectIds, (ids) => ids.length);
-    if (!selectState) {
-      return {
-        selectIds,
-        selectEntities,
-        selectAll,
-        selectTotal,
-        selectById: createSelector2(selectEntities, selectId, selectById)
-      };
-    }
+    if (!selectState) return {
+      selectIds,
+      selectEntities,
+      selectAll,
+      selectTotal,
+      selectById: createSelector2(selectEntities, selectId, selectById)
+    };
     const selectGlobalizedEntities = createSelector2(selectState, selectEntities);
     return {
       selectIds: createSelector2(selectState, selectIds),
@@ -1988,9 +1838,7 @@ function createSelectorsFactory() {
       selectById: createSelector2(selectGlobalizedEntities, selectId, selectById)
     };
   }
-  return {
-    getSelectors
-  };
+  return { getSelectors };
 }
 var isDraftTyped = isDraft;
 function createSingleArgumentStateOperator(mutator) {
@@ -2005,11 +1853,8 @@ function createStateOperator(mutator) {
       return isFSA(arg2);
     }
     const runMutator = (draft) => {
-      if (isPayloadActionArgument(arg)) {
-        mutator(arg.payload, draft);
-      } else {
-        mutator(arg, draft);
-      }
+      if (isPayloadActionArgument(arg)) mutator(arg.payload, draft);
+      else mutator(arg, draft);
     };
     if (isDraftTyped(state)) {
       runMutator(state);
@@ -2020,15 +1865,11 @@ function createStateOperator(mutator) {
 }
 function selectIdValue(entity, selectId) {
   const key = selectId(entity);
-  if (process.env.NODE_ENV !== "production" && key === void 0) {
-    console.warn("The entity passed to the `selectId` implementation returned undefined.", "You should probably provide your own `selectId` implementation.", "The entity that was passed:", entity, "The `selectId` implementation:", selectId.toString());
-  }
+  if (process.env.NODE_ENV !== "production" && key === void 0) console.warn("The entity passed to the `selectId` implementation returned undefined.", "You should probably provide your own `selectId` implementation.", "The entity that was passed:", entity, "The `selectId` implementation:", selectId.toString());
   return key;
 }
 function ensureEntitiesArray(entities) {
-  if (!Array.isArray(entities)) {
-    entities = Object.values(entities);
-  }
+  if (!Array.isArray(entities)) entities = Object.values(entities);
   return entities;
 }
 function getCurrent(value) {
@@ -2043,52 +1884,46 @@ function splitAddedUpdatedEntities(newEntities, selectId, state) {
   const updated = [];
   for (const entity of newEntities) {
     const id = selectIdValue(entity, selectId);
-    if (existingIds.has(id) || addedIds.has(id)) {
-      updated.push({
-        id,
-        changes: entity
-      });
-    } else {
+    if (existingIds.has(id) || addedIds.has(id)) updated.push({
+      id,
+      changes: entity
+    });
+    else {
       addedIds.add(id);
       added.push(entity);
     }
   }
-  return [added, updated, existingIdsArray];
+  return [
+    added,
+    updated,
+    existingIdsArray
+  ];
 }
 function createUnsortedStateAdapter(selectId) {
   function addOneMutably(entity, state) {
     const key = selectIdValue(entity, selectId);
-    if (key in state.entities) {
-      return;
-    }
+    if (key in state.entities) return;
     state.ids.push(key);
     state.entities[key] = entity;
   }
   function addManyMutably(newEntities, state) {
     newEntities = ensureEntitiesArray(newEntities);
-    for (const entity of newEntities) {
-      addOneMutably(entity, state);
-    }
+    for (const entity of newEntities) addOneMutably(entity, state);
   }
   function setOneMutably(entity, state) {
     const key = selectIdValue(entity, selectId);
-    if (!(key in state.entities)) {
-      state.ids.push(key);
-    }
-    ;
+    if (!(key in state.entities)) state.ids.push(key);
     state.entities[key] = entity;
   }
   function setManyMutably(newEntities, state) {
     newEntities = ensureEntitiesArray(newEntities);
-    for (const entity of newEntities) {
-      setOneMutably(entity, state);
-    }
+    for (const entity of newEntities) setOneMutably(entity, state);
   }
   function setAllMutably(newEntities, state) {
     newEntities = ensureEntitiesArray(newEntities);
     state.ids = [];
     state.entities = {};
-    addManyMutably(newEntities, state);
+    setManyMutably(newEntities, state);
   }
   function removeOneMutably(key, state) {
     return removeManyMutably([key], state);
@@ -2101,9 +1936,7 @@ function createUnsortedStateAdapter(selectId) {
         didMutate = true;
       }
     });
-    if (didMutate) {
-      state.ids = state.ids.filter((id) => id in state.entities);
-    }
+    if (didMutate) state.ids = state.ids.filter((id) => id in state.entities);
   }
   function removeAllMutably(state) {
     Object.assign(state, {
@@ -2112,18 +1945,15 @@ function createUnsortedStateAdapter(selectId) {
     });
   }
   function takeNewKey(keys, update, state) {
-    const original3 = state.entities[update.id];
-    if (original3 === void 0) {
-      return false;
-    }
-    const updated = Object.assign({}, original3, update.changes);
+    const original2 = state.entities[update.id];
+    if (original2 === void 0) return false;
+    const updated = Object.assign({}, original2, update.changes);
     const newKey = selectIdValue(updated, selectId);
     const hasNewKey = newKey !== update.id;
     if (hasNewKey) {
       keys[update.id] = newKey;
       delete state.entities[update.id];
     }
-    ;
     state.entities[newKey] = updated;
     return hasNewKey;
   }
@@ -2134,25 +1964,17 @@ function createUnsortedStateAdapter(selectId) {
     const newKeys = {};
     const updatesPerEntity = {};
     updates.forEach((update) => {
-      if (update.id in state.entities) {
-        updatesPerEntity[update.id] = {
-          id: update.id,
-          // Spreads ignore falsy values, so this works even if there isn't
-          // an existing update already at this key
-          changes: {
-            ...updatesPerEntity[update.id]?.changes,
-            ...update.changes
-          }
-        };
-      }
+      if (update.id in state.entities) updatesPerEntity[update.id] = {
+        id: update.id,
+        changes: {
+          ...updatesPerEntity[update.id]?.changes,
+          ...update.changes
+        }
+      };
     });
     updates = Object.values(updatesPerEntity);
-    const didMutateEntities = updates.length > 0;
-    if (didMutateEntities) {
-      const didMutateIds = updates.filter((update) => takeNewKey(newKeys, update, state)).length > 0;
-      if (didMutateIds) {
-        state.ids = Object.values(state.entities).map((e) => selectIdValue(e, selectId));
-      }
+    if (updates.length > 0) {
+      if (updates.filter((update) => takeNewKey(newKeys, update, state)).length > 0) state.ids = Object.values(state.entities).map((e) => selectIdValue(e, selectId));
     }
   }
   function upsertOneMutably(entity, state) {
@@ -2184,12 +2006,8 @@ function findInsertIndex(sortedItems, item, comparisonFunction) {
   while (lowIndex < highIndex) {
     let middleIndex = lowIndex + highIndex >>> 1;
     const currentItem = sortedItems[middleIndex];
-    const res = comparisonFunction(item, currentItem);
-    if (res >= 0) {
-      lowIndex = middleIndex + 1;
-    } else {
-      highIndex = middleIndex;
-    }
+    if (comparisonFunction(item, currentItem) >= 0) lowIndex = middleIndex + 1;
+    else highIndex = middleIndex;
   }
   return lowIndex;
 }
@@ -2199,11 +2017,7 @@ function insert(sortedItems, item, comparisonFunction) {
   return sortedItems;
 }
 function createSortedStateAdapter(selectId, comparer) {
-  const {
-    removeOne,
-    removeMany,
-    removeAll
-  } = createUnsortedStateAdapter(selectId);
+  const { removeOne, removeMany, removeAll } = createUnsortedStateAdapter(selectId);
   function addOneMutably(entity, state) {
     return addManyMutably([entity], state);
   }
@@ -2217,9 +2031,7 @@ function createSortedStateAdapter(selectId, comparer) {
       if (notAdded) addedKeys.add(modelId);
       return !existingKeys.has(modelId) && notAdded;
     });
-    if (models.length !== 0) {
-      mergeFunction(state, models);
-    }
+    if (models.length !== 0) mergeFunction(state, models);
   }
   function setOneMutably(entity, state) {
     return setManyMutably([entity], state);
@@ -2241,7 +2053,7 @@ function createSortedStateAdapter(selectId, comparer) {
     newEntities = ensureEntitiesArray(newEntities);
     state.entities = {};
     state.ids = [];
-    addManyMutably(newEntities, state, []);
+    setManyMutably(newEntities, state);
   }
   function updateOneMutably(update, state) {
     return updateManyMutably([update], state);
@@ -2249,11 +2061,17 @@ function createSortedStateAdapter(selectId, comparer) {
   function updateManyMutably(updates, state) {
     let appliedUpdates = false;
     let replacedIds = false;
-    for (let update of updates) {
-      const entity = state.entities[update.id];
-      if (!entity) {
-        continue;
+    const updatesPerEntity = {};
+    for (const update of updates) if (update.id in state.entities) updatesPerEntity[update.id] = {
+      id: update.id,
+      changes: {
+        ...updatesPerEntity[update.id]?.changes,
+        ...update.changes
       }
+    };
+    for (const update of Object.values(updatesPerEntity)) {
+      const entity = state.entities[update.id];
+      if (!entity) continue;
       appliedUpdates = true;
       Object.assign(entity, update.changes);
       const newId = selectId(entity);
@@ -2265,66 +2083,45 @@ function createSortedStateAdapter(selectId, comparer) {
         state.entities[newId] = entity;
       }
     }
-    if (appliedUpdates) {
-      mergeFunction(state, [], appliedUpdates, replacedIds);
-    }
+    if (appliedUpdates) mergeFunction(state, [], appliedUpdates, replacedIds);
   }
   function upsertOneMutably(entity, state) {
     return upsertManyMutably([entity], state);
   }
   function upsertManyMutably(newEntities, state) {
     const [added, updated, existingIdsArray] = splitAddedUpdatedEntities(newEntities, selectId, state);
-    if (added.length) {
-      addManyMutably(added, state, existingIdsArray);
-    }
-    if (updated.length) {
-      updateManyMutably(updated, state);
-    }
+    if (added.length) addManyMutably(added, state, existingIdsArray);
+    if (updated.length) updateManyMutably(updated, state);
   }
   function areArraysEqual(a, b) {
-    if (a.length !== b.length) {
-      return false;
-    }
+    if (a.length !== b.length) return false;
     for (let i = 0; i < a.length; i++) {
-      if (a[i] === b[i]) {
-        continue;
-      }
+      if (a[i] === b[i]) continue;
       return false;
     }
     return true;
   }
-  const mergeFunction = (state, addedItems, appliedUpdates, replacedIds) => {
+  function mergeFunction(state, addedItems, appliedUpdates, replacedIds) {
     const currentEntities = getCurrent(state.entities);
     const currentIds = getCurrent(state.ids);
     const stateEntities = state.entities;
     let ids = currentIds;
-    if (replacedIds) {
-      ids = new Set(currentIds);
-    }
+    if (replacedIds) ids = new Set(currentIds);
     let sortedEntities = [];
     for (const id of ids) {
       const entity = currentEntities[id];
-      if (entity) {
-        sortedEntities.push(entity);
-      }
+      if (entity) sortedEntities.push(entity);
     }
     const wasPreviouslyEmpty = sortedEntities.length === 0;
     for (const item of addedItems) {
       stateEntities[selectId(item)] = item;
-      if (!wasPreviouslyEmpty) {
-        insert(sortedEntities, item, comparer);
-      }
-    }
-    if (wasPreviouslyEmpty) {
-      sortedEntities = addedItems.slice().sort(comparer);
-    } else if (appliedUpdates) {
-      sortedEntities.sort(comparer);
+      if (!wasPreviouslyEmpty) insert(sortedEntities, item, comparer);
     }
+    if (wasPreviouslyEmpty) sortedEntities = addedItems.slice().sort(comparer);
+    else if (appliedUpdates) sortedEntities.sort(comparer);
     const newSortedIds = sortedEntities.map(selectId);
-    if (!areArraysEqual(currentIds, newSortedIds)) {
-      state.ids = newSortedIds;
-    }
-  };
+    if (!areArraysEqual(currentIds, newSortedIds)) state.ids = newSortedIds;
+  }
   return {
     removeOne,
     removeMany,
@@ -2341,10 +2138,7 @@ function createSortedStateAdapter(selectId, comparer) {
   };
 }
 function createEntityAdapter(options = {}) {
-  const {
-    selectId,
-    sortComparer
-  } = {
+  const { selectId, sortComparer } = {
     sortComparer: false,
     selectId: (instance) => instance.id,
     ...options
@@ -2367,17 +2161,12 @@ var taskCancelled = `task-${cancelled}`;
 var taskCompleted = `task-${completed}`;
 var listenerCancelled = `${listener}-${cancelled}`;
 var listenerCompleted = `${listener}-${completed}`;
-var {
-  assign
-} = Object;
+var { assign } = Object;
 var alm = "listenerMiddleware";
-var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), {
-  withTypes: () => addListener
-});
+var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), { withTypes: () => addListener });
 var clearAllListeners = /* @__PURE__ */ createAction(`${alm}/removeAll`);
-var removeListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/remove`), {
-  withTypes: () => removeListener
-});
+var removeListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/remove`), { withTypes: () => removeListener });
+var ORIGINAL_STATE = Symbol.for("rtk-state-proxy-original");
 function formatProdErrorMessage(code) {
   return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
 }