https://www.heiligenfeld.de/wp-content/themes/pixelmechanics-child-theme/build/index.js?ver=1790270828

1/******/ (() => { // webpackBootstrap
2/******/ 	"use strict";
3/******/ 	var __webpack_modules__ = ({
4
5/***/ "./src/

491/***/ "./node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.development.js":
492/*!*******************************************************************************************************!*\
493  !*** ./node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.development.js ***!
494  \*******************************************************************************************************/
495/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
496
497/**
498 * @license React
499 * use-sync-external-store-with-selector.development.js
500 *
501 * Copyright (c) Facebook, Inc. and its affiliates.
502 *
503 * This source code is licensed under the MIT license found in the
504 * LICENSE file in the root directory of this source tree.
505 */
506
507
508
509if (true) {
510  (function() {
511
512          'use strict';
513
514/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
515if (
516  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
517  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
518    'function'
519) {
520  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
521}
522          var React = __webpack_require__(/*! react */ "react");
523
524/**
525 * inlined Object.is polyfill to avoid requiring consumers ship their own
526 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
527 */
528function is(x, y) {
529  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
530  ;
531}
532
533var objectIs = typeof Object.is === 'function' ? Object.is : is;
534
535var useSyncExternalStore = React.useSyncExternalStore;
536
537// for CommonJS interop.
538
539var useRef = React.useRef,
540    useEffect = React.useEffect,
541    useMemo = React.useMemo,
542    useDebugValue = React.useDebugValue; // Same as useSyncExternalStore, but supports selector and isEqual arguments.
543
544function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
545  // Use this to track the rendered snapshot.
546  var instRef = useRef(null);
547  var inst;
548
549  if (instRef.current === null) {
550    inst = {
551      hasValue: false,
552      value: null
553    };
554    instRef.current = inst;
555  } else {
556    inst = instRef.current;
557  }
558
559  var _useMemo = useMemo(function () {
560    // Track the memoized state using closure variables that are local to this
561    // memoized instance of a getSnapshot function. Intentionally not using a
562    // useRef hook, because that state would be shared across all concurrent
563    // copies of the hook/component.
564    var hasMemo = false;
565    var memoizedSnapshot;
566    var memoizedSelection;
567
568    var memoizedSelector = function (nextSnapshot) {
569      if (!hasMemo) {
570        // The first time the hook is called, there is no memoized result.
571        hasMemo = true;
572        memoizedSnapshot = nextSnapshot;
573
574        var _nextSelection = selector(nextSnapshot);
575
576        if (isEqual !== undefined) {
577          // Even if the selector has changed, the currently rendered selection
578          // may be equal to the new selection. We should attempt to reuse the
579          // current value if possible, to preserve downstream memoizations.
580          if (inst.hasValue) {
581            var currentSelection = inst.value;
582
583            if (isEqual(currentSelection, _nextSelection)) {
584              memoizedSelection = currentSelection;
585              return currentSelection;
586            }
587          }
588        }
589
590        memoizedSelection = _nextSelection;
591        return _nextSelection;
592      } // We may be able to reuse the previous invocation's result.
593
594
595      // We may be able to reuse the previous invocation's result.
596      var prevSnapshot = memoizedSnapshot;
597      var prevSelection = memoizedSelection;
598
599      if (objectIs(prevSnapshot, nextSnapshot)) {
600        // The snapshot is the same as last time. Reuse the previous selection.
601        return prevSelection;
602      } // The snapshot has changed, so we need to compute a new selection.
603
604
605      // The snapshot has changed, so we need to compute a new selection.
606      var nextSelection = selector(nextSnapshot); // If a custom isEqual function is provided, use that to check if the data
607      // has changed. If it hasn't, return the previous selection. That signals
608      // to React that the selections are conceptually equal, and we can bail
609      // out of rendering.
610
611      // If a custom isEqual function is provided, use that to check if the data
612      // has changed. If it hasn't, return the previous selection. That signals
613      // to React that the selections are conceptually equal, and we can bail
614      // out of rendering.
615      if (isEqual !== undefined && isEqual(prevSelection, nextSelection)) {
616        return prevSelection;
617      }
618
619      memoizedSnapshot = nextSnapshot;
620      memoizedSelection = nextSelection;
621      return nextSelection;
622    }; // Assigning this to a constant so that Flow knows it can't change.
623
624
625    // Assigning this to a constant so that Flow knows it can't change.
626    var maybeGetServerSnapshot = getServerSnapshot === undefined ? null : getServerSnapshot;
627
628    var getSnapshotWithSelector = function () {
629      return memoizedSelector(getSnapshot());
630    };
631
632    var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? undefined : function () {
633      return memoizedSelector(maybeGetServerSnapshot());
634    };
635    return [getSnapshotWithSelector, getServerSnapshotWithSelector];
636  }, [getSnapshot, getServerSnapshot, selector, isEqual]),
637      getSelection = _useMemo[0],
638      getServerSelection = _useMemo[1];
639
640  var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
641  useEffect(function () {
642    inst.hasValue = true;
643    inst.value = value;
644  }, [value]);
645  useDebugValue(value);
646  return value;
647}
648
649exports.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;
650          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
651if (
652  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
653  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
654    'function'
655) {
656  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
657}
658        
659  })();
660}
661
662
663/***/ }),
664

665/***/ "./node_modules/use-sync-external-store/with-selector.js":
666/*!***************************************************************!*\
667  !*** ./node_modules/use-sync-external-store/with-selector.js ***!
668  \***************************************************************/
669/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
670
671
672
673if (false) {} else {
674  module.exports = __webpack_require__(/*! ./cjs/use-sync-external-store-with-selector.development.js */ "./node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.development.js");
675}
676
677
678/***/ }),
679
680/***/ "react":
681/*!************************!*\
682  !*** external "React" ***!
683  \************************/
684/***/ ((module) => {
685
686module.exports = window["React"];
687
688/***/ }),
689
690/***/ "react-dom":
691/*!***************************!*\
692  !*** external "ReactDOM" ***!
693  \***************************/
694/***/ ((module) => {
695
696module.exports = window["ReactDOM"];
697
698/***/ }),
699
700/***/ "react/jsx-runtime":
701/*!**********************************!*\
702  !*** external "ReactJSXRuntime" ***!
703  \**********************************/
704/***/ ((module) => {
705
706module.exports = window["ReactJSXRuntime"];
707
708/***/ }),
709

710/***/ "./node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs":
711/*!*********************************************************************!*\
712  !*** ./node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs ***!
713  \*********************************************************************/
714/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
715
716__webpack_require__.r(__webpack_exports__);
717/* harmony export */ __webpack_require__.d(__webpack_exports__, {
718/* harmony export */   ReducerType: () => (/* binding */ ReducerType),
719/* harmony export */   SHOULD_AUTOBATCH: () => (/* binding */ SHOULD_AUTOBATCH),
720/* harmony export */   TaskAbortError: () => (/* binding */ TaskAbortError),
721/* harmony export */   Tuple: () => (/* binding */ Tuple),
722/* harmony export */   __DO_NOT_USE__ActionTypes: () => (/* reexport safe */ redux__WEBPACK_IMPORTED_MODULE_0__.__DO_NOT_USE__ActionTypes),
723/* harmony export */   addListener: () => (/* binding */ addListener),
724/* harmony export */   applyMiddleware: () => (/* reexport safe */ redux__WEBPACK_IMPORTED_MODULE_0__.applyMiddleware),
725/* harmony export */   asyncThunkCreator: () => (/* binding */ asyncThunkCreator),
726/* harmony export */   autoBatchEnhancer: () => (/* binding */ autoBatchEnhancer),
727/* harmony export */   bindActionCreators: () => (/* reexport safe */ redux__WEBPACK_IMPORTED_MODULE_0__.bindActionCreators),
728/* harmony export */   buildCreateSlice: () => (/* binding */ buildCreateSlice),
729/* harmony export */   clearAllListeners: () => (/* binding */ clearAllListeners),
730/* harmony export */   combineReducers: () => (/* reexport safe */ redux__WEBPACK_IMPORTED_MODULE_0__.combineReducers),
731/* harmony export */   combineSlices: () => (/* binding */ combineSlices),
732/* harmony export */   compose: () => (/* reexport safe */ redux__WEBPACK_IMPORTED_MODULE_0__.compose),
733/* harmony export */   configureStore: () => (/* binding */ configureStore),
734/* harmony export */   createAction: () => (/* binding */ createAction),
735/* harmony export */   createActionCreatorInvariantMiddleware: () => (/* binding */ createActionCreatorInvariantMiddleware),
736/* harmony export */   createAsyncThunk: () => (/* binding */ createAsyncThunk),
737/* harmony export */   createDraftSafeSelector: () => (/* binding */ createDraftSafeSelector),
738/* harmony export */   createDraftSafeSelectorCreator: () => (/* binding */ createDraftSafeSelectorCreator),
739/* harmony export */   createDynamicMiddleware: () => (/* binding */ createDynamicMiddleware),
740/* harmony export */   createEntityAdapter: () => (/* binding */ createEntityAdapter),
741/* harmony export */   createImmutableStateInvariantMiddleware: () => (/* binding */ createImmutableStateInvariantMiddleware),
742/* harmony export */   createListenerMiddleware: () => (/* binding */ createListenerMiddleware),
743/* harmony export */   createNextState: () => (/* reexport safe */ immer__WEBPACK_IMPORTED_MODULE_2__.produce),
744/* harmony export */   createReducer: () => (/* binding */ createReducer),
745/* harmony export */   createSelector: () => (/* reexport safe */ reselect__WEBPACK_IMPORTED_MODULE_1__.createSelector),
746/* harmony export */   createSelectorCreator: () => (/* reexport safe */ reselect__WEBPACK_IMPORTED_MODULE_1__.createSelectorCreator),
747/* harmony export */   createSerializableStateInvariantMiddleware: () => (/* binding */ createSerializableStateInvariantMiddleware),
748/* harmony export */   createSlice: () => (/* binding */ createSlice),
749/* harmony export */   createStore: () => (/* reexport safe */ redux__WEBPACK_IMPORTED_MODULE_0__.createStore),
750/* harmony export */   current: () => (/* reexport safe */ immer__WEBPACK_IMPORTED_MODULE_2__.current),
751/* harmony export */   findNonSerializableValue: () => (/* binding */ findNonSerializableValue),
752/* harmony export */   formatProdErrorMessage: () => (/* binding */ formatProdErrorMessage),
753/* harmony export */   freeze: () => (/* reexport safe */ immer__WEBPACK_IMPORTED_MODULE_2__.freeze),
754/* harmony export */   isAction: () => (/* reexport safe */ redux__WEBPACK_IMPORTED_MODULE_0__.isAction),
755/* harmony export */   isActionCreator: () => (/* binding */ isActionCreator),
756/* harmony export */   isAllOf: () => (/* binding */ isAllOf),
757/* harmony export */   isAnyOf: () => (/* binding */ isAnyOf),
758/* harmony export */   isAsyncThunkAction: () => (/* binding */ isAsyncThunkAction),
759/* harmony export */   isDraft: () => (/* reexport safe */ immer__WEBPACK_IMPORTED_MODULE_2__.isDraft),
760/* harmony export */   isFluxStandardAction: () => (/* binding */ isFSA),
761/* harmony export */   isFulfilled: () => (/* binding */ isFulfilled),
762/* harmony export */   isImmutableDefault: () => (/* binding */ isImmutableDefault),
763/* harmony export */   isPending: () => (/* binding */ isPending),
764/* harmony export */   isPlain: () => (/* binding */ isPlain),
765/* harmony export */   isPlainObject: () => (/* reexport safe */ redux__WEBPACK_IMPORTED_MODULE_0__.isPlainObject),
766/* harmony export */   isRejected: () => (/* binding */ isRejected),
767/* harmony export */   isRejectedWithValue: () => (/* binding */ isRejectedWithValue),
768/* harmony export */   legacy_createStore: () => (/* reexport safe */ redux__WEBPACK_IMPORTED_MODULE_0__.legacy_createStore),
769/* harmony export */   lruMemoize: () => (/* reexport safe */ reselect__WEBPACK_IMPORTED_MODULE_1__.lruMemoize),
770/* harmony export */   miniSerializeError: () => (/* binding */ miniSerializeError),
771/* harmony export */   nanoid: () => (/* binding */ nanoid),
772/* harmony export */   original: () => (/* reexport safe */ immer__WEBPACK_IMPORTED_MODULE_2__.original),
773/* harmony export */   prepareAutoBatched: () => (/* binding */ prepareAutoBatched),
774/* harmony export */   removeListener: () => (/* binding */ removeListener),
775/* harmony export */   unwrapResult: () => (/* binding */ unwrapResult),
776/* harmony export */   weakMapMemoize: () => (/* reexport safe */ reselect__WEBPACK_IMPORTED_MODULE_1__.weakMapMemoize)
777/* harmony export */ });
778/* harmony import */ var redux__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! redux */ "./node_modules/redux/dist/redux.mjs");
779/* harmony import */ var immer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! immer */ "./node_modules/immer/dist/immer.mjs");
780/* harmony import */ var reselect__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! reselect */ "./node_modules/reselect/dist/reselect.mjs");
781/* harmony import */ var redux_thunk__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! redux-thunk */ "./node_modules/redux-thunk/dist/redux-thunk.mjs");
782// src/index.ts
783
784
785
786
787// src/createDraftSafeSelector.ts
788
789
790var createDraftSafeSelectorCreator = (...args) => {
791  const createSelector2 = (0,reselect__WEBPACK_IMPORTED_MODULE_1__.createSelectorCreator)(...args);
792  const createDraftSafeSelector2 = Object.assign((...args2) => {
793    const selector = createSelector2(...args2);
794    const wrappedSelector = (value, ...rest) => selector((0,immer__WEBPACK_IMPORTED_MODULE_2__.isDraft)(value) ? (0,immer__WEBPACK_IMPORTED_MODULE_2__.current)(value) : value, ...rest);
795    Object.assign(wrappedSelector, selector);
796    return wrappedSelector;
797  }, {
798    withTypes: () => createDraftSafeSelector2
799  });
800  return createDraftSafeSelector2;
801};
802var createDraftSafeSelector = /* @__PURE__ */ createDraftSafeSelectorCreator(reselect__WEBPACK_IMPORTED_MODULE_1__.weakMapMemoize);
803
804// src/configureStore.ts
805
806
807// src/devtoolsExtension.ts
808
809var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
810  if (arguments.length === 0) return void 0;
811  if (typeof arguments[0] === "object") return redux__WEBPACK_IMPORTED_MODULE_0__.compose;
812  return redux__WEBPACK_IMPORTED_MODULE_0__.compose.apply(null, arguments);
813};
814var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {
815  return function(noop3) {
816    return noop3;
817  };
818};
819
820// src/getDefaultMiddleware.ts
821
822
823// src/createAction.ts
824
825
826// src/tsHelpers.ts
827var hasMatchFunction = (v) => {
828  return v && typeof v.match === "function";
829};
830
831// src/createAction.ts
832function createAction(type, prepareAction) {
833  function actionCreator(...args) {
834    if (prepareAction) {
835      let prepared = prepareAction(...args);
836      if (!prepared) {
837        throw new Error( false ? 0 : "prepareAction did not return an object");
838      }
839      return {
840        type,
841        payload: prepared.payload,
842        ..."meta" in prepared && {
843          meta: prepared.meta
844        },
845        ..."error" in prepared && {
846          error: prepared.error
847        }
848      };
849    }
850    return {
851      type,
852      payload: args[0]
853    };
854  }
855  actionCreator.toString = () => `${type}`;
856  actionCreator.type = type;
857  actionCreator.match = (action) => (0,redux__WEBPACK_IMPORTED_MODULE_0__.isAction)(action) && action.type === type;
858  return actionCreator;
859}
860function isActionCreator(action) {
861  return typeof action === "function" && "type" in action && // hasMatchFunction only wants Matchers but I don't see the point in rewriting it
862  hasMatchFunction(action);
863}
864function isFSA(action) {
865  return (0,redux__WEBPACK_IMPORTED_MODULE_0__.isAction)(action) && Object.keys(action).every(isValidKey);
866}
867function isValidKey(key) {
868  return ["type", "payload", "error", "meta"].indexOf(key) > -1;
869}
870
871// src/actionCreatorInvariantMiddleware.ts
872function getMessage(type) {
873  const splitType = type ? `${type}`.split("/") : [];
874  const actionName = splitType[splitType.length - 1] || "actionCreator";
875  return `Detected an action creator with type "${type || "unknown"}" being dispatched. 
876Make sure you're calling the action creator before dispatching, i.e. \`dispatch(${actionName}())\` instead of \`dispatch(${actionName})\`. This is necessary even if the action has no payload.`;
877}
878function createActionCreatorInvariantMiddleware(options = {}) {
879  if (false) {}
880  const {
881    isActionCreator: isActionCreator2 = isActionCreator
882  } = options;
883  return () => (next) => (action) => {
884    if (isActionCreator2(action)) {
885      console.warn(getMessage(action.type));
886    }
887    return next(action);
888  };
889}
890
891// src/utils.ts
892
893function getTimeMeasureUtils(maxDelay, fnName) {
894  let elapsed = 0;
895  return {
896    measureTime(fn) {
897      const started = Date.now();
898      try {
899        return fn();
900      } finally {
901        const finished = Date.now();
902        elapsed += finished - started;
903      }
904    },
905    warnIfExceeded() {
906      if (elapsed > maxDelay) {
907        console.warn(`${fnName} took ${elapsed}ms, which is more than the warning threshold of ${maxDelay}ms. 
908If 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.
909It is disabled in production builds, so you don't need to worry about that.`);
910      }
911    }
912  };
913}
914function find(iterable, comparator) {
915  for (const entry of iterable) {
916    if (comparator(entry)) {
917      return entry;
918    }
919  }
920  return void 0;
921}
922var Tuple = class _Tuple extends Array {
923  constructor(...items) {
924    super(...items);
925    Object.setPrototypeOf(this, _Tuple.prototype);
926  }
927  static get [Symbol.species]() {
928    return _Tuple;
929  }
930  concat(...arr) {
931    return super.concat.apply(this, arr);
932  }
933  prepend(...arr) {
934    if (arr.length === 1 && Array.isArray(arr[0])) {
935      return new _Tuple(...arr[0].concat(this));
936    }
937    return new _Tuple(...arr.concat(this));
938  }
939};
940function freezeDraftable(val) {
941  return (0,immer__WEBPACK_IMPORTED_MODULE_2__.isDraftable)(val) ? (0,immer__WEBPACK_IMPORTED_MODULE_2__.produce)(val, () => {
942  }) : val;
943}
944function emplace(map, key, handler) {
945  if (map.has(key)) {
946    let value = map.get(key);
947    if (handler.update) {
948      value = handler.update(value, key, map);
949      map.set(key, value);
950    }
951    return value;
952  }
953  if (!handler.insert) throw new Error( false ? 0 : "No insert provided for key not already in map");
954  const inserted = handler.insert(key, map);
955  map.set(key, inserted);
956  return inserted;
957}
958
959// src/immutableStateInvariantMiddleware.ts
960function isImmutableDefault(value) {
961  return typeof value !== "object" || value == null || Object.isFrozen(value);
962}
963function trackForMutations(isImmutable, ignorePaths, obj) {
964  const trackedProperties = trackProperties(isImmutable, ignorePaths, obj);
965  return {
966    detectMutations() {
967      return detectMutations(isImmutable, ignorePaths, trackedProperties, obj);
968    }
969  };
970}
971function trackProperties(isImmutable, ignorePaths = [], obj, path = "", checkedObjects = /* @__PURE__ */ new Set()) {
972  const tracked = {
973    value: obj
974  };
975  if (!isImmutable(obj) && !checkedObjects.has(obj)) {
976    checkedObjects.add(obj);
977    tracked.children = {};
978    for (const key in obj) {
979      const childPath = path ? path + "." + key : key;
980      if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) {
981        continue;
982      }
983      tracked.children[key] = trackProperties(isImmutable, ignorePaths, obj[key], childPath);
984    }
985  }
986  return tracked;
987}
988function detectMutations(isImmutable, ignoredPaths = [], trackedProperty, obj, sameParentRef = false, path = "") {
989  const prevObj = trackedProperty ? trackedProperty.value : void 0;
990  const sameRef = prevObj === obj;
991  if (sameParentRef && !sameRef && !Number.isNaN(obj)) {
992    return {
993      wasMutated: true,
994      path
995    };
996  }
997  if (isImmutable(prevObj) || isImmutable(obj)) {
998    return {
999      wasMutated: false
1000    };
1001  }
1002  const keysToDetect = {};
1003  for (let key in trackedProperty.children) {
1004    keysToDetect[key] = true;
1005  }
1006  for (let key in obj) {
1007    keysToDetect[key] = true;
1008  }
1009  const hasIgnoredPaths = ignoredPaths.length > 0;
1010  for (let key in keysToDetect) {
1011    const nestedPath = path ? path + "." + key : key;
1012    if (hasIgnoredPaths) {
1013      const hasMatches = ignoredPaths.some((ignored) => {
1014        if (ignored instanceof RegExp) {
1015          return ignored.test(nestedPath);
1016        }
1017        return nestedPath === ignored;
1018      });
1019      if (hasMatches) {
1020        continue;
1021      }
1022    }
1023    const result = detectMutations(isImmutable, ignoredPaths, trackedProperty.children[key], obj[key], sameRef, nestedPath);
1024    if (result.wasMutated) {
1025      return result;
1026    }
1027  }
1028  return {
1029    wasMutated: false
1030  };
1031}
1032function createImmutableStateInvariantMiddleware(options = {}) {
1033  if (false) {} else {
1034    let stringify2 = function(obj, serializer, indent, decycler) {
1035      return JSON.stringify(obj, getSerialize2(serializer, decycler), indent);
1036    }, getSerialize2 = function(serializer, decycler) {
1037      let stack = [], keys = [];
1038      if (!decycler) decycler = function(_, value) {
1039        if (stack[0] === value) return "[Circular ~]";
1040        return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
1041      };
1042      return function(key, value) {
1043        if (stack.length > 0) {
1044          var thisPos = stack.indexOf(this);
1045          ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
1046          ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
1047          if (~stack.indexOf(value)) value = decycler.call(this, key, value);
1048        } else stack.push(value);
1049        return serializer == null ? value : serializer.call(this, key, value);
1050      };
1051    };
1052    var stringify = stringify2, getSerialize = getSerialize2;
1053    let {
1054      isImmutable = isImmutableDefault,
1055      ignoredPaths,
1056      warnAfter = 32
1057    } = options;
1058    const track = trackForMutations.bind(null, isImmutable, ignoredPaths);
1059    return ({
1060      getState
1061    }) => {
1062      let state = getState();
1063      let tracker = track(state);
1064      let result;
1065      return (next) => (action) => {
1066        const measureUtils = getTimeMeasureUtils(warnAfter, "ImmutableStateInvariantMiddleware");
1067        measureUtils.measureTime(() => {
1068          state = getState();
1069          result = tracker.detectMutations();
1070          tracker = track(state);
1071          if (result.wasMutated) {
1072            throw new Error( false ? 0 : `A state mutation was detected between dispatches, in the path '${result.path || ""}'.  This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);
1073          }
1074        });
1075        const dispatchedAction = next(action);
1076        measureUtils.measureTime(() => {
1077          state = getState();
1078          result = tracker.detectMutations();
1079          tracker = track(state);
1080          if (result.wasMutated) {
1081            throw new Error( false ? 0 : `A state mutation was detected inside a dispatch, in the path: ${result.path || ""}. Take a look at the reducer(s) handling the action ${stringify2(action)}. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);
1082          }
1083        });
1084        measureUtils.warnIfExceeded();
1085        return dispatchedAction;
1086      };
1087    };
1088  }
1089}
1090
1091// src/serializableStateInvariantMiddleware.ts
1092
1093function isPlain(val) {
1094  const type = typeof val;
1095  return val == null || type === "string" || type === "boolean" || type === "number" || Array.isArray(val) || (0,redux__WEBPACK_IMPORTED_MODULE_0__.isPlainObject)(val);
1096}
1097function findNonSerializableValue(value, path = "", isSerializable = isPlain, getEntries, ignoredPaths = [], cache) {
1098  let foundNestedSerializable;
1099  if (!isSerializable(value)) {
1100    return {
1101      keyPath: path || "<root>",
1102      value
1103    };
1104  }
1105  if (typeof value !== "object" || value === null) {
1106    return false;
1107  }
1108  if (cache?.has(value)) return false;
1109  const entries = getEntries != null ? getEntries(value) : Object.entries(value);
1110  const hasIgnoredPaths = ignoredPaths.length > 0;
1111  for (const [key, nestedValue] of entries) {
1112    const nestedPath = path ? path + "." + key : key;
1113    if (hasIgnoredPaths) {
1114      const hasMatches = ignoredPaths.some((ignored) => {
1115        if (ignored instanceof RegExp) {
1116          return ignored.test(nestedPath);
1117        }
1118        return nestedPath === ignored;
1119      });
1120      if (hasMatches) {
1121        continue;
1122      }
1123    }
1124    if (!isSerializable(nestedValue)) {
1125      return {
1126        keyPath: nestedPath,
1127        value: nestedValue
1128      };
1129    }
1130    if (typeof nestedValue === "object") {
1131      foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries, ignoredPaths, cache);
1132      if (foundNestedSerializable) {
1133        return foundNestedSerializable;
1134      }
1135    }
1136  }
1137  if (cache && isNestedFrozen(value)) cache.add(value);
1138  return false;
1139}
1140function isNestedFrozen(value) {
1141  if (!Object.isFrozen(value)) return false;
1142  for (const nestedValue of Object.values(value)) {
1143    if (typeof nestedValue !== "object" || nestedValue === null) continue;
1144    if (!isNestedFrozen(nestedValue)) return false;
1145  }
1146  return true;
1147}
1148function createSerializableStateInvariantMiddleware(options = {}) {
1149  if (false) {} else {
1150    const {
1151      isSerializable = isPlain,
1152      getEntries,
1153      ignoredActions = [],
1154      ignoredActionPaths = ["meta.arg", "meta.baseQueryMeta"],
1155      ignoredPaths = [],
1156      warnAfter = 32,
1157      ignoreState = false,
1158      ignoreActions = false,
1159      disableCache = false
1160    } = options;
1161    const cache = !disableCache && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0;
1162    return (storeAPI) => (next) => (action) => {
1163      if (!(0,redux__WEBPACK_IMPORTED_MODULE_0__.isAction)(action)) {
1164        return next(action);
1165      }
1166      const result = next(action);
1167      const measureUtils = getTimeMeasureUtils(warnAfter, "SerializableStateInvariantMiddleware");
1168      if (!ignoreActions && !(ignoredActions.length && ignoredActions.indexOf(action.type) !== -1)) {
1169        measureUtils.measureTime(() => {
1170          const foundActionNonSerializableValue = findNonSerializableValue(action, "", isSerializable, getEntries, ignoredActionPaths, cache);
1171          if (foundActionNonSerializableValue) {
1172            const {
1173              keyPath,
1174              value
1175            } = foundActionNonSerializableValue;
1176            console.error(`A non-serializable value was detected in an action, in the path: \`${keyPath}\`. Value:`, value, "\nTake a look at the logic that dispatched this action: ", action, "\n(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)", "\n(To allow non-serializable values see: https://redux-toolkit.js.org/usage/usage-guide#working-with-non-serializable-data)");
1177          }
1178        });
1179      }
1180      if (!ignoreState) {
1181        measureUtils.measureTime(() => {
1182          const state = storeAPI.getState();
1183          const foundStateNonSerializableValue = findNonSerializableValue(state, "", isSerializable, getEntries, ignoredPaths, cache);
1184          if (foundStateNonSerializableValue) {
1185            const {
1186              keyPath,
1187              value
1188            } = foundStateNonSerializableValue;
1189            console.error(`A non-serializable value was detected in the state, in the path: \`${keyPath}\`. Value:`, value, `
1190Take a look at the reducer(s) handling this action type: ${action.type}.
1191(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)`);
1192          }
1193        });
1194        measureUtils.warnIfExceeded();
1195      }
1196      return result;
1197    };
1198  }
1199}
1200
1201// src/getDefaultMiddleware.ts
1202function isBoolean(x) {
1203  return typeof x === "boolean";
1204}
1205var buildGetDefaultMiddleware = () => function getDefaultMiddleware(options) {
1206  const {
1207    thunk = true,
1208    immutableCheck = true,
1209    serializableCheck = true,
1210    actionCreatorCheck = true
1211  } = options ?? {};
1212  let middlewareArray = new Tuple();
1213  if (thunk) {
1214    if (isBoolean(thunk)) {
1215      middlewareArray.push(redux_thunk__WEBPACK_IMPORTED_MODULE_3__.thunk);
1216    } else {
1217      middlewareArray.push((0,redux_thunk__WEBPACK_IMPORTED_MODULE_3__.withExtraArgument)(thunk.extraArgument));
1218    }
1219  }
1220  if (true) {
1221    if (immutableCheck) {
1222      let immutableOptions = {};
1223      if (!isBoolean(immutableCheck)) {
1224        immutableOptions = immutableCheck;
1225      }
1226      middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions));
1227    }
1228    if (serializableCheck) {
1229      let serializableOptions = {};
1230      if (!isBoolean(serializableCheck)) {
1231        serializableOptions = serializableCheck;
1232      }
1233      middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions));
1234    }
1235    if (actionCreatorCheck) {
1236      let actionCreatorOptions = {};
1237      if (!isBoolean(actionCreatorCheck)) {
1238        actionCreatorOptions = actionCreatorCheck;
1239      }
1240      middlewareArray.unshift(createActionCreatorInvariantMiddleware(actionCreatorOptions));
1241    }
1242  }
1243  return middlewareArray;
1244};
1245
1246// src/autoBatchEnhancer.ts
1247var SHOULD_AUTOBATCH = "RTK_autoBatch";
1248var prepareAutoBatched = () => (payload) => ({
1249  payload,
1250  meta: {
1251    [SHOULD_AUTOBATCH]: true
1252  }
1253});
1254var createQueueWithTimer = (timeout) => {
1255  return (notify) => {
1256    setTimeout(notify, timeout);
1257  };
1258};
1259var rAF = typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10);
1260var autoBatchEnhancer = (options = {
1261  type: "raf"
1262}) => (next) => (...args) => {
1263  const store = next(...args);
1264  let notifying = true;
1265  let shouldNotifyAtEndOfTick = false;
1266  let notificationQueued = false;
1267  const listeners = /* @__PURE__ */ new Set();
1268  const queueCallback = options.type === "tick" ? queueMicrotask : options.type === "raf" ? rAF : options.type === "callback" ? options.queueNotification : createQueueWithTimer(options.timeout);
1269  const notifyListeners = () => {
1270    notificationQueued = false;
1271    if (shouldNotifyAtEndOfTick) {
1272      shouldNotifyAtEndOfTick = false;
1273      listeners.forEach((l) => l());
1274    }
1275  };
1276  return Object.assign({}, store, {
1277    // Override the base `store.subscribe` method to keep original listeners
1278    // from running if we're delaying notifications
1279    subscribe(listener2) {
1280      const wrappedListener = () => notifying && listener2();
1281      const unsubscribe = store.subscribe(wrappedListener);
1282      listeners.add(listener2);
1283      return () => {
1284        unsubscribe();
1285        listeners.delete(listener2);
1286      };
1287    },
1288    // Override the base `store.dispatch` method so that we can check actions
1289    // for the `shouldAutoBatch` flag and determine if batching is active
1290    dispatch(action) {
1291      try {
1292        notifying = !action?.meta?.[SHOULD_AUTOBATCH];
1293        shouldNotifyAtEndOfTick = !notifying;
1294        if (shouldNotifyAtEndOfTick) {
1295          if (!notificationQueued) {
1296            notificationQueued = true;
1297            queueCallback(notifyListeners);
1298          }
1299        }
1300        return store.dispatch(action);
1301      } finally {
1302        notifying = true;
1303      }
1304    }
1305  });
1306};
1307
1308// src/getDefaultEnhancers.ts
1309var buildGetDefaultEnhancers = (middlewareEnhancer) => function getDefaultEnhancers(options) {
1310  const {
1311    autoBatch = true
1312  } = options ?? {};
1313  let enhancerArray = new Tuple(middlewareEnhancer);
1314  if (autoBatch) {
1315    enhancerArray.push(autoBatchEnhancer(typeof autoBatch === "object" ? autoBatch : void 0));
1316  }
1317  return enhancerArray;
1318};
1319
1320// src/configureStore.ts
1321function configureStore(options) {
1322  const getDefaultMiddleware = buildGetDefaultMiddleware();
1323  const {
1324    reducer = void 0,
1325    middleware,
1326    devTools = true,
1327    preloadedState = void 0,
1328    enhancers = void 0
1329  } = options || {};
1330  let rootReducer;
1331  if (typeof reducer === "function") {
1332    rootReducer = reducer;
1333  } else if ((0,redux__WEBPACK_IMPORTED_MODULE_0__.isPlainObject)(reducer)) {
1334    rootReducer = (0,redux__WEBPACK_IMPORTED_MODULE_0__.combineReducers)(reducer);
1335  } else {
1336    throw new Error( false ? 0 : "`reducer` is a required argument, and must be a function or an object of functions that can be passed to combineReducers");
1337  }
1338  if ( true && middleware && typeof middleware !== "function") {
1339    throw new Error( false ? 0 : "`middleware` field must be a callback");
1340  }
1341  let finalMiddleware;
1342  if (typeof middleware === "function") {
1343    finalMiddleware = middleware(getDefaultMiddleware);
1344    if ( true && !Array.isArray(finalMiddleware)) {
1345      throw new Error( false ? 0 : "when using a middleware builder function, an array of middleware must be returned");
1346    }
1347  } else {
1348    finalMiddleware = getDefaultMiddleware();
1349  }
1350  if ( true && finalMiddleware.some((item) => typeof item !== "function")) {
1351    throw new Error( false ? 0 : "each middleware provided to configureStore must be a function");
1352  }
1353  let finalCompose = redux__WEBPACK_IMPORTED_MODULE_0__.compose;
1354  if (devTools) {
1355    finalCompose = composeWithDevTools({
1356      // Enable capture of stack traces for dispatched Redux actions
1357      trace: "development" !== "production",
1358      ...typeof devTools === "object" && devTools
1359    });
1360  }
1361  const middlewareEnhancer = (0,redux__WEBPACK_IMPORTED_MODULE_0__.applyMiddleware)(...finalMiddleware);
1362  const getDefaultEnhancers = buildGetDefaultEnhancers(middlewareEnhancer);
1363  if ( true && enhancers && typeof enhancers !== "function") {
1364    throw new Error( false ? 0 : "`enhancers` field must be a callback");
1365  }
1366  let storeEnhancers = typeof enhancers === "function" ? enhancers(getDefaultEnhancers) : getDefaultEnhancers();
1367  if ( true && !Array.isArray(storeEnhancers)) {
1368    throw new Error( false ? 0 : "`enhancers` callback must return an array");
1369  }
1370  if ( true && storeEnhancers.some((item) => typeof item !== "function")) {
1371    throw new Error( false ? 0 : "each enhancer provided to configureStore must be a function");
1372  }
1373  if ( true && finalMiddleware.length && !storeEnhancers.includes(middlewareEnhancer)) {
1374    console.error("middlewares were provided, but middleware enhancer was not included in final enhancers - make sure to call `getDefaultEnhancers`");
1375  }
1376  const composedEnhancer = finalCompose(...storeEnhancers);
1377  return (0,redux__WEBPACK_IMPORTED_MODULE_0__.createStore)(rootReducer, preloadedState, composedEnhancer);
1378}
1379
1380// src/createReducer.ts
1381
1382
1383// src/mapBuilders.ts
1384function executeReducerBuilderCallback(builderCallback) {
1385  const actionsMap = {};
1386  const actionMatchers = [];
1387  let defaultCaseReducer;
1388  const builder = {
1389    addCase(typeOrActionCreator, reducer) {
1390      if (true) {
1391        if (actionMatchers.length > 0) {
1392          throw new Error( false ? 0 : "`builder.addCase` should only be called before calling `builder.addMatcher`");
1393        }
1394        if (defaultCaseReducer) {
1395          throw new Error( false ? 0 : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
1396        }
1397      }
1398      const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
1399      if (!type) {
1400        throw new Error( false ? 0 : "`builder.addCase` cannot be called with an empty action type");
1401      }
1402      if (type in actionsMap) {
1403        throw new Error( false ? 0 : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
1404      }
1405      actionsMap[type] = reducer;
1406      return builder;
1407    },
1408    addMatcher(matcher, reducer) {
1409      if (true) {
1410        if (defaultCaseReducer) {
1411          throw new Error( false ? 0 : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
1412        }
1413      }
1414      actionMatchers.push({
1415        matcher,
1416        reducer
1417      });
1418      return builder;
1419    },
1420    addDefaultCase(reducer) {
1421      if (true) {
1422        if (defaultCaseReducer) {
1423          throw new Error( false ? 0 : "`builder.addDefaultCase` can only be called once");
1424        }
1425      }
1426      defaultCaseReducer = reducer;
1427      return builder;
1428    }
1429  };
1430  builderCallback(builder);
1431  return [actionsMap, actionMatchers, defaultCaseReducer];
1432}
1433
1434// src/createReducer.ts
1435function isStateFunction(x) {
1436  return typeof x === "function";
1437}
1438function createReducer(initialState, mapOrBuilderCallback) {
1439  if (true) {
1440    if (typeof mapOrBuilderCallback === "object") {
1441      throw new Error( false ? 0 : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
1442    }
1443  }
1444  let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
1445  let getInitialState;
1446  if (isStateFunction(initialState)) {
1447    getInitialState = () => freezeDraftable(initialState());
1448  } else {
1449    const frozenInitialState = freezeDraftable(initialState);
1450    getInitialState = () => frozenInitialState;
1451  }
1452  function reducer(state = getInitialState(), action) {
1453    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
1454      matcher
1455    }) => matcher(action)).map(({
1456      reducer: reducer2
1457    }) => reducer2)];
1458    if (caseReducers.filter((cr) => !!cr).length === 0) {
1459      caseReducers = [finalDefaultCaseReducer];
1460    }
1461    return caseReducers.reduce((previousState, caseReducer) => {
1462      if (caseReducer) {
1463        if ((0,immer__WEBPACK_IMPORTED_MODULE_2__.isDraft)(previousState)) {
1464          const draft = previousState;
1465          const result = caseReducer(draft, action);
1466          if (result === void 0) {
1467            return previousState;
1468          }
1469          return result;
1470        } else if (!(0,immer__WEBPACK_IMPORTED_MODULE_2__.isDraftable)(previousState)) {
1471          const result = caseReducer(previousState, action);
1472          if (result === void 0) {
1473            if (previousState === null) {
1474              return previousState;
1475            }
1476            throw new Error( false ? 0 : "A case reducer on a non-draftable value must not return undefined");
1477          }
1478          return result;
1479        } else {
1480          return (0,immer__WEBPACK_IMPORTED_MODULE_2__.produce)(previousState, (draft) => {
1481            return caseReducer(draft, action);
1482          });
1483        }
1484      }
1485      return previousState;
1486    }, state);
1487  }
1488  reducer.getInitialState = getInitialState;
1489  return reducer;
1490}
1491
1492// src/matchers.ts
1493var matches = (matcher, action) => {
1494  if (hasMatchFunction(matcher)) {
1495    return matcher.match(action);
1496  } else {
1497    return matcher(action);
1498  }
1499};
1500function isAnyOf(...matchers) {
1501  return (action) => {
1502    return matchers.some((matcher) => matches(matcher, action));
1503  };
1504}
1505function isAllOf(...matchers) {
1506  return (action) => {
1507    return matchers.every((matcher) => matches(matcher, action));
1508  };
1509}
1510function hasExpectedRequestMetadata(action, validStatus) {
1511  if (!action || !action.meta) return false;
1512  const hasValidRequestId = typeof action.meta.requestId === "string";
1513  const hasValidRequestStatus = validStatus.indexOf(action.meta.requestStatus) > -1;
1514  return hasValidRequestId && hasValidRequestStatus;
1515}
1516function isAsyncThunkArray(a) {
1517  return typeof a[0] === "function" && "pending" in a[0] && "fulfilled" in a[0] && "rejected" in a[0];
1518}
1519function isPending(...asyncThunks) {
1520  if (asyncThunks.length === 0) {
1521    return (action) => hasExpectedRequestMetadata(action, ["pending"]);
1522  }
1523  if (!isAsyncThunkArray(asyncThunks)) {
1524    return isPending()(asyncThunks[0]);
1525  }
1526  return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.pending));
1527}
1528function isRejected(...asyncThunks) {
1529  if (asyncThunks.length === 0) {
1530    return (action) => hasExpectedRequestMetadata(action, ["rejected"]);
1531  }
1532  if (!isAsyncThunkArray(asyncThunks)) {
1533    return isRejected()(asyncThunks[0]);
1534  }
1535  return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.rejected));
1536}
1537function isRejectedWithValue(...asyncThunks) {
1538  const hasFlag = (action) => {
1539    return action && action.meta && action.meta.rejectedWithValue;
1540  };
1541  if (asyncThunks.length === 0) {
1542    return isAllOf(isRejected(...asyncThunks), hasFlag);
1543  }
1544  if (!isAsyncThunkArray(asyncThunks)) {
1545    return isRejectedWithValue()(asyncThunks[0]);
1546  }
1547  return isAllOf(isRejected(...asyncThunks), hasFlag);
1548}
1549function isFulfilled(...asyncThunks) {
1550  if (asyncThunks.length === 0) {
1551    return (action) => hasExpectedRequestMetadata(action, ["fulfilled"]);
1552  }
1553  if (!isAsyncThunkArray(asyncThunks)) {
1554    return isFulfilled()(asyncThunks[0]);
1555  }
1556  return isAnyOf(...asyncThunks.map((asyncThunk) => asyncThunk.fulfilled));
1557}
1558function isAsyncThunkAction(...asyncThunks) {
1559  if (asyncThunks.length === 0) {
1560    return (action) => hasExpectedRequestMetadata(action, ["pending", "fulfilled", "rejected"]);
1561  }
1562  if (!isAsyncThunkArray(asyncThunks)) {
1563    return isAsyncThunkAction()(asyncThunks[0]);
1564  }
1565  return isAnyOf(...asyncThunks.flatMap((asyncThunk) => [asyncThunk.pending, asyncThunk.rejected, asyncThunk.fulfilled]));
1566}
1567
1568// src/nanoid.ts
1569var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
1570var nanoid = (size = 21) => {
1571  let id = "";
1572  let i = size;
1573  while (i--) {
1574    id += urlAlphabet[Math.random() * 64 | 0];
1575  }
1576  return id;
1577};
1578
1579// src/createAsyncThunk.ts
1580var commonProperties = ["name", "message", "stack", "code"];
1581var RejectWithValue = class {
1582  constructor(payload, meta) {
1583    this.payload = payload;
1584    this.meta = meta;
1585  }
1586  /*
1587  type-only property to distinguish between RejectWithValue and FulfillWithMeta
1588  does not exist at runtime
1589  */
1590  _type;
1591};
1592var FulfillWithMeta = class {
1593  constructor(payload, meta) {
1594    this.payload = payload;
1595    this.meta = meta;
1596  }
1597  /*
1598  type-only property to distinguish between RejectWithValue and FulfillWithMeta
1599  does not exist at runtime
1600  */
1601  _type;
1602};
1603var miniSerializeError = (value) => {
1604  if (typeof value === "object" && value !== null) {
1605    const simpleError = {};
1606    for (const property of commonProperties) {
1607      if (typeof value[property] === "string") {
1608        simpleError[property] = value[property];
1609      }
1610    }
1611    return simpleError;
1612  }
1613  return {
1614    message: String(value)
1615  };
1616};
1617var createAsyncThunk = /* @__PURE__ */ (() => {
1618  function createAsyncThunk2(typePrefix, payloadCreator, options) {
1619    const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
1620      payload,
1621      meta: {
1622        ...meta || {},
1623        arg,
1624        requestId,
1625        requestStatus: "fulfilled"
1626      }
1627    }));
1628    const pending = createAction(typePrefix + "/pending", (requestId, arg, meta) => ({
1629      payload: void 0,
1630      meta: {
1631        ...meta || {},
1632        arg,
1633        requestId,
1634        requestStatus: "pending"
1635      }
1636    }));
1637    const rejected = createAction(typePrefix + "/rejected", (error, requestId, arg, payload, meta) => ({
1638      payload,
1639      error: (options && options.serializeError || miniSerializeError)(error || "Rejected"),
1640      meta: {
1641        ...meta || {},
1642        arg,
1643        requestId,
1644        rejectedWithValue: !!payload,
1645        requestStatus: "rejected",
1646        aborted: error?.name === "AbortError",
1647        condition: error?.name === "ConditionError"
1648      }
1649    }));
1650    function actionCreator(arg) {
1651      return (dispatch, getState, extra) => {
1652        const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
1653        const abortController = new AbortController();
1654        let abortHandler;
1655        let abortReason;
1656        function abort(reason) {
1657          abortReason = reason;
1658          abortController.abort();
1659        }
1660        const promise = async function() {
1661          let finalAction;
1662          try {
1663            let conditionResult = options?.condition?.(arg, {
1664              getState,
1665              extra
1666            });
1667            if (isThenable(conditionResult)) {
1668              conditionResult = await conditionResult;
1669            }
1670            if (conditionResult === false || abortController.signal.aborted) {
1671              throw {
1672                name: "ConditionError",
1673                message: "Aborted due to condition callback returning false."
1674              };
1675            }
1676            const abortedPromise = new Promise((_, reject) => {
1677              abortHandler = () => {
1678                reject({
1679                  name: "AbortError",
1680                  message: abortReason || "Aborted"
1681                });
1682              };
1683              abortController.signal.addEventListener("abort", abortHandler);
1684            });
1685            dispatch(pending(requestId, arg, options?.getPendingMeta?.({
1686              requestId,
1687              arg
1688            }, {
1689              getState,
1690              extra
1691            })));
1692            finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {
1693              dispatch,
1694              getState,
1695              extra,
1696              requestId,
1697              signal: abortController.signal,
1698              abort,
1699              rejectWithValue: (value, meta) => {
1700                return new RejectWithValue(value, meta);
1701              },
1702              fulfillWithValue: (value, meta) => {
1703                return new FulfillWithMeta(value, meta);
1704              }
1705            })).then((result) => {
1706              if (result instanceof RejectWithValue) {
1707                throw result;
1708              }
1709              if (result instanceof FulfillWithMeta) {
1710                return fulfilled(result.payload, requestId, arg, result.meta);
1711              }
1712              return fulfilled(result, requestId, arg);
1713            })]);
1714          } catch (err) {
1715            finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
1716          } finally {
1717            if (abortHandler) {
1718              abortController.signal.removeEventListener("abort", abortHandler);
1719            }
1720          }
1721          const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
1722          if (!skipDispatch) {
1723            dispatch(finalAction);
1724          }
1725          return finalAction;
1726        }();
1727        return Object.assign(promise, {
1728          abort,
1729          requestId,
1730          arg,
1731          unwrap() {
1732            return promise.then(unwrapResult);
1733          }
1734        });
1735      };
1736    }
1737    return Object.assign(actionCreator, {
1738      pending,
1739      rejected,
1740      fulfilled,
1741      settled: isAnyOf(rejected, fulfilled),
1742      typePrefix
1743    });
1744  }
1745  createAsyncThunk2.withTypes = () => createAsyncThunk2;
1746  return createAsyncThunk2;
1747})();
1748function unwrapResult(action) {
1749  if (action.meta && action.meta.rejectedWithValue) {
1750    throw action.payload;
1751  }
1752  if (action.error) {
1753    throw action.error;
1754  }
1755  return action.payload;
1756}
1757function isThenable(value) {
1758  return value !== null && typeof value === "object" && typeof value.then === "function";
1759}
1760
1761// src/createSlice.ts
1762var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
1763var asyncThunkCreator = {
1764  [asyncThunkSymbol]: createAsyncThunk
1765};
1766var ReducerType = /* @__PURE__ */ ((ReducerType2) => {
1767  ReducerType2["reducer"] = "reducer";
1768  ReducerType2["reducerWithPrepare"] = "reducerWithPrepare";
1769  ReducerType2["asyncThunk"] = "asyncThunk";
1770  return ReducerType2;
1771})(ReducerType || {});
1772function getType(slice, actionKey) {
1773  return `${slice}/${actionKey}`;
1774}
1775function buildCreateSlice({
1776  creators
1777} = {}) {
1778  const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
1779  return function createSlice2(options) {
1780    const {
1781      name,
1782      reducerPath = name
1783    } = options;
1784    if (!name) {
1785      throw new Error( false ? 0 : "`name` is a required option for createSlice");
1786    }
1787    if (typeof process !== "undefined" && "development" === "development") {
1788      if (options.initialState === void 0) {
1789        console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
1790      }
1791    }
1792    const reducers = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
1793    const reducerNames = Object.keys(reducers);
1794    const context = {
1795      sliceCaseReducersByName: {},
1796      sliceCaseReducersByType: {},
1797      actionCreators: {},
1798      sliceMatchers: []
1799    };
1800    const contextMethods = {
1801      addCase(typeOrActionCreator, reducer2) {
1802        const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
1803        if (!type) {
1804          throw new Error( false ? 0 : "`context.addCase` cannot be called with an empty action type");
1805        }
1806        if (type in context.sliceCaseReducersByType) {
1807          throw new Error( false ? 0 : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
1808        }
1809        context.sliceCaseReducersByType[type] = reducer2;
1810        return contextMethods;
1811      },
1812      addMatcher(matcher, reducer2) {
1813        context.sliceMatchers.push({
1814          matcher,
1815          reducer: reducer2
1816        });
1817        return contextMethods;
1818      },
1819      exposeAction(name2, actionCreator) {
1820        context.actionCreators[name2] = actionCreator;
1821        return contextMethods;
1822      },
1823      exposeCaseReducer(name2, reducer2) {
1824        context.sliceCaseReducersByName[name2] = reducer2;
1825        return contextMethods;
1826      }
1827    };
1828    reducerNames.forEach((reducerName) => {
1829      const reducerDefinition = reducers[reducerName];
1830      const reducerDetails = {
1831        reducerName,
1832        type: getType(name, reducerName),
1833        createNotation: typeof options.reducers === "function"
1834      };
1835      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
1836        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
1837      } else {
1838        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
1839      }
1840    });
1841    function buildReducer() {
1842      if (true) {
1843        if (typeof options.extraReducers === "object") {
1844          throw new Error( false ? 0 : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
1845        }
1846      }
1847      const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
1848      const finalCaseReducers = {
1849        ...extraReducers,
1850        ...context.sliceCaseReducersByType
1851      };
1852      return createReducer(options.initialState, (builder) => {
1853        for (let key in finalCaseReducers) {
1854          builder.addCase(key, finalCaseReducers[key]);
1855        }
1856        for (let sM of context.sliceMatchers) {
1857          builder.addMatcher(sM.matcher, sM.reducer);
1858        }
1859        for (let m of actionMatchers) {
1860          builder.addMatcher(m.matcher, m.reducer);
1861        }
1862        if (defaultCaseReducer) {
1863          builder.addDefaultCase(defaultCaseReducer);
1864        }
1865      });
1866    }
1867    const selectSelf = (state) => state;
1868    const injectedSelectorCache = /* @__PURE__ */ new Map();
1869    let _reducer;
1870    function reducer(state, action) {
1871      if (!_reducer) _reducer = buildReducer();
1872      return _reducer(state, action);
1873    }
1874    function getInitialState() {
1875      if (!_reducer) _reducer = buildReducer();
1876      return _reducer.getInitialState();
1877    }
1878    function makeSelectorProps(reducerPath2, injected = false) {
1879      function selectSlice(state) {
1880        let sliceState = state[reducerPath2];
1881        if (typeof sliceState === "undefined") {
1882          if (injected) {
1883            sliceState = getInitialState();
1884          } else if (true) {
1885            throw new Error( false ? 0 : "selectSlice returned undefined for an uninjected slice reducer");
1886          }
1887        }
1888        return sliceState;
1889      }
1890      function getSelectors(selectState = selectSelf) {
1891        const selectorCache = emplace(injectedSelectorCache, injected, {
1892          insert: () => /* @__PURE__ */ new WeakMap()
1893        });
1894        return emplace(selectorCache, selectState, {
1895          insert: () => {
1896            const map = {};
1897            for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
1898              map[name2] = wrapSelector(selector, selectState, getInitialState, injected);
1899            }
1900            return map;
1901          }
1902        });
1903      }
1904      return {
1905        reducerPath: reducerPath2,
1906        getSelectors,
1907        get selectors() {
1908          return getSelectors(selectSlice);
1909        },
1910        selectSlice
1911      };
1912    }
1913    const slice = {
1914      name,
1915      reducer,
1916      actions: context.actionCreators,
1917      caseReducers: context.sliceCaseReducersByName,
1918      getInitialState,
1919      ...makeSelectorProps(reducerPath),
1920      injectInto(injectable, {
1921        reducerPath: pathOpt,
1922        ...config
1923      } = {}) {
1924        const newReducerPath = pathOpt ?? reducerPath;
1925        injectable.inject({
1926          reducerPath: newReducerPath,
1927          reducer
1928        }, config);
1929        return {
1930          ...slice,
1931          ...makeSelectorProps(newReducerPath, true)
1932        };
1933      }
1934    };
1935    return slice;
1936  };
1937}
1938function wrapSelector(selector, selectState, getInitialState, injected) {
1939  function wrapper(rootState, ...args) {
1940    let sliceState = selectState(rootState);
1941    if (typeof sliceState === "undefined") {
1942      if (injected) {
1943        sliceState = getInitialState();
1944      } else if (true) {
1945        throw new Error( false ? 0 : "selectState returned undefined for an uninjected slice reducer");
1946      }
1947    }
1948    return selector(sliceState, ...args);
1949  }
1950  wrapper.unwrapped = selector;
1951  return wrapper;
1952}
1953var createSlice = /* @__PURE__ */ buildCreateSlice();
1954function buildReducerCreators() {
1955  function asyncThunk(payloadCreator, config) {
1956    return {
1957      _reducerDefinitionType: "asyncThunk" /* asyncThunk */,
1958      payloadCreator,
1959      ...config
1960    };
1961  }
1962  asyncThunk.withTypes = () => asyncThunk;
1963  return {
1964    reducer(caseReducer) {
1965      return Object.assign({
1966        // hack so the wrapping function has the same name as the original
1967        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
1968        [caseReducer.name](...args) {
1969          return caseReducer(...args);
1970        }
1971      }[caseReducer.name], {
1972        _reducerDefinitionType: "reducer" /* reducer */
1973      });
1974    },
1975    preparedReducer(prepare, reducer) {
1976      return {
1977        _reducerDefinitionType: "reducerWithPrepare" /* reducerWithPrepare */,
1978        prepare,
1979        reducer
1980      };
1981    },
1982    asyncThunk
1983  };
1984}
1985function handleNormalReducerDefinition({
1986  type,
1987  reducerName,
1988  createNotation
1989}, maybeReducerWithPrepare, context) {
1990  let caseReducer;
1991  let prepareCallback;
1992  if ("reducer" in maybeReducerWithPrepare) {
1993    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
1994      throw new Error( false ? 0 : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
1995    }
1996    caseReducer = maybeReducerWithPrepare.reducer;
1997    prepareCallback = maybeReducerWithPrepare.prepare;
1998  } else {
1999    caseReducer = maybeReducerWithPrepare;
2000  }
2001  context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
2002}
2003function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
2004  return reducerDefinition._reducerDefinitionType === "asyncThunk" /* asyncThunk */;
2005}
2006function isCaseReducerWithPrepareDefinition(reducerDefinition) {
2007  return reducerDefinition._reducerDefinitionType === "reducerWithPrepare" /* reducerWithPrepare */;
2008}
2009function handleThunkCaseReducerDefinition({
2010  type,
2011  reducerName
2012}, reducerDefinition, context, cAT) {
2013  if (!cAT) {
2014    throw new Error( false ? 0 : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
2015  }
2016  const {
2017    payloadCreator,
2018    fulfilled,
2019    pending,
2020    rejected,
2021    settled,
2022    options
2023  } = reducerDefinition;
2024  const thunk = cAT(type, payloadCreator, options);
2025  context.exposeAction(reducerName, thunk);
2026  if (fulfilled) {
2027    context.addCase(thunk.fulfilled, fulfilled);
2028  }
2029  if (pending) {
2030    context.addCase(thunk.pending, pending);
2031  }
2032  if (rejected) {
2033    context.addCase(thunk.rejected, rejected);
2034  }
2035  if (settled) {
2036    context.addMatcher(thunk.settled, settled);
2037  }
2038  context.exposeCaseReducer(reducerName, {
2039    fulfilled: fulfilled || noop,
2040    pending: pending || noop,
2041    rejected: rejected || noop,
2042    settled: settled || noop
2043  });
2044}
2045function noop() {
2046}
2047
2048// src/entities/entity_state.ts
2049function getInitialEntityState() {
2050  return {
2051    ids: [],
2052    entities: {}
2053  };
2054}
2055function createInitialStateFactory(stateAdapter) {
2056  function getInitialState(additionalState = {}, entities) {
2057    const state = Object.assign(getInitialEntityState(), additionalState);
2058    return entities ? stateAdapter.setAll(state, entities) : state;
2059  }
2060  return {
2061    getInitialState
2062  };
2063}
2064
2065// src/entities/state_selectors.ts
2066function createSelectorsFactory() {
2067  function getSelectors(selectState, options = {}) {
2068    const {
2069      createSelector: createSelector2 = createDraftSafeSelector
2070    } = options;
2071    const selectIds = (state) => state.ids;
2072    const selectEntities = (state) => state.entities;
2073    const selectAll = createSelector2(selectIds, selectEntities, (ids, entities) => ids.map((id) => entities[id]));
2074    const selectId = (_, id) => id;
2075    const selectById = (entities, id) => entities[id];
2076    const selectTotal = createSelector2(selectIds, (ids) => ids.length);
2077    if (!selectState) {
2078      return {
2079        selectIds,
2080        selectEntities,
2081        selectAll,
2082        selectTotal,
2083        selectById: createSelector2(selectEntities, selectId, selectById)
2084      };
2085    }
2086    const selectGlobalizedEntities = createSelector2(selectState, selectEntities);
2087    return {
2088      selectIds: createSelector2(selectState, selectIds),
2089      selectEntities: selectGlobalizedEntities,
2090      selectAll: createSelector2(selectState, selectAll),
2091      selectTotal: createSelector2(selectState, selectTotal),
2092      selectById: createSelector2(selectGlobalizedEntities, selectId, selectById)
2093    };
2094  }
2095  return {
2096    getSelectors
2097  };
2098}
2099
2100// src/entities/state_adapter.ts
2101
2102var isDraftTyped = immer__WEBPACK_IMPORTED_MODULE_2__.isDraft;
2103function createSingleArgumentStateOperator(mutator) {
2104  const operator = createStateOperator((_, state) => mutator(state));
2105  return function operation(state) {
2106    return operator(state, void 0);
2107  };
2108}
2109function createStateOperator(mutator) {
2110  return function operation(state, arg) {
2111    function isPayloadActionArgument(arg2) {
2112      return isFSA(arg2);
2113    }
2114    const runMutator = (draft) => {
2115      if (isPayloadActionArgument(arg)) {
2116        mutator(arg.payload, draft);
2117      } else {
2118        mutator(arg, draft);
2119      }
2120    };
2121    if (isDraftTyped(state)) {
2122      runMutator(state);
2123      return state;
2124    }
2125    return (0,immer__WEBPACK_IMPORTED_MODULE_2__.produce)(state, runMutator);
2126  };
2127}
2128
2129// src/entities/utils.ts
2130
2131function selectIdValue(entity, selectId) {
2132  const key = selectId(entity);
2133  if ( true && key === void 0) {
2134    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());
2135  }
2136  return key;
2137}
2138function ensureEntitiesArray(entities) {
2139  if (!Array.isArray(entities)) {
2140    entities = Object.values(entities);
2141  }
2142  return entities;
2143}
2144function getCurrent(value) {
2145  return (0,immer__WEBPACK_IMPORTED_MODULE_2__.isDraft)(value) ? (0,immer__WEBPACK_IMPORTED_MODULE_2__.current)(value) : value;
2146}
2147function splitAddedUpdatedEntities(newEntities, selectId, state) {
2148  newEntities = ensureEntitiesArray(newEntities);
2149  const existingIdsArray = getCurrent(state.ids);
2150  const existingIds = new Set(existingIdsArray);
2151  const added = [];
2152  const updated = [];
2153  for (const entity of newEntities) {
2154    const id = selectIdValue(entity, selectId);
2155    if (existingIds.has(id)) {
2156      updated.push({
2157        id,
2158        changes: entity
2159      });
2160    } else {
2161      added.push(entity);
2162    }
2163  }
2164  return [added, updated, existingIdsArray];
2165}
2166
2167// src/entities/unsorted_state_adapter.ts
2168function createUnsortedStateAdapter(selectId) {
2169  function addOneMutably(entity, state) {
2170    const key = selectIdValue(entity, selectId);
2171    if (key in state.entities) {
2172      return;
2173    }
2174    state.ids.push(key);
2175    state.entities[key] = entity;
2176  }
2177  function addManyMutably(newEntities, state) {
2178    newEntities = ensureEntitiesArray(newEntities);
2179    for (const entity of newEntities) {
2180      addOneMutably(entity, state);
2181    }
2182  }
2183  function setOneMutably(entity, state) {
2184    const key = selectIdValue(entity, selectId);
2185    if (!(key in state.entities)) {
2186      state.ids.push(key);
2187    }
2188    ;
2189    state.entities[key] = entity;
2190  }
2191  function setManyMutably(newEntities, state) {
2192    newEntities = ensureEntitiesArray(newEntities);
2193    for (const entity of newEntities) {
2194      setOneMutably(entity, state);
2195    }
2196  }
2197  function setAllMutably(newEntities, state) {
2198    newEntities = ensureEntitiesArray(newEntities);
2199    state.ids = [];
2200    state.entities = {};
2201    addManyMutably(newEntities, state);
2202  }
2203  function removeOneMutably(key, state) {
2204    return removeManyMutably([key], state);
2205  }
2206  function removeManyMutably(keys, state) {
2207    let didMutate = false;
2208    keys.forEach((key) => {
2209      if (key in state.entities) {
2210        delete state.entities[key];
2211        didMutate = true;
2212      }
2213    });
2214    if (didMutate) {
2215      state.ids = state.ids.filter((id) => id in state.entities);
2216    }
2217  }
2218  function removeAllMutably(state) {
2219    Object.assign(state, {
2220      ids: [],
2221      entities: {}
2222    });
2223  }
2224  function takeNewKey(keys, update, state) {
2225    const original3 = state.entities[update.id];
2226    if (original3 === void 0) {
2227      return false;
2228    }
2229    const updated = Object.assign({}, original3, update.changes);
2230    const newKey = selectIdValue(updated, selectId);
2231    const hasNewKey = newKey !== update.id;
2232    if (hasNewKey) {
2233      keys[update.id] = newKey;
2234      delete state.entities[update.id];
2235    }
2236    ;
2237    state.entities[newKey] = updated;
2238    return hasNewKey;
2239  }
2240  function updateOneMutably(update, state) {
2241    return updateManyMutably([update], state);
2242  }
2243  function updateManyMutably(updates, state) {
2244    const newKeys = {};
2245    const updatesPerEntity = {};
2246    updates.forEach((update) => {
2247      if (update.id in state.entities) {
2248        updatesPerEntity[update.id] = {
2249          id: update.id,
2250          // Spreads ignore falsy values, so this works even if there isn't
2251          // an existing update already at this key
2252          changes: {
2253            ...updatesPerEntity[update.id]?.changes,
2254            ...update.changes
2255          }
2256        };
2257      }
2258    });
2259    updates = Object.values(updatesPerEntity);
2260    const didMutateEntities = updates.length > 0;
2261    if (didMutateEntities) {
2262      const didMutateIds = updates.filter((update) => takeNewKey(newKeys, update, state)).length > 0;
2263      if (didMutateIds) {
2264        state.ids = Object.values(state.entities).map((e) => selectIdValue(e, selectId));
2265      }
2266    }
2267  }
2268  function upsertOneMutably(entity, state) {
2269    return upsertManyMutably([entity], state);
2270  }
2271  function upsertManyMutably(newEntities, state) {
2272    const [added, updated] = splitAddedUpdatedEntities(newEntities, selectId, state);
2273    updateManyMutably(updated, state);
2274    addManyMutably(added, state);
2275  }
2276  return {
2277    removeAll: createSingleArgumentStateOperator(removeAllMutably),
2278    addOne: createStateOperator(addOneMutably),
2279    addMany: createStateOperator(addManyMutably),
2280    setOne: createStateOperator(setOneMutably),
2281    setMany: createStateOperator(setManyMutably),
2282    setAll: createStateOperator(setAllMutably),
2283    updateOne: createStateOperator(updateOneMutably),
2284    updateMany: createStateOperator(updateManyMutably),
2285    upsertOne: createStateOperator(upsertOneMutably),
2286    upsertMany: createStateOperator(upsertManyMutably),
2287    removeOne: createStateOperator(removeOneMutably),
2288    removeMany: createStateOperator(removeManyMutably)
2289  };
2290}
2291
2292// src/entities/sorted_state_adapter.ts
2293function findInsertIndex(sortedItems, item, comparisonFunction) {
2294  let lowIndex = 0;
2295  let highIndex = sortedItems.length;
2296  while (lowIndex < highIndex) {
2297    let middleIndex = lowIndex + highIndex >>> 1;
2298    const currentItem = sortedItems[middleIndex];
2299    const res = comparisonFunction(item, currentItem);
2300    if (res >= 0) {
2301      lowIndex = middleIndex + 1;
2302    } else {
2303      highIndex = middleIndex;
2304    }
2305  }
2306  return lowIndex;
2307}
2308function insert(sortedItems, item, comparisonFunction) {
2309  const insertAtIndex = findInsertIndex(sortedItems, item, comparisonFunction);
2310  sortedItems.splice(insertAtIndex, 0, item);
2311  return sortedItems;
2312}
2313function createSortedStateAdapter(selectId, comparer) {
2314  const {
2315    removeOne,
2316    removeMany,
2317    removeAll
2318  } = createUnsortedStateAdapter(selectId);
2319  function addOneMutably(entity, state) {
2320    return addManyMutably([entity], state);
2321  }
2322  function addManyMutably(newEntities, state, existingIds) {
2323    newEntities = ensureEntitiesArray(newEntities);
2324    const existingKeys = new Set(existingIds ?? getCurrent(state.ids));
2325    const models = newEntities.filter((model) => !existingKeys.has(selectIdValue(model, selectId)));
2326    if (models.length !== 0) {
2327      mergeFunction(state, models);
2328    }
2329  }
2330  function setOneMutably(entity, state) {
2331    return setManyMutably([entity], state);
2332  }
2333  function setManyMutably(newEntities, state) {
2334    newEntities = ensureEntitiesArray(newEntities);
2335    if (newEntities.length !== 0) {
2336      for (const item of newEntities) {
2337        delete state.entities[selectId(item)];
2338      }
2339      mergeFunction(state, newEntities);
2340    }
2341  }
2342  function setAllMutably(newEntities, state) {
2343    newEntities = ensureEntitiesArray(newEntities);
2344    state.entities = {};
2345    state.ids = [];
2346    addManyMutably(newEntities, state, []);
2347  }
2348  function updateOneMutably(update, state) {
2349    return updateManyMutably([update], state);
2350  }
2351  function updateManyMutably(updates, state) {
2352    let appliedUpdates = false;
2353    let replacedIds = false;
2354    for (let update of updates) {
2355      const entity = state.entities[update.id];
2356      if (!entity) {
2357        continue;
2358      }
2359      appliedUpdates = true;
2360      Object.assign(entity, update.changes);
2361      const newId = selectId(entity);
2362      if (update.id !== newId) {
2363        replacedIds = true;
2364        delete state.entities[update.id];
2365        const oldIndex = state.ids.indexOf(update.id);
2366        state.ids[oldIndex] = newId;
2367        state.entities[newId] = entity;
2368      }
2369    }
2370    if (appliedUpdates) {
2371      mergeFunction(state, [], appliedUpdates, replacedIds);
2372    }
2373  }
2374  function upsertOneMutably(entity, state) {
2375    return upsertManyMutably([entity], state);
2376  }
2377  function upsertManyMutably(newEntities, state) {
2378    const [added, updated, existingIdsArray] = splitAddedUpdatedEntities(newEntities, selectId, state);
2379    if (updated.length) {
2380      updateManyMutably(updated, state);
2381    }
2382    if (added.length) {
2383      addManyMutably(added, state, existingIdsArray);
2384    }
2385  }
2386  function areArraysEqual(a, b) {
2387    if (a.length !== b.length) {
2388      return false;
2389    }
2390    for (let i = 0; i < a.length; i++) {
2391      if (a[i] === b[i]) {
2392        continue;
2393      }
2394      return false;
2395    }
2396    return true;
2397  }
2398  const mergeFunction = (state, addedItems, appliedUpdates, replacedIds) => {
2399    const currentEntities = getCurrent(state.entities);
2400    const currentIds = getCurrent(state.ids);
2401    const stateEntities = state.entities;
2402    let ids = currentIds;
2403    if (replacedIds) {
2404      ids = new Set(currentIds);
2405    }
2406    let sortedEntities = [];
2407    for (const id of ids) {
2408      const entity = currentEntities[id];
2409      if (entity) {
2410        sortedEntities.push(entity);
2411      }
2412    }
2413    const wasPreviouslyEmpty = sortedEntities.length === 0;
2414    for (const item of addedItems) {
2415      stateEntities[selectId(item)] = item;
2416      if (!wasPreviouslyEmpty) {
2417        insert(sortedEntities, item, comparer);
2418      }
2419    }
2420    if (wasPreviouslyEmpty) {
2421      sortedEntities = addedItems.slice().sort(comparer);
2422    } else if (appliedUpdates) {
2423      sortedEntities.sort(comparer);
2424    }
2425    const newSortedIds = sortedEntities.map(selectId);
2426    if (!areArraysEqual(currentIds, newSortedIds)) {
2427      state.ids = newSortedIds;
2428    }
2429  };
2430  return {
2431    removeOne,
2432    removeMany,
2433    removeAll,
2434    addOne: createStateOperator(addOneMutably),
2435    updateOne: createStateOperator(updateOneMutably),
2436    upsertOne: createStateOperator(upsertOneMutably),
2437    setOne: createStateOperator(setOneMutably),
2438    setMany: createStateOperator(setManyMutably),
2439    setAll: createStateOperator(setAllMutably),
2440    addMany: createStateOperator(addManyMutably),
2441    updateMany: createStateOperator(updateManyMutably),
2442    upsertMany: createStateOperator(upsertManyMutably)
2443  };
2444}
2445
2446// src/entities/create_adapter.ts
2447function createEntityAdapter(options = {}) {
2448  const {
2449    selectId,
2450    sortComparer
2451  } = {
2452    sortComparer: false,
2453    selectId: (instance) => instance.id,
2454    ...options
2455  };
2456  const stateAdapter = sortComparer ? createSortedStateAdapter(selectId, sortComparer) : createUnsortedStateAdapter(selectId);
2457  const stateFactory = createInitialStateFactory(stateAdapter);
2458  const selectorsFactory = createSelectorsFactory();
2459  return {
2460    selectId,
2461    sortComparer,
2462    ...stateFactory,
2463    ...selectorsFactory,
2464    ...stateAdapter
2465  };
2466}
2467
2468// src/listenerMiddleware/index.ts
2469
2470
2471// src/listenerMiddleware/exceptions.ts
2472var task = "task";
2473var listener = "listener";
2474var completed = "completed";
2475var cancelled = "cancelled";
2476var taskCancelled = `task-${cancelled}`;
2477var taskCompleted = `task-${completed}`;
2478var listenerCancelled = `${listener}-${cancelled}`;
2479var listenerCompleted = `${listener}-${completed}`;
2480var TaskAbortError = class {
2481  constructor(code) {
2482    this.code = code;
2483    this.message = `${task} ${cancelled} (reason: ${code})`;
2484  }
2485  name = "TaskAbortError";
2486  message;
2487};
2488
2489// src/listenerMiddleware/utils.ts
2490var assertFunction = (func, expected) => {
2491  if (typeof func !== "function") {
2492    throw new Error( false ? 0 : `${expected} is not a function`);
2493  }
2494};
2495var noop2 = () => {
2496};
2497var catchRejection = (promise, onError = noop2) => {
2498  promise.catch(onError);
2499  return promise;
2500};
2501var addAbortSignalListener = (abortSignal, callback) => {
2502  abortSignal.addEventListener("abort", callback, {
2503    once: true
2504  });
2505  return () => abortSignal.removeEventListener("abort", callback);
2506};
2507var abortControllerWithReason = (abortController, reason) => {
2508  const signal = abortController.signal;
2509  if (signal.aborted) {
2510    return;
2511  }
2512  if (!("reason" in signal)) {
2513    Object.defineProperty(signal, "reason", {
2514      enumerable: true,
2515      value: reason,
2516      configurable: true,
2517      writable: true
2518    });
2519  }
2520  ;
2521  abortController.abort(reason);
2522};
2523
2524// src/listenerMiddleware/task.ts
2525var validateActive = (signal) => {
2526  if (signal.aborted) {
2527    const {
2528      reason
2529    } = signal;
2530    throw new TaskAbortError(reason);
2531  }
2532};
2533function raceWithSignal(signal, promise) {
2534  let cleanup = noop2;
2535  return new Promise((resolve, reject) => {
2536    const notifyRejection = () => reject(new TaskAbortError(signal.reason));
2537    if (signal.aborted) {
2538      notifyRejection();
2539      return;
2540    }
2541    cleanup = addAbortSignalListener(signal, notifyRejection);
2542    promise.finally(() => cleanup()).then(resolve, reject);
2543  }).finally(() => {
2544    cleanup = noop2;
2545  });
2546}
2547var runTask = async (task2, cleanUp) => {
2548  try {
2549    await Promise.resolve();
2550    const value = await task2();
2551    return {
2552      status: "ok",
2553      value
2554    };
2555  } catch (error) {
2556    return {
2557      status: error instanceof TaskAbortError ? "cancelled" : "rejected",
2558      error
2559    };
2560  } finally {
2561    cleanUp?.();
2562  }
2563};
2564var createPause = (signal) => {
2565  return (promise) => {
2566    return catchRejection(raceWithSignal(signal, promise).then((output) => {
2567      validateActive(signal);
2568      return output;
2569    }));
2570  };
2571};
2572var createDelay = (signal) => {
2573  const pause = createPause(signal);
2574  return (timeoutMs) => {
2575    return pause(new Promise((resolve) => setTimeout(resolve, timeoutMs)));
2576  };
2577};
2578
2579// src/listenerMiddleware/index.ts
2580var {
2581  assign
2582} = Object;
2583var INTERNAL_NIL_TOKEN = {};
2584var alm = "listenerMiddleware";
2585var createFork = (parentAbortSignal, parentBlockingPromises) => {
2586  const linkControllers = (controller) => addAbortSignalListener(parentAbortSignal, () => abortControllerWithReason(controller, parentAbortSignal.reason));
2587  return (taskExecutor, opts) => {
2588    assertFunction(taskExecutor, "taskExecutor");
2589    const childAbortController = new AbortController();
2590    linkControllers(childAbortController);
2591    const result = runTask(async () => {
2592      validateActive(parentAbortSignal);
2593      validateActive(childAbortController.signal);
2594      const result2 = await taskExecutor({
2595        pause: createPause(childAbortController.signal),
2596        delay: createDelay(childAbortController.signal),
2597        signal: childAbortController.signal
2598      });
2599      validateActive(childAbortController.signal);
2600      return result2;
2601    }, () => abortControllerWithReason(childAbortController, taskCompleted));
2602    if (opts?.autoJoin) {
2603      parentBlockingPromises.push(result.catch(noop2));
2604    }
2605    return {
2606      result: createPause(parentAbortSignal)(result),
2607      cancel() {
2608        abortControllerWithReason(childAbortController, taskCancelled);
2609      }
2610    };
2611  };
2612};
2613var createTakePattern = (startListening, signal) => {
2614  const take = async (predicate, timeout) => {
2615    validateActive(signal);
2616    let unsubscribe = () => {
2617    };
2618    const tuplePromise = new Promise((resolve, reject) => {
2619      let stopListening = startListening({
2620        predicate,
2621        effect: (action, listenerApi) => {
2622          listenerApi.unsubscribe();
2623          resolve([action, listenerApi.getState(), listenerApi.getOriginalState()]);
2624        }
2625      });
2626      unsubscribe = () => {
2627        stopListening();
2628        reject();
2629      };
2630    });
2631    const promises = [tuplePromise];
2632    if (timeout != null) {
2633      promises.push(new Promise((resolve) => setTimeout(resolve, timeout, null)));
2634    }
2635    try {
2636      const output = await raceWithSignal(signal, Promise.race(promises));
2637      validateActive(signal);
2638      return output;
2639    } finally {
2640      unsubscribe();
2641    }
2642  };
2643  return (predicate, timeout) => catchRejection(take(predicate, timeout));
2644};
2645var getListenerEntryPropsFrom = (options) => {
2646  let {
2647    type,
2648    actionCreator,
2649    matcher,
2650    predicate,
2651    effect
2652  } = options;
2653  if (type) {
2654    predicate = createAction(type).match;
2655  } else if (actionCreator) {
2656    type = actionCreator.type;
2657    predicate = actionCreator.match;
2658  } else if (matcher) {
2659    predicate = matcher;
2660  } else if (predicate) {
2661  } else {
2662    throw new Error( false ? 0 : "Creating or removing a listener requires one of the known fields for matching an action");
2663  }
2664  assertFunction(effect, "options.listener");
2665  return {
2666    predicate,
2667    type,
2668    effect
2669  };
2670};
2671var createListenerEntry = /* @__PURE__ */ assign((options) => {
2672  const {
2673    type,
2674    predicate,
2675    effect
2676  } = getListenerEntryPropsFrom(options);
2677  const id = nanoid();
2678  const entry = {
2679    id,
2680    effect,
2681    type,
2682    predicate,
2683    pending: /* @__PURE__ */ new Set(),
2684    unsubscribe: () => {
2685      throw new Error( false ? 0 : "Unsubscribe not initialized");
2686    }
2687  };
2688  return entry;
2689}, {
2690  withTypes: () => createListenerEntry
2691});
2692var cancelActiveListeners = (entry) => {
2693  entry.pending.forEach((controller) => {
2694    abortControllerWithReason(controller, listenerCancelled);
2695  });
2696};
2697var createClearListenerMiddleware = (listenerMap) => {
2698  return () => {
2699    listenerMap.forEach(cancelActiveListeners);
2700    listenerMap.clear();
2701  };
2702};
2703var safelyNotifyError = (errorHandler, errorToNotify, errorInfo) => {
2704  try {
2705    errorHandler(errorToNotify, errorInfo);
2706  } catch (errorHandlerError) {
2707    setTimeout(() => {
2708      throw errorHandlerError;
2709    }, 0);
2710  }
2711};
2712var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), {
2713  withTypes: () => addListener
2714});
2715var clearAllListeners = /* @__PURE__ */ createAction(`${alm}/removeAll`);
2716var removeListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/remove`), {
2717  withTypes: () => removeListener
2718});
2719var defaultErrorHandler = (...args) => {
2720  console.error(`${alm}/error`, ...args);
2721};
2722var createListenerMiddleware = (middlewareOptions = {}) => {
2723  const listenerMap = /* @__PURE__ */ new Map();
2724  const {
2725    extra,
2726    onError = defaultErrorHandler
2727  } = middlewareOptions;
2728  assertFunction(onError, "onError");
2729  const insertEntry = (entry) => {
2730    entry.unsubscribe = () => listenerMap.delete(entry.id);
2731    listenerMap.set(entry.id, entry);
2732    return (cancelOptions) => {
2733      entry.unsubscribe();
2734      if (cancelOptions?.cancelActive) {
2735        cancelActiveListeners(entry);
2736      }
2737    };
2738  };
2739  const startListening = (options) => {
2740    let entry = find(Array.from(listenerMap.values()), (existingEntry) => existingEntry.effect === options.effect);
2741    if (!entry) {
2742      entry = createListenerEntry(options);
2743    }
2744    return insertEntry(entry);
2745  };
2746  assign(startListening, {
2747    withTypes: () => startListening
2748  });
2749  const stopListening = (options) => {
2750    const {
2751      type,
2752      effect,
2753      predicate
2754    } = getListenerEntryPropsFrom(options);
2755    const entry = find(Array.from(listenerMap.values()), (entry2) => {
2756      const matchPredicateOrType = typeof type === "string" ? entry2.type === type : entry2.predicate === predicate;
2757      return matchPredicateOrType && entry2.effect === effect;
2758    });
2759    if (entry) {
2760      entry.unsubscribe();
2761      if (options.cancelActive) {
2762        cancelActiveListeners(entry);
2763      }
2764    }
2765    return !!entry;
2766  };
2767  assign(stopListening, {
2768    withTypes: () => stopListening
2769  });
2770  const notifyListener = async (entry, action, api, getOriginalState) => {
2771    const internalTaskController = new AbortController();
2772    const take = createTakePattern(startListening, internalTaskController.signal);
2773    const autoJoinPromises = [];
2774    try {
2775      entry.pending.add(internalTaskController);
2776      await Promise.resolve(entry.effect(
2777        action,
2778        // Use assign() rather than ... to avoid extra helper functions added to bundle
2779        assign({}, api, {
2780          getOriginalState,
2781          condition: (predicate, timeout) => take(predicate, timeout).then(Boolean),
2782          take,
2783          delay: createDelay(internalTaskController.signal),
2784          pause: createPause(internalTaskController.signal),
2785          extra,
2786          signal: internalTaskController.signal,
2787          fork: createFork(internalTaskController.signal, autoJoinPromises),
2788          unsubscribe: entry.unsubscribe,
2789          subscribe: () => {
2790            listenerMap.set(entry.id, entry);
2791          },
2792          cancelActiveListeners: () => {
2793            entry.pending.forEach((controller, _, set) => {
2794              if (controller !== internalTaskController) {
2795                abortControllerWithReason(controller, listenerCancelled);
2796                set.delete(controller);
2797              }
2798            });
2799          },
2800          cancel: () => {
2801            abortControllerWithReason(internalTaskController, listenerCancelled);
2802            entry.pending.delete(internalTaskController);
2803          },
2804          throwIfCancelled: () => {
2805            validateActive(internalTaskController.signal);
2806          }
2807        })
2808      ));
2809    } catch (listenerError) {
2810      if (!(listenerError instanceof TaskAbortError)) {
2811        safelyNotifyError(onError, listenerError, {
2812          raisedBy: "effect"
2813        });
2814      }
2815    } finally {
2816      await Promise.all(autoJoinPromises);
2817      abortControllerWithReason(internalTaskController, listenerCompleted);
2818      entry.pending.delete(internalTaskController);
2819    }
2820  };
2821  const clearListenerMiddleware = createClearListenerMiddleware(listenerMap);
2822  const middleware = (api) => (next) => (action) => {
2823    if (!(0,redux__WEBPACK_IMPORTED_MODULE_0__.isAction)(action)) {
2824      return next(action);
2825    }
2826    if (addListener.match(action)) {
2827      return startListening(action.payload);
2828    }
2829    if (clearAllListeners.match(action)) {
2830      clearListenerMiddleware();
2831      return;
2832    }
2833    if (removeListener.match(action)) {
2834      return stopListening(action.payload);
2835    }
2836    let originalState = api.getState();
2837    const getOriginalState = () => {
2838      if (originalState === INTERNAL_NIL_TOKEN) {
2839        throw new Error( false ? 0 : `${alm}: getOriginalState can only be called synchronously`);
2840      }
2841      return originalState;
2842    };
2843    let result;
2844    try {
2845      result = next(action);
2846      if (listenerMap.size > 0) {
2847        const currentState = api.getState();
2848        const listenerEntries = Array.from(listenerMap.values());
2849        for (const entry of listenerEntries) {
2850          let runListener = false;
2851          try {
2852            runListener = entry.predicate(action, currentState, originalState);
2853          } catch (predicateError) {
2854            runListener = false;
2855            safelyNotifyError(onError, predicateError, {
2856              raisedBy: "predicate"
2857            });
2858          }
2859          if (!runListener) {
2860            continue;
2861          }
2862          notifyListener(entry, action, api, getOriginalState);
2863        }
2864      }
2865    } finally {
2866      originalState = INTERNAL_NIL_TOKEN;
2867    }
2868    return result;
2869  };
2870  return {
2871    middleware,
2872    startListening,
2873    stopListening,
2874    clearListeners: clearListenerMiddleware
2875  };
2876};
2877
2878// src/dynamicMiddleware/index.ts
2879
2880var createMiddlewareEntry = (middleware) => ({
2881  id: nanoid(),
2882  middleware,
2883  applied: /* @__PURE__ */ new Map()
2884});
2885var matchInstance = (instanceId) => (action) => action?.meta?.instanceId === instanceId;
2886var createDynamicMiddleware = () => {
2887  const instanceId = nanoid();
2888  const middlewareMap = /* @__PURE__ */ new Map();
2889  const withMiddleware = Object.assign(createAction("dynamicMiddleware/add", (...middlewares) => ({
2890    payload: middlewares,
2891    meta: {
2892      instanceId
2893    }
2894  })), {
2895    withTypes: () => withMiddleware
2896  });
2897  const addMiddleware = Object.assign(function addMiddleware2(...middlewares) {
2898    middlewares.forEach((middleware2) => {
2899      let entry = find(Array.from(middlewareMap.values()), (entry2) => entry2.middleware === middleware2);
2900      if (!entry) {
2901        entry = createMiddlewareEntry(middleware2);
2902      }
2903      middlewareMap.set(entry.id, entry);
2904    });
2905  }, {
2906    withTypes: () => addMiddleware
2907  });
2908  const getFinalMiddleware = (api) => {
2909    const appliedMiddleware = Array.from(middlewareMap.values()).map((entry) => emplace(entry.applied, api, {
2910      insert: () => entry.middleware(api)
2911    }));
2912    return (0,redux__WEBPACK_IMPORTED_MODULE_0__.compose)(...appliedMiddleware);
2913  };
2914  const isWithMiddleware = isAllOf(withMiddleware, matchInstance(instanceId));
2915  const middleware = (api) => (next) => (action) => {
2916    if (isWithMiddleware(action)) {
2917      addMiddleware(...action.payload);
2918      return api.dispatch;
2919    }
2920    return getFinalMiddleware(api)(next)(action);
2921  };
2922  return {
2923    middleware,
2924    addMiddleware,
2925    withMiddleware,
2926    instanceId
2927  };
2928};
2929
2930// src/combineSlices.ts
2931
2932var isSliceLike = (maybeSliceLike) => "reducerPath" in maybeSliceLike && typeof maybeSliceLike.reducerPath === "string";
2933var getReducers = (slices) => slices.flatMap((sliceOrMap) => isSliceLike(sliceOrMap) ? [[sliceOrMap.reducerPath, sliceOrMap.reducer]] : Object.entries(sliceOrMap));
2934var ORIGINAL_STATE = Symbol.for("rtk-state-proxy-original");
2935var isStateProxy = (value) => !!value && !!value[ORIGINAL_STATE];
2936var stateProxyMap = /* @__PURE__ */ new WeakMap();
2937var createStateProxy = (state, reducerMap) => emplace(stateProxyMap, state, {
2938  insert: () => new Proxy(state, {
2939    get: (target, prop, receiver) => {
2940      if (prop === ORIGINAL_STATE) return target;
2941      const result = Reflect.get(target, prop, receiver);
2942      if (typeof result === "undefined") {
2943        const reducer = reducerMap[prop.toString()];
2944        if (reducer) {
2945          const reducerResult = reducer(void 0, {
2946            type: nanoid()
2947          });
2948          if (typeof reducerResult === "undefined") {
2949            throw new Error( false ? 0 : `The slice reducer for key "${prop.toString()}" returned undefined when called for selector(). If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);
2950          }
2951          return reducerResult;
2952        }
2953      }
2954      return result;
2955    }
2956  })
2957});
2958var original = (state) => {
2959  if (!isStateProxy(state)) {
2960    throw new Error( false ? 0 : "original must be used on state Proxy");
2961  }
2962  return state[ORIGINAL_STATE];
2963};
2964var noopReducer = (state = {}) => state;
2965function combineSlices(...slices) {
2966  const reducerMap = Object.fromEntries(getReducers(slices));
2967  const getReducer = () => Object.keys(reducerMap).length ? (0,redux__WEBPACK_IMPORTED_MODULE_0__.combineReducers)(reducerMap) : noopReducer;
2968  let reducer = getReducer();
2969  function combinedReducer(state, action) {
2970    return reducer(state, action);
2971  }
2972  combinedReducer.withLazyLoadedSlices = () => combinedReducer;
2973  const inject = (slice, config = {}) => {
2974    const {
2975      reducerPath,
2976      reducer: reducerToInject
2977    } = slice;
2978    const currentReducer = reducerMap[reducerPath];
2979    if (!config.overrideExisting && currentReducer && currentReducer !== reducerToInject) {
2980      if (typeof process !== "undefined" && "development" === "development") {
2981        console.error(`called \`inject\` to override already-existing reducer ${reducerPath} without specifying \`overrideExisting: true\``);
2982      }
2983      return combinedReducer;
2984    }
2985    reducerMap[reducerPath] = reducerToInject;
2986    reducer = getReducer();
2987    return combinedReducer;
2988  };
2989  const selector = Object.assign(function makeSelector(selectorFn, selectState) {
2990    return function selector2(state, ...args) {
2991      return selectorFn(createStateProxy(selectState ? selectState(state, ...args) : state, reducerMap), ...args);
2992    };
2993  }, {
2994    original
2995  });
2996  return Object.assign(combinedReducer, {
2997    inject,
2998    selector
2999  });
3000}
3001
3002// src/formatProdErrorMessage.ts
3003function formatProdErrorMessage(code) {
3004  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. `;
3005}
3006
3007//# sourceMappingURL=redux-toolkit.modern.mjs.map
3008
3009/***/ }),
3010