System.register([], (function (exports) {
  'use strict';
  return {
    execute: (function () {

      exports("createJSONStorage", createJSONStorage);

      const reduxImpl = (reducer, initial) => (set, _get, api) => {
        api.dispatch = (action) => {
          set((state) => reducer(state, action), false, action);
          return action;
        };
        api.dispatchFromDevtools = true;
        return { dispatch: (...a) => api.dispatch(...a), ...initial };
      };
      const redux = exports("redux", reduxImpl);

      const trackedConnections = /* @__PURE__ */ new Map();
      const getTrackedConnectionState = (name) => {
        const api = trackedConnections.get(name);
        if (!api) return {};
        return Object.fromEntries(
          Object.entries(api.stores).map(([key, api2]) => [key, api2.getState()])
        );
      };
      const extractConnectionInformation = (store, extensionConnector, options) => {
        if (store === void 0) {
          return {
            type: "untracked",
            connection: extensionConnector.connect(options)
          };
        }
        const existingConnection = trackedConnections.get(options.name);
        if (existingConnection) {
          return { type: "tracked", store, ...existingConnection };
        }
        const newConnection = {
          connection: extensionConnector.connect(options),
          stores: {}
        };
        trackedConnections.set(options.name, newConnection);
        return { type: "tracked", store, ...newConnection };
      };
      const devtoolsImpl = (fn, devtoolsOptions = {}) => (set, get, api) => {
        const { enabled, anonymousActionType, store, ...options } = devtoolsOptions;
        let extensionConnector;
        try {
          extensionConnector = (enabled != null ? enabled : true) && window.__REDUX_DEVTOOLS_EXTENSION__;
        } catch (_e) {
        }
        if (!extensionConnector) {
          if (enabled) {
            console.warn(
              "[zustand devtools middleware] Please install/enable Redux devtools extension"
            );
          }
          return fn(set, get, api);
        }
        const { connection, ...connectionInformation } = extractConnectionInformation(store, extensionConnector, options);
        let isRecording = true;
        api.setState = (state, replace, nameOrAction) => {
          const r = set(state, replace);
          if (!isRecording) return r;
          const action = nameOrAction === void 0 ? { type: anonymousActionType || "anonymous" } : typeof nameOrAction === "string" ? { type: nameOrAction } : nameOrAction;
          if (store === void 0) {
            connection == null ? void 0 : connection.send(action, get());
            return r;
          }
          connection == null ? void 0 : connection.send(
            {
              ...action,
              type: `${store}/${action.type}`
            },
            {
              ...getTrackedConnectionState(options.name),
              [store]: api.getState()
            }
          );
          return r;
        };
        const setStateFromDevtools = (...a) => {
          const originalIsRecording = isRecording;
          isRecording = false;
          set(...a);
          isRecording = originalIsRecording;
        };
        const initialState = fn(api.setState, get, api);
        if (connectionInformation.type === "untracked") {
          connection == null ? void 0 : connection.init(initialState);
        } else {
          connectionInformation.stores[connectionInformation.store] = api;
          connection == null ? void 0 : connection.init(
            Object.fromEntries(
              Object.entries(connectionInformation.stores).map(([key, store2]) => [
                key,
                key === connectionInformation.store ? initialState : store2.getState()
              ])
            )
          );
        }
        if (api.dispatchFromDevtools && typeof api.dispatch === "function") {
          let didWarnAboutReservedActionType = false;
          const originalDispatch = api.dispatch;
          api.dispatch = (...a) => {
            if (a[0].type === "__setState" && !didWarnAboutReservedActionType) {
              console.warn(
                '[zustand devtools middleware] "__setState" action type is reserved to set state from the devtools. Avoid using it.'
              );
              didWarnAboutReservedActionType = true;
            }
            originalDispatch(...a);
          };
        }
        connection.subscribe((message) => {
          var _a;
          switch (message.type) {
            case "ACTION":
              if (typeof message.payload !== "string") {
                console.error(
                  "[zustand devtools middleware] Unsupported action format"
                );
                return;
              }
              return parseJsonThen(
                message.payload,
                (action) => {
                  if (action.type === "__setState") {
                    if (store === void 0) {
                      setStateFromDevtools(action.state);
                      return;
                    }
                    if (Object.keys(action.state).length !== 1) {
                      console.error(
                        `
                    [zustand devtools middleware] Unsupported __setState action format. 
                    When using 'store' option in devtools(), the 'state' should have only one key, which is a value of 'store' that was passed in devtools(),
                    and value of this only key should be a state object. Example: { "type": "__setState", "state": { "abc123Store": { "foo": "bar" } } }
                    `
                      );
                    }
                    const stateFromDevtools = action.state[store];
                    if (stateFromDevtools === void 0 || stateFromDevtools === null) {
                      return;
                    }
                    if (JSON.stringify(api.getState()) !== JSON.stringify(stateFromDevtools)) {
                      setStateFromDevtools(stateFromDevtools);
                    }
                    return;
                  }
                  if (!api.dispatchFromDevtools) return;
                  if (typeof api.dispatch !== "function") return;
                  api.dispatch(action);
                }
              );
            case "DISPATCH":
              switch (message.payload.type) {
                case "RESET":
                  setStateFromDevtools(initialState);
                  if (store === void 0) {
                    return connection == null ? void 0 : connection.init(api.getState());
                  }
                  return connection == null ? void 0 : connection.init(getTrackedConnectionState(options.name));
                case "COMMIT":
                  if (store === void 0) {
                    connection == null ? void 0 : connection.init(api.getState());
                    return;
                  }
                  return connection == null ? void 0 : connection.init(getTrackedConnectionState(options.name));
                case "ROLLBACK":
                  return parseJsonThen(message.state, (state) => {
                    if (store === void 0) {
                      setStateFromDevtools(state);
                      connection == null ? void 0 : connection.init(api.getState());
                      return;
                    }
                    setStateFromDevtools(state[store]);
                    connection == null ? void 0 : connection.init(getTrackedConnectionState(options.name));
                  });
                case "JUMP_TO_STATE":
                case "JUMP_TO_ACTION":
                  return parseJsonThen(message.state, (state) => {
                    if (store === void 0) {
                      setStateFromDevtools(state);
                      return;
                    }
                    if (JSON.stringify(api.getState()) !== JSON.stringify(state[store])) {
                      setStateFromDevtools(state[store]);
                    }
                  });
                case "IMPORT_STATE": {
                  const { nextLiftedState } = message.payload;
                  const lastComputedState = (_a = nextLiftedState.computedStates.slice(-1)[0]) == null ? void 0 : _a.state;
                  if (!lastComputedState) return;
                  if (store === void 0) {
                    setStateFromDevtools(lastComputedState);
                  } else {
                    setStateFromDevtools(lastComputedState[store]);
                  }
                  connection == null ? void 0 : connection.send(
                    null,
                    // FIXME no-any
                    nextLiftedState
                  );
                  return;
                }
                case "PAUSE_RECORDING":
                  return isRecording = !isRecording;
              }
              return;
          }
        });
        return initialState;
      };
      const devtools = exports("devtools", devtoolsImpl);
      const parseJsonThen = (stringified, f) => {
        let parsed;
        try {
          parsed = JSON.parse(stringified);
        } catch (e) {
          console.error(
            "[zustand devtools middleware] Could not parse the received json",
            e
          );
        }
        if (parsed !== void 0) f(parsed);
      };

      const subscribeWithSelectorImpl = (fn) => (set, get, api) => {
        const origSubscribe = api.subscribe;
        api.subscribe = (selector, optListener, options) => {
          let listener = selector;
          if (optListener) {
            const equalityFn = (options == null ? void 0 : options.equalityFn) || Object.is;
            let currentSlice = selector(api.getState());
            listener = (state) => {
              const nextSlice = selector(state);
              if (!equalityFn(currentSlice, nextSlice)) {
                const previousSlice = currentSlice;
                optListener(currentSlice = nextSlice, previousSlice);
              }
            };
            if (options == null ? void 0 : options.fireImmediately) {
              optListener(currentSlice, currentSlice);
            }
          }
          return origSubscribe(listener);
        };
        const initialState = fn(set, get, api);
        return initialState;
      };
      const subscribeWithSelector = exports("subscribeWithSelector", subscribeWithSelectorImpl);

      const combine = exports("combine", (initialState, create) => (...a) => Object.assign({}, initialState, create(...a)));

      function createJSONStorage(getStorage, options) {
        let storage;
        try {
          storage = getStorage();
        } catch (_e) {
          return;
        }
        const persistStorage = {
          getItem: (name) => {
            var _a;
            const parse = (str2) => {
              if (str2 === null) {
                return null;
              }
              return JSON.parse(str2, options == null ? void 0 : options.reviver);
            };
            const str = (_a = storage.getItem(name)) != null ? _a : null;
            if (str instanceof Promise) {
              return str.then(parse);
            }
            return parse(str);
          },
          setItem: (name, newValue) => storage.setItem(
            name,
            JSON.stringify(newValue, options == null ? void 0 : options.replacer)
          ),
          removeItem: (name) => storage.removeItem(name)
        };
        return persistStorage;
      }
      const toThenable = (fn) => (input) => {
        try {
          const result = fn(input);
          if (result instanceof Promise) {
            return result;
          }
          return {
            then(onFulfilled) {
              return toThenable(onFulfilled)(result);
            },
            catch(_onRejected) {
              return this;
            }
          };
        } catch (e) {
          return {
            then(_onFulfilled) {
              return this;
            },
            catch(onRejected) {
              return toThenable(onRejected)(e);
            }
          };
        }
      };
      const oldImpl = (config, baseOptions) => (set, get, api) => {
        let options = {
          getStorage: () => localStorage,
          serialize: JSON.stringify,
          deserialize: JSON.parse,
          partialize: (state) => state,
          version: 0,
          merge: (persistedState, currentState) => ({
            ...currentState,
            ...persistedState
          }),
          ...baseOptions
        };
        let hasHydrated = false;
        const hydrationListeners = /* @__PURE__ */ new Set();
        const finishHydrationListeners = /* @__PURE__ */ new Set();
        let storage;
        try {
          storage = options.getStorage();
        } catch (_e) {
        }
        if (!storage) {
          return config(
            (...args) => {
              console.warn(
                `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
              );
              set(...args);
            },
            get,
            api
          );
        }
        const thenableSerialize = toThenable(options.serialize);
        const setItem = () => {
          const state = options.partialize({ ...get() });
          let errorInSync;
          const thenable = thenableSerialize({ state, version: options.version }).then(
            (serializedValue) => storage.setItem(options.name, serializedValue)
          ).catch((e) => {
            errorInSync = e;
          });
          if (errorInSync) {
            throw errorInSync;
          }
          return thenable;
        };
        const savedSetState = api.setState;
        api.setState = (state, replace) => {
          savedSetState(state, replace);
          void setItem();
        };
        const configResult = config(
          (...args) => {
            set(...args);
            void setItem();
          },
          get,
          api
        );
        let stateFromStorage;
        const hydrate = () => {
          var _a;
          if (!storage) return;
          hasHydrated = false;
          hydrationListeners.forEach((cb) => cb(get()));
          const postRehydrationCallback = ((_a = options.onRehydrateStorage) == null ? void 0 : _a.call(options, get())) || void 0;
          return toThenable(storage.getItem.bind(storage))(options.name).then((storageValue) => {
            if (storageValue) {
              return options.deserialize(storageValue);
            }
          }).then((deserializedStorageValue) => {
            if (deserializedStorageValue) {
              if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
                if (options.migrate) {
                  return options.migrate(
                    deserializedStorageValue.state,
                    deserializedStorageValue.version
                  );
                }
                console.error(
                  `State loaded from storage couldn't be migrated since no migrate function was provided`
                );
              } else {
                return deserializedStorageValue.state;
              }
            }
          }).then((migratedState) => {
            var _a2;
            stateFromStorage = options.merge(
              migratedState,
              (_a2 = get()) != null ? _a2 : configResult
            );
            set(stateFromStorage, true);
            return setItem();
          }).then(() => {
            postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
            hasHydrated = true;
            finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
          }).catch((e) => {
            postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
          });
        };
        api.persist = {
          setOptions: (newOptions) => {
            options = {
              ...options,
              ...newOptions
            };
            if (newOptions.getStorage) {
              storage = newOptions.getStorage();
            }
          },
          clearStorage: () => {
            storage == null ? void 0 : storage.removeItem(options.name);
          },
          getOptions: () => options,
          rehydrate: () => hydrate(),
          hasHydrated: () => hasHydrated,
          onHydrate: (cb) => {
            hydrationListeners.add(cb);
            return () => {
              hydrationListeners.delete(cb);
            };
          },
          onFinishHydration: (cb) => {
            finishHydrationListeners.add(cb);
            return () => {
              finishHydrationListeners.delete(cb);
            };
          }
        };
        hydrate();
        return stateFromStorage || configResult;
      };
      const newImpl = (config, baseOptions) => (set, get, api) => {
        let options = {
          storage: createJSONStorage(() => localStorage),
          partialize: (state) => state,
          version: 0,
          merge: (persistedState, currentState) => ({
            ...currentState,
            ...persistedState
          }),
          ...baseOptions
        };
        let hasHydrated = false;
        const hydrationListeners = /* @__PURE__ */ new Set();
        const finishHydrationListeners = /* @__PURE__ */ new Set();
        let storage = options.storage;
        if (!storage) {
          return config(
            (...args) => {
              console.warn(
                `[zustand persist middleware] Unable to update item '${options.name}', the given storage is currently unavailable.`
              );
              set(...args);
            },
            get,
            api
          );
        }
        const setItem = () => {
          const state = options.partialize({ ...get() });
          return storage.setItem(options.name, {
            state,
            version: options.version
          });
        };
        const savedSetState = api.setState;
        api.setState = (state, replace) => {
          savedSetState(state, replace);
          void setItem();
        };
        const configResult = config(
          (...args) => {
            set(...args);
            void setItem();
          },
          get,
          api
        );
        api.getInitialState = () => configResult;
        let stateFromStorage;
        const hydrate = () => {
          var _a, _b;
          if (!storage) return;
          hasHydrated = false;
          hydrationListeners.forEach((cb) => {
            var _a2;
            return cb((_a2 = get()) != null ? _a2 : configResult);
          });
          const postRehydrationCallback = ((_b = options.onRehydrateStorage) == null ? void 0 : _b.call(options, (_a = get()) != null ? _a : configResult)) || void 0;
          return toThenable(storage.getItem.bind(storage))(options.name).then((deserializedStorageValue) => {
            if (deserializedStorageValue) {
              if (typeof deserializedStorageValue.version === "number" && deserializedStorageValue.version !== options.version) {
                if (options.migrate) {
                  return [
                    true,
                    options.migrate(
                      deserializedStorageValue.state,
                      deserializedStorageValue.version
                    )
                  ];
                }
                console.error(
                  `State loaded from storage couldn't be migrated since no migrate function was provided`
                );
              } else {
                return [false, deserializedStorageValue.state];
              }
            }
            return [false, void 0];
          }).then((migrationResult) => {
            var _a2;
            const [migrated, migratedState] = migrationResult;
            stateFromStorage = options.merge(
              migratedState,
              (_a2 = get()) != null ? _a2 : configResult
            );
            set(stateFromStorage, true);
            if (migrated) {
              return setItem();
            }
          }).then(() => {
            postRehydrationCallback == null ? void 0 : postRehydrationCallback(stateFromStorage, void 0);
            stateFromStorage = get();
            hasHydrated = true;
            finishHydrationListeners.forEach((cb) => cb(stateFromStorage));
          }).catch((e) => {
            postRehydrationCallback == null ? void 0 : postRehydrationCallback(void 0, e);
          });
        };
        api.persist = {
          setOptions: (newOptions) => {
            options = {
              ...options,
              ...newOptions
            };
            if (newOptions.storage) {
              storage = newOptions.storage;
            }
          },
          clearStorage: () => {
            storage == null ? void 0 : storage.removeItem(options.name);
          },
          getOptions: () => options,
          rehydrate: () => hydrate(),
          hasHydrated: () => hasHydrated,
          onHydrate: (cb) => {
            hydrationListeners.add(cb);
            return () => {
              hydrationListeners.delete(cb);
            };
          },
          onFinishHydration: (cb) => {
            finishHydrationListeners.add(cb);
            return () => {
              finishHydrationListeners.delete(cb);
            };
          }
        };
        if (!options.skipHydration) {
          hydrate();
        }
        return stateFromStorage || configResult;
      };
      const persistImpl = (config, baseOptions) => {
        if ("getStorage" in baseOptions || "serialize" in baseOptions || "deserialize" in baseOptions) {
          {
            console.warn(
              "[DEPRECATED] `getStorage`, `serialize` and `deserialize` options are deprecated. Use `storage` option instead."
            );
          }
          return oldImpl(config, baseOptions);
        }
        return newImpl(config, baseOptions);
      };
      const persist = exports("persist", persistImpl);

    })
  };
}));
