@rific/auto-paper 0.1.3 → 0.3.1

package/dist/index.mjs

@@ -2,2031 +2,2383 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// src/components/Button.tsx
-import { Button as PaperButton } from "react-native-paper";
+// src/BlurContext.tsx
+import { useContext } from "react";
+
+// src/ThemeSettingsContext.ts
+import { createContext } from "react";
+var defaultThemeSettings = {
+  appearance: "system",
+  blur: true,
+  blurTint: 0.2,
+  color: "#6750a4",
+  harmony: "split-complementary"
+};
+var ThemeSettingsContext = createContext({
+  settings: defaultThemeSettings,
+  set: () => {
+  }
+});
+
+// src/BlurContext.tsx
+function useBlur(override) {
+  const { settings } = useContext(ThemeSettingsContext);
+  return override ?? settings.blur;
+}
+
+// src/components/Appbar.tsx
+import { StatusBar } from "react-native";
+import { Appbar as PaperAppbar, useTheme } from "react-native-paper";
 
 // src/PaperDefaultsContext.tsx
-import { createContext, useContext } from "react";
-var PaperDefaultsContext = createContext({});
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var PaperDefaultsContext = createContext2({});
 function usePaperDefaults() {
-  return useContext(PaperDefaultsContext);
+  return useContext2(PaperDefaultsContext);
 }
 
-// src/components/Button.tsx
-import { jsx } from "react/jsx-runtime";
-function Button(props) {
+// src/components/Appbar.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function Header({ style, ...props }) {
   const defaults = usePaperDefaults();
-  return /* @__PURE__ */ jsx(PaperButton, { ...defaults.Button, ...props });
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(StatusBar, { backgroundColor: theme.colors.surface, barStyle: theme.dark ? "light-content" : "dark-content" }),
+    /* @__PURE__ */ jsx(PaperAppbar.Header, { ...defaults.AppbarHeader, ...props, style })
+  ] });
 }
+var Appbar = {
+  Header,
+  Content: PaperAppbar.Content,
+  Action: PaperAppbar.Action,
+  BackAction: PaperAppbar.BackAction
+};
 
-// src/components/Chip.tsx
-import { Chip as PaperChip } from "react-native-paper";
+// src/components/AppearancePicker.tsx
+import { SegmentedButtons } from "react-native-paper";
 import { jsx as jsx2 } from "react/jsx-runtime";
-function Chip(props) {
-  const defaults = usePaperDefaults();
-  return /* @__PURE__ */ jsx2(PaperChip, { ...defaults.Chip, ...props });
-}
+var APPEARANCES = [
+  { label: "System", value: "system", icon: "brightness-auto" },
+  { label: "Light", value: "light", icon: "white-balance-sunny" },
+  { label: "Dark", value: "dark", icon: "weather-night" }
+];
+var AppearancePicker = ({ value, onChange }) => /* @__PURE__ */ jsx2(SegmentedButtons, { value, onValueChange: (v) => onChange(v), buttons: APPEARANCES.map((a) => ({ value: a.value, label: a.label, icon: a.icon })) });
 
-// src/components/FAB.tsx
-import { FAB as PaperFAB } from "react-native-paper";
-import { jsx as jsx3 } from "react/jsx-runtime";
-function FAB(props) {
-  const defaults = usePaperDefaults();
-  return /* @__PURE__ */ jsx3(PaperFAB, { ...defaults.FAB, ...props });
-}
+// src/components/BlurView.tsx
+import { BlurView as ExpoBlurView } from "expo-blur";
+import { useContext as useContext3 } from "react";
+import { StyleSheet, View } from "react-native";
+import { useTheme as useTheme2 } from "react-native-paper";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var ELEVATION_OPACITY = { 0: 0, 1: 0.05, 2: 0.08, 3: 0.11, 4: 0.12, 5: 0.14 };
+var BlurView = ({ blur = true, children, elevation, style, ...props }) => {
+  const { dark, colors } = useTheme2();
+  const { settings } = useContext3(ThemeSettingsContext);
+  const tintOpacity = elevation !== void 0 ? ELEVATION_OPACITY[elevation] : 0;
+  const tint = tintOpacity > 0 ? /* @__PURE__ */ jsx3(View, { style: [StyleSheet.absoluteFill, { backgroundColor: colors.primary, opacity: tintOpacity }] }) : null;
+  if (blur)
+    return /* @__PURE__ */ jsxs2(ExpoBlurView, { ...props, tint: dark ? "dark" : "light", style, children: [
+      /* @__PURE__ */ jsx3(View, { style: [StyleSheet.absoluteFill, { backgroundColor: colors.surface, opacity: settings.blurTint }] }),
+      tint,
+      children
+    ] });
+  return /* @__PURE__ */ jsxs2(View, { style: [{ backgroundColor: colors.surface }, style], children: [
+    tint,
+    children
+  ] });
+};
 
-// src/components/IconButton.tsx
-import { IconButton as PaperIconButton } from "react-native-paper";
-import { jsx as jsx4 } from "react/jsx-runtime";
-function IconButton(props) {
-  const defaults = usePaperDefaults();
-  return /* @__PURE__ */ jsx4(PaperIconButton, { ...defaults.IconButton, ...props });
-}
+// src/components/BottomNavigation.tsx
+import { useEffect as useEffect3 } from "react";
+import { Platform } from "react-native";
+import { BottomNavigation as PaperBottomNavigation, useTheme as useTheme3 } from "react-native-paper";
 
-// src/components/TextInput.tsx
-import { forwardRef } from "react";
-import { TextInput as PaperTextInput } from "react-native-paper";
-import { jsx as jsx5 } from "react/jsx-runtime";
-var TextInput = forwardRef(function TextInput2(props, ref) {
-  const defaults = usePaperDefaults();
-  return /* @__PURE__ */ jsx5(PaperTextInput, { ref, ...defaults.TextInput, ...props });
-});
+// src/ThemeProvider.tsx
+import { createContext as createContext3, useCallback as useCallback2, useContext as useContext4, useEffect as useEffect2, useRef, useState as useState2 } from "react";
+import { StatusBar as StatusBar2, StyleSheet as StyleSheet2, View as View2 } from "react-native";
+import { Provider as PaperProvider } from "react-native-paper";
 
-// node_modules/redux/dist/redux.mjs
-var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
-var ActionTypes = {
-  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
-  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
-  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
+// src/useComputedTheme.ts
+import { useCallback, useEffect, useState } from "react";
+import { Appearance } from "react-native";
+import { MD3DarkTheme, MD3LightTheme } from "react-native-paper";
+
+// src/utils/colorNames.ts
+var colorNames = {
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgrey: "#a9a9a9",
+  darkgreen: "#006400",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkslategrey: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  gray: "#808080",
+  grey: "#808080",
+  green: "#008000",
+  greenyellow: "#adff2f",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgrey: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightslategrey: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  maroon: "#800000",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370db",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navy: "#000080",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  purple: "#800080",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  slategrey: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  transparent: "transparent",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  yellow: "#ffff00",
+  yellowgreen: "#9acd32"
 };
-function isPlainObject(obj) {
-  if (typeof obj !== "object" || obj === null)
-    return false;
-  let proto = obj;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
+
+// src/utils/getRgb.ts
+var getRgb = (value) => {
+  if (!value) return null;
+  let trimmed = value.trim().toLowerCase();
+  const namedColor = colorNames[trimmed];
+  if (namedColor) trimmed = namedColor;
+  const hexMatch = trimmed.match(/^#?([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i);
+  if (hexMatch) {
+    const hex = hexMatch[1];
+    let normalized = hex;
+    if (hex.length === 3) {
+      normalized = hex.split("").map((c) => c + c).join("");
+    } else if (hex.length === 8) {
+      const alpha = parseInt(hex.substring(6, 8), 16);
+      normalized = hex.substring(0, 6);
+      const intVal2 = parseInt(normalized, 16);
+      return {
+        r: intVal2 >> 16 & 255,
+        g: intVal2 >> 8 & 255,
+        b: intVal2 & 255,
+        a: alpha / 255
+      };
+    }
+    const intVal = parseInt(normalized, 16);
+    return {
+      r: intVal >> 16 & 255,
+      g: intVal >> 8 & 255,
+      b: intVal & 255
+    };
   }
-  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
-}
-function compose(...funcs) {
-  if (funcs.length === 0) {
-    return (arg) => arg;
+  const rgbMatch = trimmed.match(/^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*([0-9.]+))?\s*\)$/i);
+  if (rgbMatch) {
+    const result = {
+      r: Number(rgbMatch[1]),
+      g: Number(rgbMatch[2]),
+      b: Number(rgbMatch[3])
+    };
+    if (rgbMatch[4] !== void 0) {
+      result.a = Number(rgbMatch[4]);
+    }
+    return result;
   }
-  if (funcs.length === 1) {
-    return funcs[0];
-  }
-  return funcs.reduce((a, b) => (...args) => a(b(...args)));
-}
-function isAction(action) {
-  return isPlainObject(action) && "type" in action && typeof action.type === "string";
-}
+  return null;
+};
 
-// node_modules/immer/dist/immer.mjs
-var NOTHING = /* @__PURE__ */ Symbol.for("immer-nothing");
-var DRAFTABLE = /* @__PURE__ */ Symbol.for("immer-draftable");
-var DRAFT_STATE = /* @__PURE__ */ Symbol.for("immer-state");
-var errors = process.env.NODE_ENV !== "production" ? [
-  // All error codes, starting by 0:
-  function(plugin) {
-    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
-  },
-  function(thing) {
-    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
-  },
-  "This object has been frozen and should not be mutated",
-  function(data) {
-    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
-  },
-  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
-  "Immer forbids circular references",
-  "The first or second argument to `produce` must be a function",
-  "The third argument to `produce` must be a function or undefined",
-  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
-  "First argument to `finishDraft` must be a draft returned by `createDraft`",
-  function(thing) {
-    return `'current' expects a draft, got: ${thing}`;
-  },
-  "Object.defineProperty() cannot be used on an Immer draft",
-  "Object.setPrototypeOf() cannot be used on an Immer draft",
-  "Immer only supports deleting array indices",
-  "Immer only supports setting array indices and the 'length' property",
-  function(thing) {
-    return `'original' expects a draft, got: ${thing}`;
-  }
-  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
-  // See Patches.ts for additional errors
-] : [];
-function die(error, ...args) {
-  if (process.env.NODE_ENV !== "production") {
-    const e = errors[error];
-    const msg = isFunction(e) ? e.apply(null, args) : e;
-    throw new Error(`[Immer] ${msg}`);
+// src/utils/getHex.ts
+var getHex = (value) => {
+  const rgb = getRgb(value);
+  if (!rgb) return null;
+  const toHex = (n) => {
+    const hex = Math.round(n).toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  };
+  const hexString = `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`;
+  if (rgb.a !== void 0) {
+    return `${hexString}${toHex(rgb.a * 255)}`;
   }
-  throw new Error(
-    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
-  );
-}
-var O = Object;
-var getPrototypeOf = O.getPrototypeOf;
-var CONSTRUCTOR = "constructor";
-var PROTOTYPE = "prototype";
-var CONFIGURABLE = "configurable";
-var ENUMERABLE = "enumerable";
-var WRITABLE = "writable";
-var VALUE = "value";
-var isDraft = (value) => !!value && !!value[DRAFT_STATE];
-function isDraftable(value) {
-  if (!value)
-    return false;
-  return isPlainObject2(value) || isArray(value) || !!value[DRAFTABLE] || !!value[CONSTRUCTOR]?.[DRAFTABLE] || isMap(value) || isSet(value);
-}
-var objectCtorString = O[PROTOTYPE][CONSTRUCTOR].toString();
-var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
-function isPlainObject2(value) {
-  if (!value || !isObjectish(value))
-    return false;
-  const proto = getPrototypeOf(value);
-  if (proto === null || proto === O[PROTOTYPE])
-    return true;
-  const Ctor = O.hasOwnProperty.call(proto, CONSTRUCTOR) && proto[CONSTRUCTOR];
-  if (Ctor === Object)
-    return true;
-  if (!isFunction(Ctor))
-    return false;
-  let ctorString = cachedCtorStrings.get(Ctor);
-  if (ctorString === void 0) {
-    ctorString = Function.toString.call(Ctor);
-    cachedCtorStrings.set(Ctor, ctorString);
+  return hexString;
+};
+
+// src/utils/getBlendedColor.ts
+var getBlendedColor = (foreground, background, alpha) => {
+  const fg = getRgb(foreground);
+  const bg = getRgb(background);
+  if (!fg || !bg) return background;
+  const safeAlpha = Math.min(1, Math.max(0, alpha));
+  const r = Math.round(fg.r * safeAlpha + bg.r * (1 - safeAlpha));
+  const g = Math.round(fg.g * safeAlpha + bg.g * (1 - safeAlpha));
+  const b = Math.round(fg.b * safeAlpha + bg.b * (1 - safeAlpha));
+  return getHex(`rgb(${r}, ${g}, ${b})`) ?? background;
+};
+
+// src/utils/getTonalColor.ts
+var getTonalColor = (color, lightness) => {
+  const rgb = getRgb(color);
+  if (!rgb) return color;
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  let h = 0;
+  if (delta !== 0) {
+    if (max === r) h = (g - b) / delta % 6;
+    else if (max === g) h = (b - r) / delta + 2;
+    else h = (r - g) / delta + 4;
+    h = (h * 60 + 360) % 360;
   }
-  return ctorString === objectCtorString;
-}
-function each(obj, iter, strict = true) {
-  if (getArchtype(obj) === 0) {
-    const keys = strict ? Reflect.ownKeys(obj) : O.keys(obj);
-    keys.forEach((key) => {
-      iter(key, obj[key], obj);
-    });
+  const l = (max + min) / 2;
+  const s = delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
+  const targetL = Math.min(1, Math.max(0, lightness));
+  const c = (1 - Math.abs(2 * targetL - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = targetL - c / 2;
+  let r2 = 0, g2 = 0, b2 = 0;
+  if (h < 60) {
+    r2 = c;
+    g2 = x;
+    b2 = 0;
+  } else if (h < 120) {
+    r2 = x;
+    g2 = c;
+    b2 = 0;
+  } else if (h < 180) {
+    r2 = 0;
+    g2 = c;
+    b2 = x;
+  } else if (h < 240) {
+    r2 = 0;
+    g2 = x;
+    b2 = c;
+  } else if (h < 300) {
+    r2 = x;
+    g2 = 0;
+    b2 = c;
   } else {
-    obj.forEach((entry, index) => iter(index, entry, obj));
+    r2 = c;
+    g2 = 0;
+    b2 = x;
   }
-}
-function getArchtype(thing) {
-  const state = thing[DRAFT_STATE];
-  return state ? state.type_ : isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
-}
-var has = (thing, prop, type = getArchtype(thing)) => type === 2 ? thing.has(prop) : O[PROTOTYPE].hasOwnProperty.call(thing, prop);
-var get = (thing, prop, type = getArchtype(thing)) => (
-  // @ts-ignore
-  type === 2 ? thing.get(prop) : thing[prop]
-);
-var set = (thing, propOrOldValue, value, type = getArchtype(thing)) => {
-  if (type === 2)
-    thing.set(propOrOldValue, value);
-  else if (type === 3) {
-    thing.add(value);
-  } else
-    thing[propOrOldValue] = value;
+  const toInt = (n) => Math.round((n + m) * 255);
+  return getHex(`rgb(${toInt(r2)}, ${toInt(g2)}, ${toInt(b2)})`) ?? color;
 };
-function is(x, y) {
-  if (x === y) {
-    return x !== 0 || 1 / x === 1 / y;
-  } else {
-    return x !== x && y !== y;
+
+// src/utils/getTriadicPalette.ts
+var HARMONY_OFFSETS = {
+  analogous: [1 / 12, 2 / 12],
+  complementary: [1 / 4, 1 / 2],
+  "double-split": [1 / 12, 11 / 12],
+  "split-complementary": [5 / 12, 7 / 12],
+  square: [1 / 4, 3 / 4],
+  triadic: [1 / 3, 2 / 3]
+};
+function getTriadicPalette(primaryColor, harmony = "split-complementary") {
+  const rgb = getRgb(primaryColor);
+  if (!rgb) throw new Error(`Invalid color format: ${primaryColor}`);
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  let h = 0;
+  let s = 0;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+        break;
+      case g:
+        h = ((b - r) / d + 2) / 6;
+        break;
+      case b:
+        h = ((r - g) / d + 4) / 6;
+        break;
+    }
   }
+  const [o1, o2] = HARMONY_OFFSETS[harmony];
+  return {
+    primary: getHex(primaryColor) ?? primaryColor,
+    secondary: hslToHex((h + o1) % 1, s, l),
+    tertiary: hslToHex((h + o2) % 1, s, l)
+  };
 }
-var isArray = Array.isArray;
-var isMap = (target) => target instanceof Map;
-var isSet = (target) => target instanceof Set;
-var isObjectish = (target) => typeof target === "object";
-var isFunction = (target) => typeof target === "function";
-var isBoolean = (target) => typeof target === "boolean";
-function isArrayIndex(value) {
-  const n = +value;
-  return Number.isInteger(n) && String(n) === value;
-}
-var latest = (state) => state.copy_ || state.base_;
-var getFinalValue = (state) => state.modified_ ? state.copy_ : state.base_;
-function shallowCopy(base, strict) {
-  if (isMap(base)) {
-    return new Map(base);
-  }
-  if (isSet(base)) {
-    return new Set(base);
-  }
-  if (isArray(base))
-    return Array[PROTOTYPE].slice.call(base);
-  const isPlain = isPlainObject2(base);
-  if (strict === true || strict === "class_only" && !isPlain) {
-    const descriptors = O.getOwnPropertyDescriptors(base);
-    delete descriptors[DRAFT_STATE];
-    let keys = Reflect.ownKeys(descriptors);
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      const desc = descriptors[key];
-      if (desc[WRITABLE] === false) {
-        desc[WRITABLE] = true;
-        desc[CONFIGURABLE] = true;
-      }
-      if (desc.get || desc.set)
-        descriptors[key] = {
-          [CONFIGURABLE]: true,
-          [WRITABLE]: true,
-          // could live with !!desc.set as well here...
-          [ENUMERABLE]: desc[ENUMERABLE],
-          [VALUE]: base[key]
-        };
-    }
-    return O.create(getPrototypeOf(base), descriptors);
+function hslToHex(h, s, l) {
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h * 6 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  if (h < 1 / 6) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (h < 2 / 6) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (h < 3 / 6) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (h < 4 / 6) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (h < 5 / 6) {
+    r = x;
+    g = 0;
+    b = c;
   } else {
-    const proto = getPrototypeOf(base);
-    if (proto !== null && isPlain) {
-      return { ...base };
-    }
-    const obj = O.create(proto);
-    return O.assign(obj, base);
+    r = c;
+    g = 0;
+    b = x;
   }
+  const toHex = (value) => {
+    const hex = Math.round((value + m) * 255).toString(16);
+    return hex.length === 1 ? `0${hex}` : hex;
+  };
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
 }
-function freeze(obj, deep = false) {
-  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
-    return obj;
-  if (getArchtype(obj) > 1) {
-    O.defineProperties(obj, {
-      set: dontMutateMethodOverride,
-      add: dontMutateMethodOverride,
-      clear: dontMutateMethodOverride,
-      delete: dontMutateMethodOverride
-    });
-  }
-  O.freeze(obj);
-  if (deep)
-    each(
-      obj,
-      (_key, value) => {
-        freeze(value, true);
-      },
-      false
-    );
-  return obj;
-}
-function dontMutateFrozenCollections() {
-  die(2);
-}
-var dontMutateMethodOverride = {
-  [VALUE]: dontMutateFrozenCollections
+
+// src/utils/isDarkColor.ts
+var isDarkColor = (value) => {
+  const rgb = getRgb(value);
+  if (!rgb) return false;
+  const [r, g, b] = [rgb.r / 255, rgb.g / 255, rgb.b / 255];
+  const [rs, gs, bs] = [r, g, b].map((c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4));
+  const luminance = 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+  return luminance < 0.5;
 };
-function isFrozen(obj) {
-  if (obj === null || !isObjectish(obj))
-    return true;
-  return O.isFrozen(obj);
+
+// src/useComputedTheme.ts
+function useComputedTheme(appearance, color, harmony = "split-complementary") {
+  const [theme, setTheme] = useState(null);
+  const computeTheme = useCallback(() => {
+    let resolved = appearance;
+    if (resolved === "system") resolved = Appearance.getColorScheme();
+    if (resolved === "no-preference" || !resolved) resolved = "light";
+    const base = resolved === "dark" ? MD3DarkTheme : MD3LightTheme;
+    const _theme = {
+      ...base,
+      colors: {
+        ...base.colors,
+        elevation: { ...base.colors.elevation }
+      }
+    };
+    const palette = getTriadicPalette(color, harmony);
+    const surface = base.colors.surface;
+    _theme.colors.primary = palette.primary;
+    _theme.colors.onPrimary = getTonalColor(palette.primary, isDarkColor(palette.primary) ? 0.95 : 0.08);
+    _theme.colors.primaryContainer = getBlendedColor(palette.primary, surface, 0.15);
+    _theme.colors.onPrimaryContainer = getTonalColor(palette.primary, isDarkColor(_theme.colors.primaryContainer) ? 0.92 : 0.12);
+    _theme.colors.secondary = palette.secondary;
+    _theme.colors.onSecondary = getTonalColor(palette.secondary, isDarkColor(palette.secondary) ? 0.95 : 0.08);
+    _theme.colors.secondaryContainer = getBlendedColor(palette.secondary, surface, 0.15);
+    _theme.colors.onSecondaryContainer = getTonalColor(palette.secondary, isDarkColor(_theme.colors.secondaryContainer) ? 0.92 : 0.12);
+    _theme.colors.tertiary = palette.tertiary;
+    _theme.colors.onTertiary = getTonalColor(palette.tertiary, isDarkColor(palette.tertiary) ? 0.95 : 0.08);
+    _theme.colors.tertiaryContainer = getBlendedColor(palette.tertiary, surface, 0.15);
+    _theme.colors.onTertiaryContainer = getTonalColor(palette.tertiary, isDarkColor(_theme.colors.tertiaryContainer) ? 0.92 : 0.12);
+    const blended = getBlendedColor(color, palette.secondary, 0.5);
+    const tintSurface = (alpha) => getBlendedColor(blended, surface, alpha);
+    _theme.colors.background = base.dark ? "#0F0F0F" : "#F0F0F0";
+    _theme.colors.surface = surface;
+    _theme.colors.surfaceVariant = tintSurface(0.2);
+    _theme.colors.outline = getBlendedColor(color, base.colors.outline, 0.45);
+    const grey = base.dark ? "#424242" : "#c2c2c2";
+    const blendedGrey = getBlendedColor(blended, grey, 0.05);
+    _theme.colors.elevation = {
+      ..._theme.colors.elevation,
+      level1: _theme.colors.surface,
+      level2: getBlendedColor(blendedGrey, _theme.colors.surface, 0.25),
+      level3: getBlendedColor(blendedGrey, _theme.colors.surface, 0.4),
+      level4: getBlendedColor(blendedGrey, _theme.colors.surface, 0.55),
+      level5: getBlendedColor(blendedGrey, _theme.colors.surface, 0.7)
+    };
+    setTheme(_theme);
+  }, [appearance, color, harmony]);
+  useEffect(() => {
+    computeTheme();
+  }, [computeTheme]);
+  useEffect(() => {
+    const subscription = Appearance.addChangeListener(computeTheme);
+    return subscription.remove;
+  }, [computeTheme]);
+  return theme;
 }
-var PluginMapSet = "MapSet";
-var PluginPatches = "Patches";
-var PluginArrayMethods = "ArrayMethods";
-var plugins = {};
-function getPlugin(pluginKey) {
-  const plugin = plugins[pluginKey];
-  if (!plugin) {
-    die(0, pluginKey);
-  }
-  return plugin;
+
+// src/ThemeProvider.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var NavBarContext = createContext3({});
+var useNavBarContext = () => useContext4(NavBarContext);
+function Provider({ overrides, onChange, children, defaults, onNavBarChange, onReady, statusBarProps, style }) {
+  const [settings, setSettings] = useState2(() => ({ ...defaultThemeSettings, ...overrides }));
+  const set2 = useCallback2(
+    (patch) => {
+      setSettings((prev) => {
+        const next = { ...prev, ...patch };
+        onChange?.(next);
+        return next;
+      });
+    },
+    [onChange]
+  );
+  const theme = useComputedTheme(settings.appearance, settings.color, settings.harmony);
+  const called = useRef(false);
+  useEffect2(() => {
+    if (theme && !called.current) {
+      called.current = true;
+      onReady?.();
+    }
+  }, [theme, onReady]);
+  if (!theme) return null;
+  return /* @__PURE__ */ jsx4(ThemeSettingsContext.Provider, { value: { settings, set: set2 }, children: /* @__PURE__ */ jsxs3(PaperProvider, { theme, children: [
+    /* @__PURE__ */ jsx4(StatusBar2, { backgroundColor: theme.colors.background, barStyle: theme.dark ? "light-content" : "dark-content", ...statusBarProps }),
+    /* @__PURE__ */ jsx4(PaperDefaultsContext.Provider, { value: defaults ?? {}, children: /* @__PURE__ */ jsx4(NavBarContext.Provider, { value: { onNavBarChange }, children: /* @__PURE__ */ jsx4(View2, { style: [styles.flex, { backgroundColor: theme.colors.background }, style], children }) }) })
+  ] }) });
 }
-var isPluginLoaded = (pluginKey) => !!plugins[pluginKey];
-var currentScope;
-var getCurrentScope = () => currentScope;
-var createScope = (parent_, immer_) => ({
-  drafts_: [],
-  parent_,
-  immer_,
-  // Whenever the modified draft contains a draft from another scope, we
-  // need to prevent auto-freezing so the unowned draft can be finalized.
-  canAutoFreeze_: true,
-  unfinalizedDrafts_: 0,
-  handledSet_: /* @__PURE__ */ new Set(),
-  processedForPatches_: /* @__PURE__ */ new Set(),
-  mapSetPlugin_: isPluginLoaded(PluginMapSet) ? getPlugin(PluginMapSet) : void 0,
-  arrayMethodsPlugin_: isPluginLoaded(PluginArrayMethods) ? getPlugin(PluginArrayMethods) : void 0
+var styles = StyleSheet2.create({
+  flex: { flex: 1 }
 });
-function usePatchesInScope(scope, patchListener) {
-  if (patchListener) {
-    scope.patchPlugin_ = getPlugin(PluginPatches);
-    scope.patches_ = [];
-    scope.inversePatches_ = [];
-    scope.patchListener_ = patchListener;
-  }
+
+// src/components/BottomNavigation.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function useNavigationBarSync() {
+  const theme = useTheme3();
+  const { onNavBarChange } = useNavBarContext();
+  useEffect3(() => {
+    if (Platform.OS !== "android" || !onNavBarChange) return;
+    onNavBarChange(theme.colors.surface, theme.dark);
+  }, [theme, onNavBarChange]);
+}
+function BottomNavigationComponent(props) {
+  const defaults = usePaperDefaults();
+  useNavigationBarSync();
+  return /* @__PURE__ */ jsx5(PaperBottomNavigation, { ...defaults.BottomNavigation, ...props });
 }
-function revokeScope(scope) {
-  leaveScope(scope);
-  scope.drafts_.forEach(revokeDraft);
-  scope.drafts_ = null;
+function Bar(props) {
+  useNavigationBarSync();
+  return /* @__PURE__ */ jsx5(PaperBottomNavigation.Bar, { ...props });
 }
-function leaveScope(scope) {
-  if (scope === currentScope) {
-    currentScope = scope.parent_;
-  }
+BottomNavigationComponent.Bar = Bar;
+BottomNavigationComponent.SceneMap = PaperBottomNavigation.SceneMap;
+var BottomNavigation = BottomNavigationComponent;
+
+// src/components/Button.tsx
+import { Button as PaperButton } from "react-native-paper";
+import { jsx as jsx6 } from "react/jsx-runtime";
+function Button(props) {
+  const defaults = usePaperDefaults();
+  return /* @__PURE__ */ jsx6(PaperButton, { ...defaults.Button, ...props });
 }
-var enterScope = (immer2) => currentScope = createScope(currentScope, immer2);
-function revokeDraft(draft) {
-  const state = draft[DRAFT_STATE];
-  if (state.type_ === 0 || state.type_ === 1)
-    state.revoke_();
-  else
-    state.revoked_ = true;
+
+// src/components/Chip.tsx
+import { Chip as PaperChip } from "react-native-paper";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function Chip(props) {
+  const defaults = usePaperDefaults();
+  return /* @__PURE__ */ jsx7(PaperChip, { ...defaults.Chip, ...props });
 }
-function processResult(result, scope) {
-  scope.unfinalizedDrafts_ = scope.drafts_.length;
-  const baseDraft = scope.drafts_[0];
-  const isReplaced = result !== void 0 && result !== baseDraft;
-  if (isReplaced) {
-    if (baseDraft[DRAFT_STATE].modified_) {
-      revokeScope(scope);
-      die(4);
-    }
-    if (isDraftable(result)) {
-      result = finalize(scope, result);
+
+// src/components/ColorPicker.tsx
+import { useState as useState4 } from "react";
+import { StyleSheet as StyleSheet4, TouchableOpacity, View as View4 } from "react-native";
+import { Icon, TouchableRipple } from "react-native-paper";
+
+// src/components/Dialog.tsx
+import { useEffect as useEffect4, useRef as useRef2, useState as useState3 } from "react";
+import { Animated, StyleSheet as StyleSheet3, TouchableWithoutFeedback, View as View3 } from "react-native";
+import { Dialog as PaperDialog, Portal, useTheme as useTheme4 } from "react-native-paper";
+import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+function DialogComponent({ blur: blurProp, visible, onDismiss, children, style, ...rest }) {
+  const blur = useBlur(blurProp);
+  const { roundness, colors } = useTheme4();
+  const opacity = useRef2(new Animated.Value(0)).current;
+  const [mounted, setMounted] = useState3(visible);
+  useEffect4(() => {
+    if (visible) {
+      setMounted(true);
+      Animated.timing(opacity, { toValue: 1, duration: 200, useNativeDriver: true }).start();
+    } else {
+      Animated.timing(opacity, { toValue: 0, duration: 150, useNativeDriver: true }).start(() => setMounted(false));
     }
-    const { patchPlugin_ } = scope;
-    if (patchPlugin_) {
-      patchPlugin_.generateReplacementPatches_(
-        baseDraft[DRAFT_STATE].base_,
-        result,
-        scope
-      );
+  }, [visible]);
+  if (!blur) {
+    return /* @__PURE__ */ jsx8(PaperDialog, { visible, onDismiss, style, ...rest, children });
+  }
+  if (!mounted) return null;
+  return /* @__PURE__ */ jsx8(Portal, { children: /* @__PURE__ */ jsxs4(Animated.View, { style: [StyleSheet3.absoluteFill, { opacity }], pointerEvents: visible ? "box-none" : "none", children: [
+    /* @__PURE__ */ jsx8(TouchableWithoutFeedback, { onPress: onDismiss, children: /* @__PURE__ */ jsx8(View3, { style: [StyleSheet3.absoluteFill, { backgroundColor: colors.backdrop }] }) }),
+    /* @__PURE__ */ jsx8(View3, { style: styles2.wrapper, pointerEvents: "box-none", children: /* @__PURE__ */ jsx8(BlurView, { style: [styles2.card, { borderRadius: roundness * 7 }], children }) })
+  ] }) });
+}
+DialogComponent.Title = PaperDialog.Title;
+DialogComponent.Content = PaperDialog.Content;
+DialogComponent.Actions = PaperDialog.Actions;
+DialogComponent.ScrollArea = PaperDialog.ScrollArea;
+var Dialog = DialogComponent;
+var styles2 = StyleSheet3.create({
+  card: { overflow: "hidden" },
+  wrapper: { flex: 1, justifyContent: "center", paddingHorizontal: 26 }
+});
+
+// src/components/ColorPicker.tsx
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+var defaultColors = [
+  { label: "Red", value: "#f44336" },
+  { label: "Coral", value: "#ff5722" },
+  { label: "Orange", value: "#ff6d00" },
+  { label: "Amber", value: "#ff9800" },
+  { label: "Yellow", value: "#fdd835" },
+  { label: "Lime", value: "#8bc34a" },
+  { label: "Emerald", value: "#4caf50" },
+  { label: "Teal", value: "#009688" },
+  { label: "Cyan", value: "#00bcd4" },
+  { label: "Blue", value: "#2196f3" },
+  { label: "Indigo", value: "#3f51b5" },
+  { label: "Deep Purple", value: "#673ab7" },
+  { label: "Violet", value: "#9c27b0" },
+  { label: "Magenta", value: "#d500f9" },
+  { label: "Pink", value: "#ec407a" },
+  { label: "Rose", value: "#e91e63" },
+  { label: "Brown", value: "#795548" },
+  { label: "Blue Grey", value: "#607d8b" }
+];
+var ColorPicker = ({ value, onChange, colors = defaultColors, blur: blurProp }) => {
+  const blur = useBlur(blurProp);
+  const [open, setOpen] = useState4(false);
+  return /* @__PURE__ */ jsxs5(Fragment2, { children: [
+    /* @__PURE__ */ jsx9(TouchableRipple, { onPress: () => setOpen(true), style: [styles3.trigger, { backgroundColor: value }], borderless: true, children: /* @__PURE__ */ jsx9(Icon, { source: "palette", size: 20, color: "white" }) }),
+    /* @__PURE__ */ jsx9(Dialog, { blur, visible: open, onDismiss: () => setOpen(false), children: /* @__PURE__ */ jsx9(Dialog.Content, { children: /* @__PURE__ */ jsx9(View4, { style: styles3.swatches, children: colors.map(({ value: hex }) => /* @__PURE__ */ jsx9(
+      TouchableOpacity,
+      {
+        onPress: () => {
+          onChange(hex);
+          setOpen(false);
+        },
+        style: [styles3.swatch, { backgroundColor: hex }, value === hex && styles3.selected],
+        children: value === hex && /* @__PURE__ */ jsx9(Icon, { source: "check", size: 20, color: "white" })
+      },
+      hex
+    )) }) }) })
+  ] });
+};
+var styles3 = StyleSheet4.create({
+  selected: { borderColor: "white", borderWidth: 3 },
+  swatch: { alignItems: "center", borderRadius: 24, height: 48, justifyContent: "center", width: 48 },
+  swatches: { flexDirection: "row", flexWrap: "wrap", gap: 12, paddingTop: 12 },
+  trigger: { alignItems: "center", alignSelf: "flex-start", borderRadius: 24, height: 48, justifyContent: "center", width: 48 }
+});
+
+// src/components/FAB.tsx
+import { FAB as PaperFAB } from "react-native-paper";
+import { jsx as jsx10 } from "react/jsx-runtime";
+function FAB(props) {
+  const defaults = usePaperDefaults();
+  return /* @__PURE__ */ jsx10(PaperFAB, { ...defaults.FAB, ...props });
+}
+
+// src/components/HarmonyPicker.tsx
+import { useState as useState5 } from "react";
+import { Button as Button2 } from "react-native-paper";
+
+// src/components/Menu.tsx
+import { StyleSheet as StyleSheet5 } from "react-native";
+import { Menu as PaperMenu } from "react-native-paper";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var MenuComponent = ({ blur: blurProp, children, ...props }) => {
+  const blur = useBlur(blurProp);
+  return /* @__PURE__ */ jsx11(PaperMenu, { ...props, contentStyle: [styles4.content, props.contentStyle], children: /* @__PURE__ */ jsx11(BlurView, { blur, children }) });
+};
+var Menu = Object.assign(MenuComponent, {
+  Item: PaperMenu.Item
+});
+var styles4 = StyleSheet5.create({
+  content: { backgroundColor: "transparent", paddingVertical: 0 }
+});
+
+// src/components/HarmonyPicker.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+var HARMONIES = [
+  { label: "Triadic", value: "triadic", icon: "triangle-outline" },
+  { label: "Split", value: "split-complementary", icon: "arrow-split-vertical" },
+  { label: "Analogous", value: "analogous", icon: "ray-end-arrow" },
+  { label: "Square", value: "square", icon: "square-outline" },
+  { label: "Complement", value: "complementary", icon: "circle-half-full" },
+  { label: "Dbl Split", value: "double-split", icon: "arrow-expand-horizontal" }
+];
+var HarmonyPicker = ({ value, onChange, blur: blurProp }) => {
+  const blur = useBlur(blurProp);
+  const [open, setOpen] = useState5(false);
+  const selected = HARMONIES.find((h) => h.value === value);
+  return /* @__PURE__ */ jsx12(
+    Menu,
+    {
+      blur,
+      visible: open,
+      onDismiss: () => setOpen(false),
+      anchor: /* @__PURE__ */ jsx12(Button2, { mode: "outlined", icon: selected.icon, onPress: () => setOpen(true), children: selected.label }),
+      children: HARMONIES.map((h) => /* @__PURE__ */ jsx12(
+        Menu.Item,
+        {
+          leadingIcon: h.value === value ? "check" : h.icon,
+          title: h.label,
+          onPress: () => {
+            onChange(h.value);
+            setOpen(false);
+          }
+        },
+        h.value
+      ))
     }
-  } else {
-    result = finalize(scope, baseDraft);
-  }
-  maybeFreeze(scope, result, true);
-  revokeScope(scope);
-  if (scope.patches_) {
-    scope.patchListener_(scope.patches_, scope.inversePatches_);
+  );
+};
+
+// src/components/IconButton.tsx
+import { IconButton as PaperIconButton } from "react-native-paper";
+import { jsx as jsx13 } from "react/jsx-runtime";
+function IconButton(props) {
+  const defaults = usePaperDefaults();
+  return /* @__PURE__ */ jsx13(PaperIconButton, { ...defaults.IconButton, ...props });
+}
+
+// src/components/TextInput.tsx
+import { forwardRef } from "react";
+import { TextInput as PaperTextInput } from "react-native-paper";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var TextInput = forwardRef(function TextInput2(props, ref) {
+  const defaults = usePaperDefaults();
+  return /* @__PURE__ */ jsx14(PaperTextInput, { ref, ...defaults.TextInput, ...props });
+});
+
+// node_modules/redux/dist/redux.mjs
+var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
+var ActionTypes = {
+  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
+  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
+  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
+};
+function isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  let proto = obj;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
   }
-  return result !== NOTHING ? result : void 0;
+  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
 }
-function finalize(rootScope, value) {
-  if (isFrozen(value))
-    return value;
-  const state = value[DRAFT_STATE];
-  if (!state) {
-    const finalValue = handleValue(value, rootScope.handledSet_, rootScope);
-    return finalValue;
+function compose(...funcs) {
+  if (funcs.length === 0) {
+    return (arg) => arg;
   }
-  if (!isSameScope(state, rootScope)) {
-    return value;
-  }
-  if (!state.modified_) {
-    return state.base_;
-  }
-  if (!state.finalized_) {
-    const { callbacks_ } = state;
-    if (callbacks_) {
-      while (callbacks_.length > 0) {
-        const callback = callbacks_.pop();
-        callback(rootScope);
-      }
-    }
-    generatePatchesAndFinalize(state, rootScope);
+  if (funcs.length === 1) {
+    return funcs[0];
   }
-  return state.copy_;
+  return funcs.reduce((a, b) => (...args) => a(b(...args)));
 }
-function maybeFreeze(scope, value, deep = false) {
-  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
-    freeze(value, deep);
+function isAction(action) {
+  return isPlainObject(action) && "type" in action && typeof action.type === "string";
+}
+
+// node_modules/immer/dist/immer.mjs
+var NOTHING = /* @__PURE__ */ Symbol.for("immer-nothing");
+var DRAFTABLE = /* @__PURE__ */ Symbol.for("immer-draftable");
+var DRAFT_STATE = /* @__PURE__ */ Symbol.for("immer-state");
+var errors = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(plugin) {
+    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
+  },
+  function(thing) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(data) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(thing) {
+    return `'current' expects a draft, got: ${thing}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(thing) {
+    return `'original' expects a draft, got: ${thing}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function die(error, ...args) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = errors[error];
+    const msg = isFunction(e) ? e.apply(null, args) : e;
+    throw new Error(`[Immer] ${msg}`);
   }
+  throw new Error(
+    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
+  );
 }
-function markStateFinalized(state) {
-  state.finalized_ = true;
-  state.scope_.unfinalizedDrafts_--;
+var O = Object;
+var getPrototypeOf = O.getPrototypeOf;
+var CONSTRUCTOR = "constructor";
+var PROTOTYPE = "prototype";
+var CONFIGURABLE = "configurable";
+var ENUMERABLE = "enumerable";
+var WRITABLE = "writable";
+var VALUE = "value";
+var isDraft = (value) => !!value && !!value[DRAFT_STATE];
+function isDraftable(value) {
+  if (!value)
+    return false;
+  return isPlainObject2(value) || isArray(value) || !!value[DRAFTABLE] || !!value[CONSTRUCTOR]?.[DRAFTABLE] || isMap(value) || isSet(value);
 }
-var isSameScope = (state, rootScope) => state.scope_ === rootScope;
-var EMPTY_LOCATIONS_RESULT = [];
-function updateDraftInParent(parent, draftValue, finalizedValue, originalKey) {
-  const parentCopy = latest(parent);
-  const parentType = parent.type_;
-  if (originalKey !== void 0) {
-    const currentValue = get(parentCopy, originalKey, parentType);
-    if (currentValue === draftValue) {
-      set(parentCopy, originalKey, finalizedValue, parentType);
-      return;
-    }
+var objectCtorString = O[PROTOTYPE][CONSTRUCTOR].toString();
+var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
+function isPlainObject2(value) {
+  if (!value || !isObjectish(value))
+    return false;
+  const proto = getPrototypeOf(value);
+  if (proto === null || proto === O[PROTOTYPE])
+    return true;
+  const Ctor = O.hasOwnProperty.call(proto, CONSTRUCTOR) && proto[CONSTRUCTOR];
+  if (Ctor === Object)
+    return true;
+  if (!isFunction(Ctor))
+    return false;
+  let ctorString = cachedCtorStrings.get(Ctor);
+  if (ctorString === void 0) {
+    ctorString = Function.toString.call(Ctor);
+    cachedCtorStrings.set(Ctor, ctorString);
   }
-  if (!parent.draftLocations_) {
-    const draftLocations = parent.draftLocations_ = /* @__PURE__ */ new Map();
-    each(parentCopy, (key, value) => {
-      if (isDraft(value)) {
-        const keys = draftLocations.get(value) || [];
-        keys.push(key);
-        draftLocations.set(value, keys);
-      }
+  return ctorString === objectCtorString;
+}
+function each(obj, iter, strict = true) {
+  if (getArchtype(obj) === 0) {
+    const keys = strict ? Reflect.ownKeys(obj) : O.keys(obj);
+    keys.forEach((key) => {
+      iter(key, obj[key], obj);
     });
-  }
-  const locations = parent.draftLocations_.get(draftValue) ?? EMPTY_LOCATIONS_RESULT;
-  for (const location of locations) {
-    set(parentCopy, location, finalizedValue, parentType);
+  } else {
+    obj.forEach((entry, index) => iter(index, entry, obj));
   }
 }
-function registerChildFinalizationCallback(parent, child, key) {
-  parent.callbacks_.push(function childCleanup(rootScope) {
-    const state = child;
-    if (!state || !isSameScope(state, rootScope)) {
-      return;
-    }
-    rootScope.mapSetPlugin_?.fixSetContents(state);
-    const finalizedValue = getFinalValue(state);
-    updateDraftInParent(parent, state.draft_ ?? state, finalizedValue, key);
-    generatePatchesAndFinalize(state, rootScope);
-  });
+function getArchtype(thing) {
+  const state = thing[DRAFT_STATE];
+  return state ? state.type_ : isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
 }
-function generatePatchesAndFinalize(state, rootScope) {
-  const shouldFinalize = state.modified_ && !state.finalized_ && (state.type_ === 3 || state.type_ === 1 && state.allIndicesReassigned_ || (state.assigned_?.size ?? 0) > 0);
-  if (shouldFinalize) {
-    const { patchPlugin_ } = rootScope;
-    if (patchPlugin_) {
-      const basePath = patchPlugin_.getPath(state);
-      if (basePath) {
-        patchPlugin_.generatePatches_(state, basePath, rootScope);
-      }
-    }
-    markStateFinalized(state);
+var has = (thing, prop, type = getArchtype(thing)) => type === 2 ? thing.has(prop) : O[PROTOTYPE].hasOwnProperty.call(thing, prop);
+var get = (thing, prop, type = getArchtype(thing)) => (
+  // @ts-ignore
+  type === 2 ? thing.get(prop) : thing[prop]
+);
+var set = (thing, propOrOldValue, value, type = getArchtype(thing)) => {
+  if (type === 2)
+    thing.set(propOrOldValue, value);
+  else if (type === 3) {
+    thing.add(value);
+  } else
+    thing[propOrOldValue] = value;
+};
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
   }
 }
-function handleCrossReference(target, key, value) {
-  const { scope_ } = target;
-  if (isDraft(value)) {
-    const state = value[DRAFT_STATE];
-    if (isSameScope(state, scope_)) {
-      state.callbacks_.push(function crossReferenceCleanup() {
-        prepareCopy(target);
-        const finalizedValue = getFinalValue(state);
-        updateDraftInParent(target, value, finalizedValue, key);
-      });
-    }
-  } else if (isDraftable(value)) {
-    target.callbacks_.push(function nestedDraftCleanup() {
-      const targetCopy = latest(target);
-      if (target.type_ === 3) {
-        if (targetCopy.has(value)) {
-          handleValue(value, scope_.handledSet_, scope_);
-        }
-      } else {
-        if (get(targetCopy, key, target.type_) === value) {
-          if (scope_.drafts_.length > 1 && (target.assigned_.get(key) ?? false) === true && target.copy_) {
-            handleValue(
-              get(target.copy_, key, target.type_),
-              scope_.handledSet_,
-              scope_
-            );
-          }
-        }
-      }
-    });
-  }
+var isArray = Array.isArray;
+var isMap = (target) => target instanceof Map;
+var isSet = (target) => target instanceof Set;
+var isObjectish = (target) => typeof target === "object";
+var isFunction = (target) => typeof target === "function";
+var isBoolean = (target) => typeof target === "boolean";
+function isArrayIndex(value) {
+  const n = +value;
+  return Number.isInteger(n) && String(n) === value;
 }
-function handleValue(target, handledSet, rootScope) {
-  if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
-    return target;
+var latest = (state) => state.copy_ || state.base_;
+var getFinalValue = (state) => state.modified_ ? state.copy_ : state.base_;
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
   }
-  if (isDraft(target) || handledSet.has(target) || !isDraftable(target) || isFrozen(target)) {
-    return target;
+  if (isSet(base)) {
+    return new Set(base);
   }
-  handledSet.add(target);
-  each(target, (key, value) => {
-    if (isDraft(value)) {
-      const state = value[DRAFT_STATE];
-      if (isSameScope(state, rootScope)) {
-        const updatedValue = getFinalValue(state);
-        set(target, key, updatedValue, target.type_);
-        markStateFinalized(state);
+  if (isArray(base))
+    return Array[PROTOTYPE].slice.call(base);
+  const isPlain = isPlainObject2(base);
+  if (strict === true || strict === "class_only" && !isPlain) {
+    const descriptors = O.getOwnPropertyDescriptors(base);
+    delete descriptors[DRAFT_STATE];
+    let keys = Reflect.ownKeys(descriptors);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const desc = descriptors[key];
+      if (desc[WRITABLE] === false) {
+        desc[WRITABLE] = true;
+        desc[CONFIGURABLE] = true;
       }
-    } else if (isDraftable(value)) {
-      handleValue(value, handledSet, rootScope);
-    }
-  });
-  return target;
-}
-function createProxyProxy(base, parent) {
-  const baseIsArray = isArray(base);
-  const state = {
-    type_: baseIsArray ? 1 : 0,
-    // Track which produce call this is associated with.
-    scope_: parent ? parent.scope_ : getCurrentScope(),
-    // True for both shallow and deep changes.
-    modified_: false,
-    // Used during finalization.
-    finalized_: false,
-    // Track which properties have been assigned (true) or deleted (false).
-    // actually instantiated in `prepareCopy()`
-    assigned_: void 0,
-    // The parent draft state.
-    parent_: parent,
-    // The base state.
-    base_: base,
-    // The base proxy.
-    draft_: null,
-    // set below
-    // The base copy with any updated values.
-    copy_: null,
-    // Called by the `produce` function.
-    revoke_: null,
-    isManual_: false,
-    // `callbacks` actually gets assigned in `createProxy`
-    callbacks_: void 0
-  };
-  let target = state;
-  let traps = objectTraps;
-  if (baseIsArray) {
-    target = [state];
-    traps = arrayTraps;
-  }
-  const { revoke, proxy } = Proxy.revocable(target, traps);
-  state.draft_ = proxy;
-  state.revoke_ = revoke;
-  return [proxy, state];
-}
-var objectTraps = {
-  get(state, prop) {
-    if (prop === DRAFT_STATE)
-      return state;
-    let arrayPlugin = state.scope_.arrayMethodsPlugin_;
-    const isArrayWithStringProp = state.type_ === 1 && typeof prop === "string";
-    if (isArrayWithStringProp) {
-      if (arrayPlugin?.isArrayOperationMethod(prop)) {
-        return arrayPlugin.createMethodInterceptor(state, prop);
-      }
-    }
-    const source = latest(state);
-    if (!has(source, prop, state.type_)) {
-      return readPropFromProto(state, source, prop);
-    }
-    const value = source[prop];
-    if (state.finalized_ || !isDraftable(value)) {
-      return value;
-    }
-    if (isArrayWithStringProp && state.operationMethod && arrayPlugin?.isMutatingArrayMethod(
-      state.operationMethod
-    ) && isArrayIndex(prop)) {
-      return value;
-    }
-    if (value === peek(state.base_, prop)) {
-      prepareCopy(state);
-      const childKey = state.type_ === 1 ? +prop : prop;
-      const childDraft = createProxy(state.scope_, value, state, childKey);
-      return state.copy_[childKey] = childDraft;
-    }
-    return value;
-  },
-  has(state, prop) {
-    return prop in latest(state);
-  },
-  ownKeys(state) {
-    return Reflect.ownKeys(latest(state));
-  },
-  set(state, prop, value) {
-    const desc = getDescriptorFromProto(latest(state), prop);
-    if (desc?.set) {
-      desc.set.call(state.draft_, value);
-      return true;
-    }
-    if (!state.modified_) {
-      const current2 = peek(latest(state), prop);
-      const currentState = current2?.[DRAFT_STATE];
-      if (currentState && currentState.base_ === value) {
-        state.copy_[prop] = value;
-        state.assigned_.set(prop, false);
-        return true;
-      }
-      if (is(value, current2) && (value !== void 0 || has(state.base_, prop, state.type_)))
-        return true;
-      prepareCopy(state);
-      markChanged(state);
-    }
-    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
-    (value !== void 0 || prop in state.copy_) || // special case: NaN
-    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
-      return true;
-    state.copy_[prop] = value;
-    state.assigned_.set(prop, true);
-    handleCrossReference(state, prop, value);
-    return true;
-  },
-  deleteProperty(state, prop) {
-    prepareCopy(state);
-    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
-      state.assigned_.set(prop, false);
-      markChanged(state);
-    } else {
-      state.assigned_.delete(prop);
+      if (desc.get || desc.set)
+        descriptors[key] = {
+          [CONFIGURABLE]: true,
+          [WRITABLE]: true,
+          // could live with !!desc.set as well here...
+          [ENUMERABLE]: desc[ENUMERABLE],
+          [VALUE]: base[key]
+        };
     }
-    if (state.copy_) {
-      delete state.copy_[prop];
+    return O.create(getPrototypeOf(base), descriptors);
+  } else {
+    const proto = getPrototypeOf(base);
+    if (proto !== null && isPlain) {
+      return { ...base };
     }
-    return true;
-  },
-  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
-  // the same guarantee in ES5 mode.
-  getOwnPropertyDescriptor(state, prop) {
-    const owner = latest(state);
-    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
-    if (!desc)
-      return desc;
-    return {
-      [WRITABLE]: true,
-      [CONFIGURABLE]: state.type_ !== 1 || prop !== "length",
-      [ENUMERABLE]: desc[ENUMERABLE],
-      [VALUE]: owner[prop]
-    };
-  },
-  defineProperty() {
-    die(11);
-  },
-  getPrototypeOf(state) {
-    return getPrototypeOf(state.base_);
-  },
-  setPrototypeOf() {
-    die(12);
+    const obj = O.create(proto);
+    return O.assign(obj, base);
   }
-};
-var arrayTraps = {};
-for (let key in objectTraps) {
-  let fn = objectTraps[key];
-  arrayTraps[key] = function() {
-    const args = arguments;
-    args[0] = args[0][0];
-    return fn.apply(this, args);
-  };
-}
-arrayTraps.deleteProperty = function(state, prop) {
-  if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop)))
-    die(13);
-  return arrayTraps.set.call(this, state, prop, void 0);
-};
-arrayTraps.set = function(state, prop, value) {
-  if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop)))
-    die(14);
-  return objectTraps.set.call(this, state[0], prop, value, state[0]);
-};
-function peek(draft, prop) {
-  const state = draft[DRAFT_STATE];
-  const source = state ? latest(state) : draft;
-  return source[prop];
 }
-function readPropFromProto(state, source, prop) {
-  const desc = getDescriptorFromProto(source, prop);
-  return desc ? VALUE in desc ? desc[VALUE] : (
-    // This is a very special case, if the prop is a getter defined by the
-    // prototype, we should invoke it with the draft as context!
-    desc.get?.call(state.draft_)
-  ) : void 0;
-}
-function getDescriptorFromProto(source, prop) {
-  if (!(prop in source))
-    return void 0;
-  let proto = getPrototypeOf(source);
-  while (proto) {
-    const desc = Object.getOwnPropertyDescriptor(proto, prop);
-    if (desc)
-      return desc;
-    proto = getPrototypeOf(proto);
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    O.defineProperties(obj, {
+      set: dontMutateMethodOverride,
+      add: dontMutateMethodOverride,
+      clear: dontMutateMethodOverride,
+      delete: dontMutateMethodOverride
+    });
   }
-  return void 0;
+  O.freeze(obj);
+  if (deep)
+    each(
+      obj,
+      (_key, value) => {
+        freeze(value, true);
+      },
+      false
+    );
+  return obj;
 }
-function markChanged(state) {
-  if (!state.modified_) {
-    state.modified_ = true;
-    if (state.parent_) {
-      markChanged(state.parent_);
-    }
-  }
+function dontMutateFrozenCollections() {
+  die(2);
 }
-function prepareCopy(state) {
-  if (!state.copy_) {
-    state.assigned_ = /* @__PURE__ */ new Map();
-    state.copy_ = shallowCopy(
-      state.base_,
-      state.scope_.immer_.useStrictShallowCopy_
-    );
+var dontMutateMethodOverride = {
+  [VALUE]: dontMutateFrozenCollections
+};
+function isFrozen(obj) {
+  if (obj === null || !isObjectish(obj))
+    return true;
+  return O.isFrozen(obj);
+}
+var PluginMapSet = "MapSet";
+var PluginPatches = "Patches";
+var PluginArrayMethods = "ArrayMethods";
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
   }
+  return plugin;
 }
-var Immer2 = class {
-  constructor(config) {
-    this.autoFreeze_ = true;
-    this.useStrictShallowCopy_ = false;
-    this.useStrictIteration_ = false;
-    this.produce = (base, recipe, patchListener) => {
-      if (isFunction(base) && !isFunction(recipe)) {
-        const defaultBase = recipe;
-        recipe = base;
-        const self = this;
-        return function curriedProduce(base2 = defaultBase, ...args) {
-          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
-        };
-      }
-      if (!isFunction(recipe))
-        die(6);
-      if (patchListener !== void 0 && !isFunction(patchListener))
-        die(7);
-      let result;
-      if (isDraftable(base)) {
-        const scope = enterScope(this);
-        const proxy = createProxy(scope, base, void 0);
-        let hasError = true;
-        try {
-          result = recipe(proxy);
-          hasError = false;
-        } finally {
-          if (hasError)
-            revokeScope(scope);
-          else
-            leaveScope(scope);
-        }
-        usePatchesInScope(scope, patchListener);
-        return processResult(result, scope);
-      } else if (!base || !isObjectish(base)) {
-        result = recipe(base);
-        if (result === void 0)
-          result = base;
-        if (result === NOTHING)
-          result = void 0;
-        if (this.autoFreeze_)
-          freeze(result, true);
-        if (patchListener) {
-          const p = [];
-          const ip = [];
-          getPlugin(PluginPatches).generateReplacementPatches_(base, result, {
-            patches_: p,
-            inversePatches_: ip
-          });
-          patchListener(p, ip);
-        }
-        return result;
-      } else
-        die(1, base);
-    };
-    this.produceWithPatches = (base, recipe) => {
-      if (isFunction(base)) {
-        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
-      }
-      let patches, inversePatches;
-      const result = this.produce(base, recipe, (p, ip) => {
-        patches = p;
-        inversePatches = ip;
-      });
-      return [result, patches, inversePatches];
-    };
-    if (isBoolean(config?.autoFreeze))
-      this.setAutoFreeze(config.autoFreeze);
-    if (isBoolean(config?.useStrictShallowCopy))
-      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
-    if (isBoolean(config?.useStrictIteration))
-      this.setUseStrictIteration(config.useStrictIteration);
+var isPluginLoaded = (pluginKey) => !!plugins[pluginKey];
+var currentScope;
+var getCurrentScope = () => currentScope;
+var createScope = (parent_, immer_) => ({
+  drafts_: [],
+  parent_,
+  immer_,
+  // Whenever the modified draft contains a draft from another scope, we
+  // need to prevent auto-freezing so the unowned draft can be finalized.
+  canAutoFreeze_: true,
+  unfinalizedDrafts_: 0,
+  handledSet_: /* @__PURE__ */ new Set(),
+  processedForPatches_: /* @__PURE__ */ new Set(),
+  mapSetPlugin_: isPluginLoaded(PluginMapSet) ? getPlugin(PluginMapSet) : void 0,
+  arrayMethodsPlugin_: isPluginLoaded(PluginArrayMethods) ? getPlugin(PluginArrayMethods) : void 0
+});
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    scope.patchPlugin_ = getPlugin(PluginPatches);
+    scope.patches_ = [];
+    scope.inversePatches_ = [];
+    scope.patchListener_ = patchListener;
   }
-  createDraft(base) {
-    if (!isDraftable(base))
-      die(8);
-    if (isDraft(base))
-      base = current(base);
-    const scope = enterScope(this);
-    const proxy = createProxy(scope, base, void 0);
-    proxy[DRAFT_STATE].isManual_ = true;
-    leaveScope(scope);
-    return proxy;
+}
+function revokeScope(scope) {
+  leaveScope(scope);
+  scope.drafts_.forEach(revokeDraft);
+  scope.drafts_ = null;
+}
+function leaveScope(scope) {
+  if (scope === currentScope) {
+    currentScope = scope.parent_;
   }
-  finishDraft(draft, patchListener) {
-    const state = draft && draft[DRAFT_STATE];
-    if (!state || !state.isManual_)
-      die(9);
-    const { scope_: scope } = state;
-    usePatchesInScope(scope, patchListener);
-    return processResult(void 0, scope);
+}
+var enterScope = (immer2) => currentScope = createScope(currentScope, immer2);
+function revokeDraft(draft) {
+  const state = draft[DRAFT_STATE];
+  if (state.type_ === 0 || state.type_ === 1)
+    state.revoke_();
+  else
+    state.revoked_ = true;
+}
+function processResult(result, scope) {
+  scope.unfinalizedDrafts_ = scope.drafts_.length;
+  const baseDraft = scope.drafts_[0];
+  const isReplaced = result !== void 0 && result !== baseDraft;
+  if (isReplaced) {
+    if (baseDraft[DRAFT_STATE].modified_) {
+      revokeScope(scope);
+      die(4);
+    }
+    if (isDraftable(result)) {
+      result = finalize(scope, result);
+    }
+    const { patchPlugin_ } = scope;
+    if (patchPlugin_) {
+      patchPlugin_.generateReplacementPatches_(
+        baseDraft[DRAFT_STATE].base_,
+        result,
+        scope
+      );
+    }
+  } else {
+    result = finalize(scope, baseDraft);
   }
-  /**
-   * Pass true to automatically freeze all copies created by Immer.
-   *
-   * By default, auto-freezing is enabled.
-   */
-  setAutoFreeze(value) {
-    this.autoFreeze_ = value;
+  maybeFreeze(scope, result, true);
+  revokeScope(scope);
+  if (scope.patches_) {
+    scope.patchListener_(scope.patches_, scope.inversePatches_);
   }
-  /**
-   * Pass true to enable strict shallow copy.
-   *
-   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
-   */
-  setUseStrictShallowCopy(value) {
-    this.useStrictShallowCopy_ = value;
+  return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value) {
+  if (isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  if (!state) {
+    const finalValue = handleValue(value, rootScope.handledSet_, rootScope);
+    return finalValue;
   }
-  /**
-   * Pass false to use faster iteration that skips non-enumerable properties
-   * but still handles symbols for compatibility.
-   *
-   * By default, strict iteration is enabled (includes all own properties).
-   */
-  setUseStrictIteration(value) {
-    this.useStrictIteration_ = value;
+  if (!isSameScope(state, rootScope)) {
+    return value;
   }
-  shouldUseStrictIteration() {
-    return this.useStrictIteration_;
+  if (!state.modified_) {
+    return state.base_;
   }
-  applyPatches(base, patches) {
-    let i;
-    for (i = patches.length - 1; i >= 0; i--) {
-      const patch = patches[i];
-      if (patch.path.length === 0 && patch.op === "replace") {
-        base = patch.value;
-        break;
+  if (!state.finalized_) {
+    const { callbacks_ } = state;
+    if (callbacks_) {
+      while (callbacks_.length > 0) {
+        const callback = callbacks_.pop();
+        callback(rootScope);
       }
     }
-    if (i > -1) {
-      patches = patches.slice(i + 1);
-    }
-    const applyPatchesImpl = getPlugin(PluginPatches).applyPatches_;
-    if (isDraft(base)) {
-      return applyPatchesImpl(base, patches);
+    generatePatchesAndFinalize(state, rootScope);
+  }
+  return state.copy_;
+}
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
+}
+function markStateFinalized(state) {
+  state.finalized_ = true;
+  state.scope_.unfinalizedDrafts_--;
+}
+var isSameScope = (state, rootScope) => state.scope_ === rootScope;
+var EMPTY_LOCATIONS_RESULT = [];
+function updateDraftInParent(parent, draftValue, finalizedValue, originalKey) {
+  const parentCopy = latest(parent);
+  const parentType = parent.type_;
+  if (originalKey !== void 0) {
+    const currentValue = get(parentCopy, originalKey, parentType);
+    if (currentValue === draftValue) {
+      set(parentCopy, originalKey, finalizedValue, parentType);
+      return;
     }
-    return this.produce(
-      base,
-      (draft) => applyPatchesImpl(draft, patches)
-    );
   }
-};
-function createProxy(rootScope, value, parent, key) {
-  const [draft, state] = isMap(value) ? getPlugin(PluginMapSet).proxyMap_(value, parent) : isSet(value) ? getPlugin(PluginMapSet).proxySet_(value, parent) : createProxyProxy(value, parent);
-  const scope = parent?.scope_ ?? getCurrentScope();
-  scope.drafts_.push(draft);
-  state.callbacks_ = parent?.callbacks_ ?? [];
-  state.key_ = key;
-  if (parent && key !== void 0) {
-    registerChildFinalizationCallback(parent, state, key);
-  } else {
-    state.callbacks_.push(function rootDraftCleanup(rootScope2) {
-      rootScope2.mapSetPlugin_?.fixSetContents(state);
-      const { patchPlugin_ } = rootScope2;
-      if (state.modified_ && patchPlugin_) {
-        patchPlugin_.generatePatches_(state, [], rootScope2);
+  if (!parent.draftLocations_) {
+    const draftLocations = parent.draftLocations_ = /* @__PURE__ */ new Map();
+    each(parentCopy, (key, value) => {
+      if (isDraft(value)) {
+        const keys = draftLocations.get(value) || [];
+        keys.push(key);
+        draftLocations.set(value, keys);
       }
     });
   }
-  return draft;
+  const locations = parent.draftLocations_.get(draftValue) ?? EMPTY_LOCATIONS_RESULT;
+  for (const location of locations) {
+    set(parentCopy, location, finalizedValue, parentType);
+  }
 }
-function current(value) {
-  if (!isDraft(value))
-    die(10, value);
-  return currentImpl(value);
-}
-function currentImpl(value) {
-  if (!isDraftable(value) || isFrozen(value))
-    return value;
-  const state = value[DRAFT_STATE];
-  let copy;
-  let strict = true;
-  if (state) {
-    if (!state.modified_)
-      return state.base_;
-    state.finalized_ = true;
-    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
-    strict = state.scope_.immer_.shouldUseStrictIteration();
-  } else {
-    copy = shallowCopy(value, true);
-  }
-  each(
-    copy,
-    (key, childValue) => {
-      set(copy, key, currentImpl(childValue));
-    },
-    strict
-  );
-  if (state) {
-    state.finalized_ = false;
-  }
-  return copy;
+function registerChildFinalizationCallback(parent, child, key) {
+  parent.callbacks_.push(function childCleanup(rootScope) {
+    const state = child;
+    if (!state || !isSameScope(state, rootScope)) {
+      return;
+    }
+    rootScope.mapSetPlugin_?.fixSetContents(state);
+    const finalizedValue = getFinalValue(state);
+    updateDraftInParent(parent, state.draft_ ?? state, finalizedValue, key);
+    generatePatchesAndFinalize(state, rootScope);
+  });
 }
-var immer = new Immer2();
-var produce = immer.produce;
-
-// node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs
-var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
-  if (arguments.length === 0) return void 0;
-  if (typeof arguments[0] === "object") return compose;
-  return compose.apply(null, arguments);
-};
-var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {
-  return function(noop3) {
-    return noop3;
-  };
-};
-var hasMatchFunction = (v) => {
-  return v && typeof v.match === "function";
-};
-function createAction(type, prepareAction) {
-  function actionCreator(...args) {
-    if (prepareAction) {
-      let prepared = prepareAction(...args);
-      if (!prepared) {
-        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : "prepareAction did not return an object");
+function generatePatchesAndFinalize(state, rootScope) {
+  const shouldFinalize = state.modified_ && !state.finalized_ && (state.type_ === 3 || state.type_ === 1 && state.allIndicesReassigned_ || (state.assigned_?.size ?? 0) > 0);
+  if (shouldFinalize) {
+    const { patchPlugin_ } = rootScope;
+    if (patchPlugin_) {
+      const basePath = patchPlugin_.getPath(state);
+      if (basePath) {
+        patchPlugin_.generatePatches_(state, basePath, rootScope);
       }
-      return {
-        type,
-        payload: prepared.payload,
-        ..."meta" in prepared && {
-          meta: prepared.meta
-        },
-        ..."error" in prepared && {
-          error: prepared.error
-        }
-      };
     }
-    return {
-      type,
-      payload: args[0]
-    };
+    markStateFinalized(state);
   }
-  actionCreator.toString = () => `${type}`;
-  actionCreator.type = type;
-  actionCreator.match = (action) => isAction(action) && action.type === type;
-  return actionCreator;
-}
-function freezeDraftable(val) {
-  return isDraftable(val) ? produce(val, () => {
-  }) : val;
 }
-function getOrInsertComputed(map, key, compute) {
-  if (map.has(key)) return map.get(key);
-  return map.set(key, compute(key)).get(key);
-}
-function executeReducerBuilderCallback(builderCallback) {
-  const actionsMap = {};
-  const actionMatchers = [];
-  let defaultCaseReducer;
-  const builder = {
-    addCase(typeOrActionCreator, reducer) {
-      if (process.env.NODE_ENV !== "production") {
-        if (actionMatchers.length > 0) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
-        }
-        if (defaultCaseReducer) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
-        }
-      }
-      const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
-      if (!type) {
-        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(28) : "`builder.addCase` cannot be called with an empty action type");
-      }
-      if (type in actionsMap) {
-        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
-      }
-      actionsMap[type] = reducer;
-      return builder;
-    },
-    addAsyncThunk(asyncThunk, reducers2) {
-      if (process.env.NODE_ENV !== "production") {
-        if (defaultCaseReducer) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
-        }
-      }
-      if (reducers2.pending) actionsMap[asyncThunk.pending.type] = reducers2.pending;
-      if (reducers2.rejected) actionsMap[asyncThunk.rejected.type] = reducers2.rejected;
-      if (reducers2.fulfilled) actionsMap[asyncThunk.fulfilled.type] = reducers2.fulfilled;
-      if (reducers2.settled) actionMatchers.push({
-        matcher: asyncThunk.settled,
-        reducer: reducers2.settled
+function handleCrossReference(target, key, value) {
+  const { scope_ } = target;
+  if (isDraft(value)) {
+    const state = value[DRAFT_STATE];
+    if (isSameScope(state, scope_)) {
+      state.callbacks_.push(function crossReferenceCleanup() {
+        prepareCopy(target);
+        const finalizedValue = getFinalValue(state);
+        updateDraftInParent(target, value, finalizedValue, key);
       });
-      return builder;
-    },
-    addMatcher(matcher, reducer) {
-      if (process.env.NODE_ENV !== "production") {
-        if (defaultCaseReducer) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+    }
+  } else if (isDraftable(value)) {
+    target.callbacks_.push(function nestedDraftCleanup() {
+      const targetCopy = latest(target);
+      if (target.type_ === 3) {
+        if (targetCopy.has(value)) {
+          handleValue(value, scope_.handledSet_, scope_);
         }
-      }
-      actionMatchers.push({
-        matcher,
-        reducer
-      });
-      return builder;
-    },
-    addDefaultCase(reducer) {
-      if (process.env.NODE_ENV !== "production") {
-        if (defaultCaseReducer) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(31) : "`builder.addDefaultCase` can only be called once");
+      } else {
+        if (get(targetCopy, key, target.type_) === value) {
+          if (scope_.drafts_.length > 1 && (target.assigned_.get(key) ?? false) === true && target.copy_) {
+            handleValue(
+              get(target.copy_, key, target.type_),
+              scope_.handledSet_,
+              scope_
+            );
+          }
         }
       }
-      defaultCaseReducer = reducer;
-      return builder;
-    }
-  };
-  builderCallback(builder);
-  return [actionsMap, actionMatchers, defaultCaseReducer];
-}
-function isStateFunction(x) {
-  return typeof x === "function";
+    });
+  }
 }
-function createReducer(initialState, mapOrBuilderCallback) {
-  if (process.env.NODE_ENV !== "production") {
-    if (typeof mapOrBuilderCallback === "object") {
-      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
-    }
+function handleValue(target, handledSet, rootScope) {
+  if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+    return target;
   }
-  let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
-  let getInitialState;
-  if (isStateFunction(initialState)) {
-    getInitialState = () => freezeDraftable(initialState());
-  } else {
-    const frozenInitialState = freezeDraftable(initialState);
-    getInitialState = () => frozenInitialState;
+  if (isDraft(target) || handledSet.has(target) || !isDraftable(target) || isFrozen(target)) {
+    return target;
   }
-  function reducer(state = getInitialState(), action) {
-    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
-      matcher
-    }) => matcher(action)).map(({
-      reducer: reducer2
-    }) => reducer2)];
-    if (caseReducers.filter((cr) => !!cr).length === 0) {
-      caseReducers = [finalDefaultCaseReducer];
-    }
-    return caseReducers.reduce((previousState, caseReducer) => {
-      if (caseReducer) {
-        if (isDraft(previousState)) {
-          const draft = previousState;
-          const result = caseReducer(draft, action);
-          if (result === void 0) {
-            return previousState;
-          }
-          return result;
-        } else if (!isDraftable(previousState)) {
-          const result = caseReducer(previousState, action);
-          if (result === void 0) {
-            if (previousState === null) {
-              return previousState;
-            }
-            throw Error("A case reducer on a non-draftable value must not return undefined");
-          }
-          return result;
-        } else {
-          return produce(previousState, (draft) => {
-            return caseReducer(draft, action);
-          });
-        }
+  handledSet.add(target);
+  each(target, (key, value) => {
+    if (isDraft(value)) {
+      const state = value[DRAFT_STATE];
+      if (isSameScope(state, rootScope)) {
+        const updatedValue = getFinalValue(state);
+        set(target, key, updatedValue, target.type_);
+        markStateFinalized(state);
       }
-      return previousState;
-    }, state);
-  }
-  reducer.getInitialState = getInitialState;
-  return reducer;
+    } else if (isDraftable(value)) {
+      handleValue(value, handledSet, rootScope);
+    }
+  });
+  return target;
 }
-var matches = (matcher, action) => {
-  if (hasMatchFunction(matcher)) {
-    return matcher.match(action);
-  } else {
-    return matcher(action);
+function createProxyProxy(base, parent) {
+  const baseIsArray = isArray(base);
+  const state = {
+    type_: baseIsArray ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: parent ? parent.scope_ : getCurrentScope(),
+    // True for both shallow and deep changes.
+    modified_: false,
+    // Used during finalization.
+    finalized_: false,
+    // Track which properties have been assigned (true) or deleted (false).
+    // actually instantiated in `prepareCopy()`
+    assigned_: void 0,
+    // The parent draft state.
+    parent_: parent,
+    // The base state.
+    base_: base,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: false,
+    // `callbacks` actually gets assigned in `createProxy`
+    callbacks_: void 0
+  };
+  let target = state;
+  let traps = objectTraps;
+  if (baseIsArray) {
+    target = [state];
+    traps = arrayTraps;
+  }
+  const { revoke, proxy } = Proxy.revocable(target, traps);
+  state.draft_ = proxy;
+  state.revoke_ = revoke;
+  return [proxy, state];
+}
+var objectTraps = {
+  get(state, prop) {
+    if (prop === DRAFT_STATE)
+      return state;
+    let arrayPlugin = state.scope_.arrayMethodsPlugin_;
+    const isArrayWithStringProp = state.type_ === 1 && typeof prop === "string";
+    if (isArrayWithStringProp) {
+      if (arrayPlugin?.isArrayOperationMethod(prop)) {
+        return arrayPlugin.createMethodInterceptor(state, prop);
+      }
+    }
+    const source = latest(state);
+    if (!has(source, prop, state.type_)) {
+      return readPropFromProto(state, source, prop);
+    }
+    const value = source[prop];
+    if (state.finalized_ || !isDraftable(value)) {
+      return value;
+    }
+    if (isArrayWithStringProp && state.operationMethod && arrayPlugin?.isMutatingArrayMethod(
+      state.operationMethod
+    ) && isArrayIndex(prop)) {
+      return value;
+    }
+    if (value === peek(state.base_, prop)) {
+      prepareCopy(state);
+      const childKey = state.type_ === 1 ? +prop : prop;
+      const childDraft = createProxy(state.scope_, value, state, childKey);
+      return state.copy_[childKey] = childDraft;
+    }
+    return value;
+  },
+  has(state, prop) {
+    return prop in latest(state);
+  },
+  ownKeys(state) {
+    return Reflect.ownKeys(latest(state));
+  },
+  set(state, prop, value) {
+    const desc = getDescriptorFromProto(latest(state), prop);
+    if (desc?.set) {
+      desc.set.call(state.draft_, value);
+      return true;
+    }
+    if (!state.modified_) {
+      const current2 = peek(latest(state), prop);
+      const currentState = current2?.[DRAFT_STATE];
+      if (currentState && currentState.base_ === value) {
+        state.copy_[prop] = value;
+        state.assigned_.set(prop, false);
+        return true;
+      }
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop, state.type_)))
+        return true;
+      prepareCopy(state);
+      markChanged(state);
+    }
+    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
+    (value !== void 0 || prop in state.copy_) || // special case: NaN
+    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
+      return true;
+    state.copy_[prop] = value;
+    state.assigned_.set(prop, true);
+    handleCrossReference(state, prop, value);
+    return true;
+  },
+  deleteProperty(state, prop) {
+    prepareCopy(state);
+    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+      state.assigned_.set(prop, false);
+      markChanged(state);
+    } else {
+      state.assigned_.delete(prop);
+    }
+    if (state.copy_) {
+      delete state.copy_[prop];
+    }
+    return true;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(state, prop) {
+    const owner = latest(state);
+    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+    if (!desc)
+      return desc;
+    return {
+      [WRITABLE]: true,
+      [CONFIGURABLE]: state.type_ !== 1 || prop !== "length",
+      [ENUMERABLE]: desc[ENUMERABLE],
+      [VALUE]: owner[prop]
+    };
+  },
+  defineProperty() {
+    die(11);
+  },
+  getPrototypeOf(state) {
+    return getPrototypeOf(state.base_);
+  },
+  setPrototypeOf() {
+    die(12);
   }
 };
-function isAnyOf(...matchers) {
-  return (action) => {
-    return matchers.some((matcher) => matches(matcher, action));
+var arrayTraps = {};
+for (let key in objectTraps) {
+  let fn = objectTraps[key];
+  arrayTraps[key] = function() {
+    const args = arguments;
+    args[0] = args[0][0];
+    return fn.apply(this, args);
   };
 }
-var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
-var nanoid = (size = 21) => {
-  let id = "";
-  let i = size;
-  while (i--) {
-    id += urlAlphabet[Math.random() * 64 | 0];
-  }
-  return id;
+arrayTraps.deleteProperty = function(state, prop) {
+  if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop)))
+    die(13);
+  return arrayTraps.set.call(this, state, prop, void 0);
 };
-var commonProperties = ["name", "message", "stack", "code"];
-var RejectWithValue = class {
-  constructor(payload, meta) {
-    __publicField(this, "payload");
-    __publicField(this, "meta");
-    /*
-    type-only property to distinguish between RejectWithValue and FulfillWithMeta
-    does not exist at runtime
-    */
-    __publicField(this, "_type");
-    this.payload = payload;
-    this.meta = meta;
-  }
+arrayTraps.set = function(state, prop, value) {
+  if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop)))
+    die(14);
+  return objectTraps.set.call(this, state[0], prop, value, state[0]);
 };
-var FulfillWithMeta = class {
-  constructor(payload, meta) {
-    __publicField(this, "payload");
-    __publicField(this, "meta");
-    /*
-    type-only property to distinguish between RejectWithValue and FulfillWithMeta
-    does not exist at runtime
-    */
-    __publicField(this, "_type");
-    this.payload = payload;
-    this.meta = meta;
+function peek(draft, prop) {
+  const state = draft[DRAFT_STATE];
+  const source = state ? latest(state) : draft;
+  return source[prop];
+}
+function readPropFromProto(state, source, prop) {
+  const desc = getDescriptorFromProto(source, prop);
+  return desc ? VALUE in desc ? desc[VALUE] : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    desc.get?.call(state.draft_)
+  ) : void 0;
+}
+function getDescriptorFromProto(source, prop) {
+  if (!(prop in source))
+    return void 0;
+  let proto = getPrototypeOf(source);
+  while (proto) {
+    const desc = Object.getOwnPropertyDescriptor(proto, prop);
+    if (desc)
+      return desc;
+    proto = getPrototypeOf(proto);
   }
-};
-var miniSerializeError = (value) => {
-  if (typeof value === "object" && value !== null) {
-    const simpleError = {};
-    for (const property of commonProperties) {
-      if (typeof value[property] === "string") {
-        simpleError[property] = value[property];
-      }
+  return void 0;
+}
+function markChanged(state) {
+  if (!state.modified_) {
+    state.modified_ = true;
+    if (state.parent_) {
+      markChanged(state.parent_);
     }
-    return simpleError;
   }
-  return {
-    message: String(value)
-  };
-};
-var externalAbortMessage = "External signal was aborted";
-var createAsyncThunk = /* @__PURE__ */ (() => {
-  function createAsyncThunk2(typePrefix, payloadCreator, options) {
-    const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
-      payload,
-      meta: {
-        ...meta || {},
-        arg,
-        requestId,
-        requestStatus: "fulfilled"
-      }
-    }));
-    const pending = createAction(typePrefix + "/pending", (requestId, arg, meta) => ({
-      payload: void 0,
-      meta: {
-        ...meta || {},
-        arg,
-        requestId,
-        requestStatus: "pending"
-      }
-    }));
-    const rejected = createAction(typePrefix + "/rejected", (error, requestId, arg, payload, meta) => ({
-      payload,
-      error: (options && options.serializeError || miniSerializeError)(error || "Rejected"),
-      meta: {
-        ...meta || {},
-        arg,
-        requestId,
-        rejectedWithValue: !!payload,
-        requestStatus: "rejected",
-        aborted: error?.name === "AbortError",
-        condition: error?.name === "ConditionError"
-      }
-    }));
-    function actionCreator(arg, {
-      signal
-    } = {}) {
-      return (dispatch, getState, extra) => {
-        const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
-        const abortController = new AbortController();
-        let abortHandler;
-        let abortReason;
-        function abort(reason) {
-          abortReason = reason;
-          abortController.abort();
-        }
-        if (signal) {
-          if (signal.aborted) {
-            abort(externalAbortMessage);
-          } else {
-            signal.addEventListener("abort", () => abort(externalAbortMessage), {
-              once: true
-            });
-          }
-        }
-        const promise = (async function() {
-          let finalAction;
-          try {
-            let conditionResult = options?.condition?.(arg, {
-              getState,
-              extra
-            });
-            if (isThenable(conditionResult)) {
-              conditionResult = await conditionResult;
-            }
-            if (conditionResult === false || abortController.signal.aborted) {
-              throw {
-                name: "ConditionError",
-                message: "Aborted due to condition callback returning false."
-              };
-            }
-            const abortedPromise = new Promise((_, reject) => {
-              abortHandler = () => {
-                reject({
-                  name: "AbortError",
-                  message: abortReason || "Aborted"
-                });
-              };
-              abortController.signal.addEventListener("abort", abortHandler, {
-                once: true
-              });
-            });
-            dispatch(pending(requestId, arg, options?.getPendingMeta?.({
-              requestId,
-              arg
-            }, {
-              getState,
-              extra
-            })));
-            finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {
-              dispatch,
-              getState,
-              extra,
-              requestId,
-              signal: abortController.signal,
-              abort,
-              rejectWithValue: ((value, meta) => {
-                return new RejectWithValue(value, meta);
-              }),
-              fulfillWithValue: ((value, meta) => {
-                return new FulfillWithMeta(value, meta);
-              })
-            })).then((result) => {
-              if (result instanceof RejectWithValue) {
-                throw result;
-              }
-              if (result instanceof FulfillWithMeta) {
-                return fulfilled(result.payload, requestId, arg, result.meta);
-              }
-              return fulfilled(result, requestId, arg);
-            })]);
-          } catch (err) {
-            finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
-          } finally {
-            if (abortHandler) {
-              abortController.signal.removeEventListener("abort", abortHandler);
-            }
-          }
-          const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
-          if (!skipDispatch) {
-            dispatch(finalAction);
-          }
-          return finalAction;
-        })();
-        return Object.assign(promise, {
-          abort,
-          requestId,
-          arg,
-          unwrap() {
-            return promise.then(unwrapResult);
-          }
-        });
-      };
-    }
-    return Object.assign(actionCreator, {
-      pending,
-      rejected,
-      fulfilled,
-      settled: isAnyOf(rejected, fulfilled),
-      typePrefix
-    });
-  }
-  createAsyncThunk2.withTypes = () => createAsyncThunk2;
-  return createAsyncThunk2;
-})();
-function unwrapResult(action) {
-  if (action.meta && action.meta.rejectedWithValue) {
-    throw action.payload;
-  }
-  if (action.error) {
-    throw action.error;
-  }
-  return action.payload;
-}
-function isThenable(value) {
-  return value !== null && typeof value === "object" && typeof value.then === "function";
 }
-var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
-var asyncThunkCreator = {
-  [asyncThunkSymbol]: createAsyncThunk
-};
-function getType(slice, actionKey) {
-  return `${slice}/${actionKey}`;
+function prepareCopy(state) {
+  if (!state.copy_) {
+    state.assigned_ = /* @__PURE__ */ new Map();
+    state.copy_ = shallowCopy(
+      state.base_,
+      state.scope_.immer_.useStrictShallowCopy_
+    );
+  }
 }
-function buildCreateSlice({
-  creators
-} = {}) {
-  const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
-  return function createSlice2(options) {
-    const {
-      name,
-      reducerPath = name
-    } = options;
-    if (!name) {
-      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(11) : "`name` is a required option for createSlice");
-    }
-    if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
-      if (options.initialState === void 0) {
-        console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+var Immer2 = class {
+  constructor(config) {
+    this.autoFreeze_ = true;
+    this.useStrictShallowCopy_ = false;
+    this.useStrictIteration_ = false;
+    this.produce = (base, recipe, patchListener) => {
+      if (isFunction(base) && !isFunction(recipe)) {
+        const defaultBase = recipe;
+        recipe = base;
+        const self = this;
+        return function curriedProduce(base2 = defaultBase, ...args) {
+          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+        };
       }
-    }
-    const reducers2 = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
-    const reducerNames = Object.keys(reducers2);
-    const context = {
-      sliceCaseReducersByName: {},
-      sliceCaseReducersByType: {},
-      actionCreators: {},
-      sliceMatchers: []
-    };
-    const contextMethods = {
-      addCase(typeOrActionCreator, reducer2) {
-        const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
-        if (!type) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : "`context.addCase` cannot be called with an empty action type");
+      if (!isFunction(recipe))
+        die(6);
+      if (patchListener !== void 0 && !isFunction(patchListener))
+        die(7);
+      let result;
+      if (isDraftable(base)) {
+        const scope = enterScope(this);
+        const proxy = createProxy(scope, base, void 0);
+        let hasError = true;
+        try {
+          result = recipe(proxy);
+          hasError = false;
+        } finally {
+          if (hasError)
+            revokeScope(scope);
+          else
+            leaveScope(scope);
         }
-        if (type in context.sliceCaseReducersByType) {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
+        usePatchesInScope(scope, patchListener);
+        return processResult(result, scope);
+      } else if (!base || !isObjectish(base)) {
+        result = recipe(base);
+        if (result === void 0)
+          result = base;
+        if (result === NOTHING)
+          result = void 0;
+        if (this.autoFreeze_)
+          freeze(result, true);
+        if (patchListener) {
+          const p = [];
+          const ip = [];
+          getPlugin(PluginPatches).generateReplacementPatches_(base, result, {
+            patches_: p,
+            inversePatches_: ip
+          });
+          patchListener(p, ip);
         }
-        context.sliceCaseReducersByType[type] = reducer2;
-        return contextMethods;
-      },
-      addMatcher(matcher, reducer2) {
-        context.sliceMatchers.push({
-          matcher,
-          reducer: reducer2
-        });
-        return contextMethods;
-      },
-      exposeAction(name2, actionCreator) {
-        context.actionCreators[name2] = actionCreator;
-        return contextMethods;
-      },
-      exposeCaseReducer(name2, reducer2) {
-        context.sliceCaseReducersByName[name2] = reducer2;
-        return contextMethods;
-      }
+        return result;
+      } else
+        die(1, base);
     };
-    reducerNames.forEach((reducerName) => {
-      const reducerDefinition = reducers2[reducerName];
-      const reducerDetails = {
-        reducerName,
-        type: getType(name, reducerName),
-        createNotation: typeof options.reducers === "function"
-      };
-      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
-        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
-      } else {
-        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
-      }
-    });
-    function buildReducer() {
-      if (process.env.NODE_ENV !== "production") {
-        if (typeof options.extraReducers === "object") {
-          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
-        }
+    this.produceWithPatches = (base, recipe) => {
+      if (isFunction(base)) {
+        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
       }
-      const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
-      const finalCaseReducers = {
-        ...extraReducers,
-        ...context.sliceCaseReducersByType
-      };
-      return createReducer(options.initialState, (builder) => {
-        for (let key in finalCaseReducers) {
-          builder.addCase(key, finalCaseReducers[key]);
-        }
-        for (let sM of context.sliceMatchers) {
-          builder.addMatcher(sM.matcher, sM.reducer);
-        }
-        for (let m of actionMatchers) {
-          builder.addMatcher(m.matcher, m.reducer);
-        }
-        if (defaultCaseReducer) {
-          builder.addDefaultCase(defaultCaseReducer);
-        }
+      let patches, inversePatches;
+      const result = this.produce(base, recipe, (p, ip) => {
+        patches = p;
+        inversePatches = ip;
       });
+      return [result, patches, inversePatches];
+    };
+    if (isBoolean(config?.autoFreeze))
+      this.setAutoFreeze(config.autoFreeze);
+    if (isBoolean(config?.useStrictShallowCopy))
+      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+    if (isBoolean(config?.useStrictIteration))
+      this.setUseStrictIteration(config.useStrictIteration);
+  }
+  createDraft(base) {
+    if (!isDraftable(base))
+      die(8);
+    if (isDraft(base))
+      base = current(base);
+    const scope = enterScope(this);
+    const proxy = createProxy(scope, base, void 0);
+    proxy[DRAFT_STATE].isManual_ = true;
+    leaveScope(scope);
+    return proxy;
+  }
+  finishDraft(draft, patchListener) {
+    const state = draft && draft[DRAFT_STATE];
+    if (!state || !state.isManual_)
+      die(9);
+    const { scope_: scope } = state;
+    usePatchesInScope(scope, patchListener);
+    return processResult(void 0, scope);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(value) {
+    this.autoFreeze_ = value;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(value) {
+    this.useStrictShallowCopy_ = value;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(value) {
+    this.useStrictIteration_ = value;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(base, patches) {
+    let i;
+    for (i = patches.length - 1; i >= 0; i--) {
+      const patch = patches[i];
+      if (patch.path.length === 0 && patch.op === "replace") {
+        base = patch.value;
+        break;
+      }
     }
-    const selectSelf = (state) => state;
-    const injectedSelectorCache = /* @__PURE__ */ new Map();
-    const injectedStateCache = /* @__PURE__ */ new WeakMap();
-    let _reducer;
-    function reducer(state, action) {
-      if (!_reducer) _reducer = buildReducer();
-      return _reducer(state, action);
+    if (i > -1) {
+      patches = patches.slice(i + 1);
     }
-    function getInitialState() {
-      if (!_reducer) _reducer = buildReducer();
-      return _reducer.getInitialState();
+    const applyPatchesImpl = getPlugin(PluginPatches).applyPatches_;
+    if (isDraft(base)) {
+      return applyPatchesImpl(base, patches);
     }
-    function makeSelectorProps(reducerPath2, injected = false) {
-      function selectSlice(state) {
-        let sliceState = state[reducerPath2];
-        if (typeof sliceState === "undefined") {
-          if (injected) {
-            sliceState = getOrInsertComputed(injectedStateCache, selectSlice, getInitialState);
-          } else if (process.env.NODE_ENV !== "production") {
-            throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(15) : "selectSlice returned undefined for an uninjected slice reducer");
-          }
-        }
-        return sliceState;
+    return this.produce(
+      base,
+      (draft) => applyPatchesImpl(draft, patches)
+    );
+  }
+};
+function createProxy(rootScope, value, parent, key) {
+  const [draft, state] = isMap(value) ? getPlugin(PluginMapSet).proxyMap_(value, parent) : isSet(value) ? getPlugin(PluginMapSet).proxySet_(value, parent) : createProxyProxy(value, parent);
+  const scope = parent?.scope_ ?? getCurrentScope();
+  scope.drafts_.push(draft);
+  state.callbacks_ = parent?.callbacks_ ?? [];
+  state.key_ = key;
+  if (parent && key !== void 0) {
+    registerChildFinalizationCallback(parent, state, key);
+  } else {
+    state.callbacks_.push(function rootDraftCleanup(rootScope2) {
+      rootScope2.mapSetPlugin_?.fixSetContents(state);
+      const { patchPlugin_ } = rootScope2;
+      if (state.modified_ && patchPlugin_) {
+        patchPlugin_.generatePatches_(state, [], rootScope2);
       }
-      function getSelectors(selectState = selectSelf) {
-        const selectorCache = getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap());
-        return getOrInsertComputed(selectorCache, selectState, () => {
-          const map = {};
-          for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
-            map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
-          }
-          return map;
-        });
+    });
+  }
+  return draft;
+}
+function current(value) {
+  if (!isDraft(value))
+    die(10, value);
+  return currentImpl(value);
+}
+function currentImpl(value) {
+  if (!isDraftable(value) || isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  let copy;
+  let strict = true;
+  if (state) {
+    if (!state.modified_)
+      return state.base_;
+    state.finalized_ = true;
+    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+    strict = state.scope_.immer_.shouldUseStrictIteration();
+  } else {
+    copy = shallowCopy(value, true);
+  }
+  each(
+    copy,
+    (key, childValue) => {
+      set(copy, key, currentImpl(childValue));
+    },
+    strict
+  );
+  if (state) {
+    state.finalized_ = false;
+  }
+  return copy;
+}
+var immer = new Immer2();
+var produce = immer.produce;
+
+// node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs
+var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
+  if (arguments.length === 0) return void 0;
+  if (typeof arguments[0] === "object") return compose;
+  return compose.apply(null, arguments);
+};
+var devToolsEnhancer = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {
+  return function(noop3) {
+    return noop3;
+  };
+};
+var hasMatchFunction = (v) => {
+  return v && typeof v.match === "function";
+};
+function createAction(type, prepareAction) {
+  function actionCreator(...args) {
+    if (prepareAction) {
+      let prepared = prepareAction(...args);
+      if (!prepared) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(0) : "prepareAction did not return an object");
       }
       return {
-        reducerPath: reducerPath2,
-        getSelectors,
-        get selectors() {
-          return getSelectors(selectSlice);
+        type,
+        payload: prepared.payload,
+        ..."meta" in prepared && {
+          meta: prepared.meta
         },
-        selectSlice
+        ..."error" in prepared && {
+          error: prepared.error
+        }
       };
     }
-    const slice = {
-      name,
-      reducer,
-      actions: context.actionCreators,
-      caseReducers: context.sliceCaseReducersByName,
-      getInitialState,
-      ...makeSelectorProps(reducerPath),
-      injectInto(injectable, {
-        reducerPath: pathOpt,
-        ...config
-      } = {}) {
-        const newReducerPath = pathOpt ?? reducerPath;
-        injectable.inject({
-          reducerPath: newReducerPath,
-          reducer
-        }, config);
-        return {
-          ...slice,
-          ...makeSelectorProps(newReducerPath, true)
-        };
-      }
+    return {
+      type,
+      payload: args[0]
     };
-    return slice;
-  };
-}
-function wrapSelector(selector, selectState, getInitialState, injected) {
-  function wrapper(rootState, ...args) {
-    let sliceState = selectState(rootState);
-    if (typeof sliceState === "undefined") {
-      if (injected) {
-        sliceState = getInitialState();
-      } else if (process.env.NODE_ENV !== "production") {
-        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(16) : "selectState returned undefined for an uninjected slice reducer");
-      }
-    }
-    return selector(sliceState, ...args);
   }
-  wrapper.unwrapped = selector;
-  return wrapper;
+  actionCreator.toString = () => `${type}`;
+  actionCreator.type = type;
+  actionCreator.match = (action) => isAction(action) && action.type === type;
+  return actionCreator;
 }
-var createSlice = /* @__PURE__ */ buildCreateSlice();
-function buildReducerCreators() {
-  function asyncThunk(payloadCreator, config) {
-    return {
-      _reducerDefinitionType: "asyncThunk",
-      payloadCreator,
-      ...config
-    };
-  }
-  asyncThunk.withTypes = () => asyncThunk;
-  return {
-    reducer(caseReducer) {
-      return Object.assign({
-        // hack so the wrapping function has the same name as the original
-        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
-        [caseReducer.name](...args) {
-          return caseReducer(...args);
+function freezeDraftable(val) {
+  return isDraftable(val) ? produce(val, () => {
+  }) : val;
+}
+function getOrInsertComputed(map, key, compute) {
+  if (map.has(key)) return map.get(key);
+  return map.set(key, compute(key)).get(key);
+}
+function executeReducerBuilderCallback(builderCallback) {
+  const actionsMap = {};
+  const actionMatchers = [];
+  let defaultCaseReducer;
+  const builder = {
+    addCase(typeOrActionCreator, reducer) {
+      if (process.env.NODE_ENV !== "production") {
+        if (actionMatchers.length > 0) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(26) : "`builder.addCase` should only be called before calling `builder.addMatcher`");
         }
-      }[caseReducer.name], {
-        _reducerDefinitionType: "reducer"
-        /* reducer */
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(27) : "`builder.addCase` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
+      if (!type) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(28) : "`builder.addCase` cannot be called with an empty action type");
+      }
+      if (type in actionsMap) {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(29) : `\`builder.addCase\` cannot be called with two reducers for the same action type '${type}'`);
+      }
+      actionsMap[type] = reducer;
+      return builder;
+    },
+    addAsyncThunk(asyncThunk, reducers2) {
+      if (process.env.NODE_ENV !== "production") {
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(43) : "`builder.addAsyncThunk` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      if (reducers2.pending) actionsMap[asyncThunk.pending.type] = reducers2.pending;
+      if (reducers2.rejected) actionsMap[asyncThunk.rejected.type] = reducers2.rejected;
+      if (reducers2.fulfilled) actionsMap[asyncThunk.fulfilled.type] = reducers2.fulfilled;
+      if (reducers2.settled) actionMatchers.push({
+        matcher: asyncThunk.settled,
+        reducer: reducers2.settled
       });
+      return builder;
     },
-    preparedReducer(prepare, reducer) {
-      return {
-        _reducerDefinitionType: "reducerWithPrepare",
-        prepare,
+    addMatcher(matcher, reducer) {
+      if (process.env.NODE_ENV !== "production") {
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(30) : "`builder.addMatcher` should only be called before calling `builder.addDefaultCase`");
+        }
+      }
+      actionMatchers.push({
+        matcher,
         reducer
-      };
+      });
+      return builder;
     },
-    asyncThunk
+    addDefaultCase(reducer) {
+      if (process.env.NODE_ENV !== "production") {
+        if (defaultCaseReducer) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(31) : "`builder.addDefaultCase` can only be called once");
+        }
+      }
+      defaultCaseReducer = reducer;
+      return builder;
+    }
   };
+  builderCallback(builder);
+  return [actionsMap, actionMatchers, defaultCaseReducer];
 }
-function handleNormalReducerDefinition({
-  type,
-  reducerName,
-  createNotation
-}, maybeReducerWithPrepare, context) {
-  let caseReducer;
-  let prepareCallback;
-  if ("reducer" in maybeReducerWithPrepare) {
-    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
-      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+function isStateFunction(x) {
+  return typeof x === "function";
+}
+function createReducer(initialState, mapOrBuilderCallback) {
+  if (process.env.NODE_ENV !== "production") {
+    if (typeof mapOrBuilderCallback === "object") {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(8) : "The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer");
     }
-    caseReducer = maybeReducerWithPrepare.reducer;
-    prepareCallback = maybeReducerWithPrepare.prepare;
+  }
+  let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
+  let getInitialState;
+  if (isStateFunction(initialState)) {
+    getInitialState = () => freezeDraftable(initialState());
   } else {
-    caseReducer = maybeReducerWithPrepare;
+    const frozenInitialState = freezeDraftable(initialState);
+    getInitialState = () => frozenInitialState;
   }
-  context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
-}
-function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
-  return reducerDefinition._reducerDefinitionType === "asyncThunk";
-}
-function isCaseReducerWithPrepareDefinition(reducerDefinition) {
-  return reducerDefinition._reducerDefinitionType === "reducerWithPrepare";
+  function reducer(state = getInitialState(), action) {
+    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
+      matcher
+    }) => matcher(action)).map(({
+      reducer: reducer2
+    }) => reducer2)];
+    if (caseReducers.filter((cr) => !!cr).length === 0) {
+      caseReducers = [finalDefaultCaseReducer];
+    }
+    return caseReducers.reduce((previousState, caseReducer) => {
+      if (caseReducer) {
+        if (isDraft(previousState)) {
+          const draft = previousState;
+          const result = caseReducer(draft, action);
+          if (result === void 0) {
+            return previousState;
+          }
+          return result;
+        } else if (!isDraftable(previousState)) {
+          const result = caseReducer(previousState, action);
+          if (result === void 0) {
+            if (previousState === null) {
+              return previousState;
+            }
+            throw Error("A case reducer on a non-draftable value must not return undefined");
+          }
+          return result;
+        } else {
+          return produce(previousState, (draft) => {
+            return caseReducer(draft, action);
+          });
+        }
+      }
+      return previousState;
+    }, state);
+  }
+  reducer.getInitialState = getInitialState;
+  return reducer;
 }
-function handleThunkCaseReducerDefinition({
-  type,
-  reducerName
-}, reducerDefinition, context, cAT) {
-  if (!cAT) {
-    throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
+var matches = (matcher, action) => {
+  if (hasMatchFunction(matcher)) {
+    return matcher.match(action);
+  } else {
+    return matcher(action);
   }
-  const {
-    payloadCreator,
-    fulfilled,
-    pending,
-    rejected,
-    settled,
-    options
-  } = reducerDefinition;
-  const thunk = cAT(type, payloadCreator, options);
-  context.exposeAction(reducerName, thunk);
-  if (fulfilled) {
-    context.addCase(thunk.fulfilled, fulfilled);
+};
+function isAnyOf(...matchers) {
+  return (action) => {
+    return matchers.some((matcher) => matches(matcher, action));
+  };
+}
+var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
+var nanoid = (size = 21) => {
+  let id = "";
+  let i = size;
+  while (i--) {
+    id += urlAlphabet[Math.random() * 64 | 0];
   }
-  if (pending) {
-    context.addCase(thunk.pending, pending);
+  return id;
+};
+var commonProperties = ["name", "message", "stack", "code"];
+var RejectWithValue = class {
+  constructor(payload, meta) {
+    __publicField(this, "payload");
+    __publicField(this, "meta");
+    /*
+    type-only property to distinguish between RejectWithValue and FulfillWithMeta
+    does not exist at runtime
+    */
+    __publicField(this, "_type");
+    this.payload = payload;
+    this.meta = meta;
   }
-  if (rejected) {
-    context.addCase(thunk.rejected, rejected);
+};
+var FulfillWithMeta = class {
+  constructor(payload, meta) {
+    __publicField(this, "payload");
+    __publicField(this, "meta");
+    /*
+    type-only property to distinguish between RejectWithValue and FulfillWithMeta
+    does not exist at runtime
+    */
+    __publicField(this, "_type");
+    this.payload = payload;
+    this.meta = meta;
   }
-  if (settled) {
-    context.addMatcher(thunk.settled, settled);
+};
+var miniSerializeError = (value) => {
+  if (typeof value === "object" && value !== null) {
+    const simpleError = {};
+    for (const property of commonProperties) {
+      if (typeof value[property] === "string") {
+        simpleError[property] = value[property];
+      }
+    }
+    return simpleError;
   }
-  context.exposeCaseReducer(reducerName, {
-    fulfilled: fulfilled || noop,
-    pending: pending || noop,
-    rejected: rejected || noop,
-    settled: settled || noop
-  });
-}
-function noop() {
-}
-var listener = "listener";
-var completed = "completed";
-var cancelled = "cancelled";
-var taskCancelled = `task-${cancelled}`;
-var taskCompleted = `task-${completed}`;
-var listenerCancelled = `${listener}-${cancelled}`;
-var listenerCompleted = `${listener}-${completed}`;
-var {
-  assign
-} = Object;
-var alm = "listenerMiddleware";
-var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), {
-  withTypes: () => addListener
-});
-var clearAllListeners = /* @__PURE__ */ createAction(`${alm}/removeAll`);
-var removeListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/remove`), {
-  withTypes: () => removeListener
-});
-function formatProdErrorMessage(code) {
-  return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
-}
-
-// src/redux/themeSlice.ts
-var defaultInitialState = {
-  appearance: "system",
-  color: "#6750a4"
-};
-var reducers = {
-  initialize: (state, action) => ({ ...state, ...action.payload }),
-  setAppearance: (state, action) => ({ ...state, appearance: action.payload }),
-  setColor: (state, action) => ({ ...state, color: action.payload })
-};
-function createThemeReducer(initialState) {
-  return createSlice({
-    name: "theme",
-    initialState: { ...defaultInitialState, ...initialState },
-    reducers
-  }).reducer;
-}
-var defaultSlice = createSlice({
-  name: "theme",
-  initialState: defaultInitialState,
-  reducers
-});
-var themeActions = defaultSlice.actions;
-var themeReducer = defaultSlice.reducer;
-var selectThemeAppearance = (state) => state.appearance;
-var selectThemeColor = (state) => state.color;
-
-// src/ThemeProvider.tsx
-import { useEffect as useEffect2, useRef } from "react";
-import { StatusBar, StyleSheet, View } from "react-native";
-import { Provider as PaperProvider } from "react-native-paper";
-
-// src/useComputedTheme.ts
-import { useCallback, useEffect, useState } from "react";
-import { Appearance } from "react-native";
-import { MD3DarkTheme, MD3LightTheme } from "react-native-paper";
-
-// src/utils/colorNames.ts
-var colorNames = {
-  aliceblue: "#f0f8ff",
-  antiquewhite: "#faebd7",
-  aqua: "#00ffff",
-  aquamarine: "#7fffd4",
-  azure: "#f0ffff",
-  beige: "#f5f5dc",
-  bisque: "#ffe4c4",
-  black: "#000000",
-  blanchedalmond: "#ffebcd",
-  blue: "#0000ff",
-  blueviolet: "#8a2be2",
-  brown: "#a52a2a",
-  burlywood: "#deb887",
-  cadetblue: "#5f9ea0",
-  chartreuse: "#7fff00",
-  chocolate: "#d2691e",
-  coral: "#ff7f50",
-  cornflowerblue: "#6495ed",
-  cornsilk: "#fff8dc",
-  crimson: "#dc143c",
-  cyan: "#00ffff",
-  darkblue: "#00008b",
-  darkcyan: "#008b8b",
-  darkgoldenrod: "#b8860b",
-  darkgray: "#a9a9a9",
-  darkgrey: "#a9a9a9",
-  darkgreen: "#006400",
-  darkkhaki: "#bdb76b",
-  darkmagenta: "#8b008b",
-  darkolivegreen: "#556b2f",
-  darkorange: "#ff8c00",
-  darkorchid: "#9932cc",
-  darkred: "#8b0000",
-  darksalmon: "#e9967a",
-  darkseagreen: "#8fbc8f",
-  darkslateblue: "#483d8b",
-  darkslategray: "#2f4f4f",
-  darkslategrey: "#2f4f4f",
-  darkturquoise: "#00ced1",
-  darkviolet: "#9400d3",
-  deeppink: "#ff1493",
-  deepskyblue: "#00bfff",
-  dimgray: "#696969",
-  dimgrey: "#696969",
-  dodgerblue: "#1e90ff",
-  firebrick: "#b22222",
-  floralwhite: "#fffaf0",
-  forestgreen: "#228b22",
-  fuchsia: "#ff00ff",
-  gainsboro: "#dcdcdc",
-  ghostwhite: "#f8f8ff",
-  gold: "#ffd700",
-  goldenrod: "#daa520",
-  gray: "#808080",
-  grey: "#808080",
-  green: "#008000",
-  greenyellow: "#adff2f",
-  honeydew: "#f0fff0",
-  hotpink: "#ff69b4",
-  indianred: "#cd5c5c",
-  indigo: "#4b0082",
-  ivory: "#fffff0",
-  khaki: "#f0e68c",
-  lavender: "#e6e6fa",
-  lavenderblush: "#fff0f5",
-  lawngreen: "#7cfc00",
-  lemonchiffon: "#fffacd",
-  lightblue: "#add8e6",
-  lightcoral: "#f08080",
-  lightcyan: "#e0ffff",
-  lightgoldenrodyellow: "#fafad2",
-  lightgray: "#d3d3d3",
-  lightgrey: "#d3d3d3",
-  lightgreen: "#90ee90",
-  lightpink: "#ffb6c1",
-  lightsalmon: "#ffa07a",
-  lightseagreen: "#20b2aa",
-  lightskyblue: "#87cefa",
-  lightslategray: "#778899",
-  lightslategrey: "#778899",
-  lightsteelblue: "#b0c4de",
-  lightyellow: "#ffffe0",
-  lime: "#00ff00",
-  limegreen: "#32cd32",
-  linen: "#faf0e6",
-  magenta: "#ff00ff",
-  maroon: "#800000",
-  mediumaquamarine: "#66cdaa",
-  mediumblue: "#0000cd",
-  mediumorchid: "#ba55d3",
-  mediumpurple: "#9370db",
-  mediumseagreen: "#3cb371",
-  mediumslateblue: "#7b68ee",
-  mediumspringgreen: "#00fa9a",
-  mediumturquoise: "#48d1cc",
-  mediumvioletred: "#c71585",
-  midnightblue: "#191970",
-  mintcream: "#f5fffa",
-  mistyrose: "#ffe4e1",
-  moccasin: "#ffe4b5",
-  navajowhite: "#ffdead",
-  navy: "#000080",
-  oldlace: "#fdf5e6",
-  olive: "#808000",
-  olivedrab: "#6b8e23",
-  orange: "#ffa500",
-  orangered: "#ff4500",
-  orchid: "#da70d6",
-  palegoldenrod: "#eee8aa",
-  palegreen: "#98fb98",
-  paleturquoise: "#afeeee",
-  palevioletred: "#db7093",
-  papayawhip: "#ffefd5",
-  peachpuff: "#ffdab9",
-  peru: "#cd853f",
-  pink: "#ffc0cb",
-  plum: "#dda0dd",
-  powderblue: "#b0e0e6",
-  purple: "#800080",
-  rebeccapurple: "#663399",
-  red: "#ff0000",
-  rosybrown: "#bc8f8f",
-  royalblue: "#4169e1",
-  saddlebrown: "#8b4513",
-  salmon: "#fa8072",
-  sandybrown: "#f4a460",
-  seagreen: "#2e8b57",
-  seashell: "#fff5ee",
-  sienna: "#a0522d",
-  silver: "#c0c0c0",
-  skyblue: "#87ceeb",
-  slateblue: "#6a5acd",
-  slategray: "#708090",
-  slategrey: "#708090",
-  snow: "#fffafa",
-  springgreen: "#00ff7f",
-  steelblue: "#4682b4",
-  tan: "#d2b48c",
-  teal: "#008080",
-  thistle: "#d8bfd8",
-  tomato: "#ff6347",
-  transparent: "transparent",
-  turquoise: "#40e0d0",
-  violet: "#ee82ee",
-  wheat: "#f5deb3",
-  white: "#ffffff",
-  whitesmoke: "#f5f5f5",
-  yellow: "#ffff00",
-  yellowgreen: "#9acd32"
+  return {
+    message: String(value)
+  };
 };
-
-// src/utils/getRgb.ts
-var getRgb = (value) => {
-  if (!value) return null;
-  let trimmed = value.trim().toLowerCase();
-  const namedColor = colorNames[trimmed];
-  if (namedColor) trimmed = namedColor;
-  const hexMatch = trimmed.match(/^#?([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i);
-  if (hexMatch) {
-    const hex = hexMatch[1];
-    let normalized = hex;
-    if (hex.length === 3) {
-      normalized = hex.split("").map((c) => c + c).join("");
-    } else if (hex.length === 8) {
-      const alpha = parseInt(hex.substring(6, 8), 16);
-      normalized = hex.substring(0, 6);
-      const intVal2 = parseInt(normalized, 16);
-      return {
-        r: intVal2 >> 16 & 255,
-        g: intVal2 >> 8 & 255,
-        b: intVal2 & 255,
-        a: alpha / 255
+var externalAbortMessage = "External signal was aborted";
+var createAsyncThunk = /* @__PURE__ */ (() => {
+  function createAsyncThunk2(typePrefix, payloadCreator, options) {
+    const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
+      payload,
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        requestStatus: "fulfilled"
+      }
+    }));
+    const pending = createAction(typePrefix + "/pending", (requestId, arg, meta) => ({
+      payload: void 0,
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        requestStatus: "pending"
+      }
+    }));
+    const rejected = createAction(typePrefix + "/rejected", (error, requestId, arg, payload, meta) => ({
+      payload,
+      error: (options && options.serializeError || miniSerializeError)(error || "Rejected"),
+      meta: {
+        ...meta || {},
+        arg,
+        requestId,
+        rejectedWithValue: !!payload,
+        requestStatus: "rejected",
+        aborted: error?.name === "AbortError",
+        condition: error?.name === "ConditionError"
+      }
+    }));
+    function actionCreator(arg, {
+      signal
+    } = {}) {
+      return (dispatch, getState, extra) => {
+        const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
+        const abortController = new AbortController();
+        let abortHandler;
+        let abortReason;
+        function abort(reason) {
+          abortReason = reason;
+          abortController.abort();
+        }
+        if (signal) {
+          if (signal.aborted) {
+            abort(externalAbortMessage);
+          } else {
+            signal.addEventListener("abort", () => abort(externalAbortMessage), {
+              once: true
+            });
+          }
+        }
+        const promise = (async function() {
+          let finalAction;
+          try {
+            let conditionResult = options?.condition?.(arg, {
+              getState,
+              extra
+            });
+            if (isThenable(conditionResult)) {
+              conditionResult = await conditionResult;
+            }
+            if (conditionResult === false || abortController.signal.aborted) {
+              throw {
+                name: "ConditionError",
+                message: "Aborted due to condition callback returning false."
+              };
+            }
+            const abortedPromise = new Promise((_, reject) => {
+              abortHandler = () => {
+                reject({
+                  name: "AbortError",
+                  message: abortReason || "Aborted"
+                });
+              };
+              abortController.signal.addEventListener("abort", abortHandler, {
+                once: true
+              });
+            });
+            dispatch(pending(requestId, arg, options?.getPendingMeta?.({
+              requestId,
+              arg
+            }, {
+              getState,
+              extra
+            })));
+            finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {
+              dispatch,
+              getState,
+              extra,
+              requestId,
+              signal: abortController.signal,
+              abort,
+              rejectWithValue: ((value, meta) => {
+                return new RejectWithValue(value, meta);
+              }),
+              fulfillWithValue: ((value, meta) => {
+                return new FulfillWithMeta(value, meta);
+              })
+            })).then((result) => {
+              if (result instanceof RejectWithValue) {
+                throw result;
+              }
+              if (result instanceof FulfillWithMeta) {
+                return fulfilled(result.payload, requestId, arg, result.meta);
+              }
+              return fulfilled(result, requestId, arg);
+            })]);
+          } catch (err) {
+            finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
+          } finally {
+            if (abortHandler) {
+              abortController.signal.removeEventListener("abort", abortHandler);
+            }
+          }
+          const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
+          if (!skipDispatch) {
+            dispatch(finalAction);
+          }
+          return finalAction;
+        })();
+        return Object.assign(promise, {
+          abort,
+          requestId,
+          arg,
+          unwrap() {
+            return promise.then(unwrapResult);
+          }
+        });
       };
     }
-    const intVal = parseInt(normalized, 16);
-    return {
-      r: intVal >> 16 & 255,
-      g: intVal >> 8 & 255,
-      b: intVal & 255
-    };
+    return Object.assign(actionCreator, {
+      pending,
+      rejected,
+      fulfilled,
+      settled: isAnyOf(rejected, fulfilled),
+      typePrefix
+    });
   }
-  const rgbMatch = trimmed.match(/^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*([0-9.]+))?\s*\)$/i);
-  if (rgbMatch) {
-    const result = {
-      r: Number(rgbMatch[1]),
-      g: Number(rgbMatch[2]),
-      b: Number(rgbMatch[3])
-    };
-    if (rgbMatch[4] !== void 0) {
-      result.a = Number(rgbMatch[4]);
-    }
-    return result;
+  createAsyncThunk2.withTypes = () => createAsyncThunk2;
+  return createAsyncThunk2;
+})();
+function unwrapResult(action) {
+  if (action.meta && action.meta.rejectedWithValue) {
+    throw action.payload;
   }
-  return null;
-};
-
-// src/utils/getHex.ts
-var getHex = (value) => {
-  const rgb = getRgb(value);
-  if (!rgb) return null;
-  const toHex = (n) => {
-    const hex = Math.round(n).toString(16);
-    return hex.length === 1 ? "0" + hex : hex;
-  };
-  const hexString = `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`;
-  if (rgb.a !== void 0) {
-    return `${hexString}${toHex(rgb.a * 255)}`;
+  if (action.error) {
+    throw action.error;
   }
-  return hexString;
-};
-
-// src/utils/getBlendedColor.ts
-var getBlendedColor = (foreground, background, alpha) => {
-  const fg = getRgb(foreground);
-  const bg = getRgb(background);
-  if (!fg || !bg) return background;
-  const safeAlpha = Math.min(1, Math.max(0, alpha));
-  const r = Math.round(fg.r * safeAlpha + bg.r * (1 - safeAlpha));
-  const g = Math.round(fg.g * safeAlpha + bg.g * (1 - safeAlpha));
-  const b = Math.round(fg.b * safeAlpha + bg.b * (1 - safeAlpha));
-  return getHex(`rgb(${r}, ${g}, ${b})`) ?? background;
+  return action.payload;
+}
+function isThenable(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
+var asyncThunkCreator = {
+  [asyncThunkSymbol]: createAsyncThunk
 };
-
-// src/utils/getTriadicPalette.ts
-function getTriadicPalette(primaryColor) {
-  const rgb = getRgb(primaryColor);
-  if (!rgb) throw new Error(`Invalid color format: ${primaryColor}`);
-  const r = rgb.r / 255;
-  const g = rgb.g / 255;
-  const b = rgb.b / 255;
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  const l = (max + min) / 2;
-  let h = 0;
-  let s = 0;
-  if (max !== min) {
-    const d = max - min;
-    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-    switch (max) {
-      case r:
-        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
-        break;
-      case g:
-        h = ((b - r) / d + 2) / 6;
-        break;
-      case b:
-        h = ((r - g) / d + 4) / 6;
-        break;
+function getType(slice, actionKey) {
+  return `${slice}/${actionKey}`;
+}
+function buildCreateSlice({
+  creators
+} = {}) {
+  const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
+  return function createSlice2(options) {
+    const {
+      name,
+      reducerPath = name
+    } = options;
+    if (!name) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(11) : "`name` is a required option for createSlice");
+    }
+    if (typeof process !== "undefined" && process.env.NODE_ENV === "development") {
+      if (options.initialState === void 0) {
+        console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
+      }
+    }
+    const reducers2 = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
+    const reducerNames = Object.keys(reducers2);
+    const context = {
+      sliceCaseReducersByName: {},
+      sliceCaseReducersByType: {},
+      actionCreators: {},
+      sliceMatchers: []
+    };
+    const contextMethods = {
+      addCase(typeOrActionCreator, reducer2) {
+        const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
+        if (!type) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : "`context.addCase` cannot be called with an empty action type");
+        }
+        if (type in context.sliceCaseReducersByType) {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : "`context.addCase` cannot be called with two reducers for the same action type: " + type);
+        }
+        context.sliceCaseReducersByType[type] = reducer2;
+        return contextMethods;
+      },
+      addMatcher(matcher, reducer2) {
+        context.sliceMatchers.push({
+          matcher,
+          reducer: reducer2
+        });
+        return contextMethods;
+      },
+      exposeAction(name2, actionCreator) {
+        context.actionCreators[name2] = actionCreator;
+        return contextMethods;
+      },
+      exposeCaseReducer(name2, reducer2) {
+        context.sliceCaseReducersByName[name2] = reducer2;
+        return contextMethods;
+      }
+    };
+    reducerNames.forEach((reducerName) => {
+      const reducerDefinition = reducers2[reducerName];
+      const reducerDetails = {
+        reducerName,
+        type: getType(name, reducerName),
+        createNotation: typeof options.reducers === "function"
+      };
+      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
+        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
+      } else {
+        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
+      }
+    });
+    function buildReducer() {
+      if (process.env.NODE_ENV !== "production") {
+        if (typeof options.extraReducers === "object") {
+          throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : "The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice");
+        }
+      }
+      const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
+      const finalCaseReducers = {
+        ...extraReducers,
+        ...context.sliceCaseReducersByType
+      };
+      return createReducer(options.initialState, (builder) => {
+        for (let key in finalCaseReducers) {
+          builder.addCase(key, finalCaseReducers[key]);
+        }
+        for (let sM of context.sliceMatchers) {
+          builder.addMatcher(sM.matcher, sM.reducer);
+        }
+        for (let m of actionMatchers) {
+          builder.addMatcher(m.matcher, m.reducer);
+        }
+        if (defaultCaseReducer) {
+          builder.addDefaultCase(defaultCaseReducer);
+        }
+      });
+    }
+    const selectSelf = (state) => state;
+    const injectedSelectorCache = /* @__PURE__ */ new Map();
+    const injectedStateCache = /* @__PURE__ */ new WeakMap();
+    let _reducer;
+    function reducer(state, action) {
+      if (!_reducer) _reducer = buildReducer();
+      return _reducer(state, action);
+    }
+    function getInitialState() {
+      if (!_reducer) _reducer = buildReducer();
+      return _reducer.getInitialState();
+    }
+    function makeSelectorProps(reducerPath2, injected = false) {
+      function selectSlice(state) {
+        let sliceState = state[reducerPath2];
+        if (typeof sliceState === "undefined") {
+          if (injected) {
+            sliceState = getOrInsertComputed(injectedStateCache, selectSlice, getInitialState);
+          } else if (process.env.NODE_ENV !== "production") {
+            throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(15) : "selectSlice returned undefined for an uninjected slice reducer");
+          }
+        }
+        return sliceState;
+      }
+      function getSelectors(selectState = selectSelf) {
+        const selectorCache = getOrInsertComputed(injectedSelectorCache, injected, () => /* @__PURE__ */ new WeakMap());
+        return getOrInsertComputed(selectorCache, selectState, () => {
+          const map = {};
+          for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
+            map[name2] = wrapSelector(selector, selectState, () => getOrInsertComputed(injectedStateCache, selectState, getInitialState), injected);
+          }
+          return map;
+        });
+      }
+      return {
+        reducerPath: reducerPath2,
+        getSelectors,
+        get selectors() {
+          return getSelectors(selectSlice);
+        },
+        selectSlice
+      };
+    }
+    const slice = {
+      name,
+      reducer,
+      actions: context.actionCreators,
+      caseReducers: context.sliceCaseReducersByName,
+      getInitialState,
+      ...makeSelectorProps(reducerPath),
+      injectInto(injectable, {
+        reducerPath: pathOpt,
+        ...config
+      } = {}) {
+        const newReducerPath = pathOpt ?? reducerPath;
+        injectable.inject({
+          reducerPath: newReducerPath,
+          reducer
+        }, config);
+        return {
+          ...slice,
+          ...makeSelectorProps(newReducerPath, true)
+        };
+      }
+    };
+    return slice;
+  };
+}
+function wrapSelector(selector, selectState, getInitialState, injected) {
+  function wrapper(rootState, ...args) {
+    let sliceState = selectState(rootState);
+    if (typeof sliceState === "undefined") {
+      if (injected) {
+        sliceState = getInitialState();
+      } else if (process.env.NODE_ENV !== "production") {
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(16) : "selectState returned undefined for an uninjected slice reducer");
+      }
     }
+    return selector(sliceState, ...args);
+  }
+  wrapper.unwrapped = selector;
+  return wrapper;
+}
+var createSlice = /* @__PURE__ */ buildCreateSlice();
+function buildReducerCreators() {
+  function asyncThunk(payloadCreator, config) {
+    return {
+      _reducerDefinitionType: "asyncThunk",
+      payloadCreator,
+      ...config
+    };
   }
+  asyncThunk.withTypes = () => asyncThunk;
   return {
-    primary: getHex(primaryColor) ?? primaryColor,
-    secondary: hslToHex((h + 1 / 3) % 1, s, l),
-    tertiary: hslToHex((h + 2 / 3) % 1, s, l)
+    reducer(caseReducer) {
+      return Object.assign({
+        // hack so the wrapping function has the same name as the original
+        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
+        [caseReducer.name](...args) {
+          return caseReducer(...args);
+        }
+      }[caseReducer.name], {
+        _reducerDefinitionType: "reducer"
+        /* reducer */
+      });
+    },
+    preparedReducer(prepare, reducer) {
+      return {
+        _reducerDefinitionType: "reducerWithPrepare",
+        prepare,
+        reducer
+      };
+    },
+    asyncThunk
   };
 }
-function hslToHex(h, s, l) {
-  const c = (1 - Math.abs(2 * l - 1)) * s;
-  const x = c * (1 - Math.abs(h * 6 % 2 - 1));
-  const m = l - c / 2;
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  if (h < 1 / 6) {
-    r = c;
-    g = x;
-    b = 0;
-  } else if (h < 2 / 6) {
-    r = x;
-    g = c;
-    b = 0;
-  } else if (h < 3 / 6) {
-    r = 0;
-    g = c;
-    b = x;
-  } else if (h < 4 / 6) {
-    r = 0;
-    g = x;
-    b = c;
-  } else if (h < 5 / 6) {
-    r = x;
-    g = 0;
-    b = c;
+function handleNormalReducerDefinition({
+  type,
+  reducerName,
+  createNotation
+}, maybeReducerWithPrepare, context) {
+  let caseReducer;
+  let prepareCallback;
+  if ("reducer" in maybeReducerWithPrepare) {
+    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(17) : "Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.");
+    }
+    caseReducer = maybeReducerWithPrepare.reducer;
+    prepareCallback = maybeReducerWithPrepare.prepare;
   } else {
-    r = c;
-    g = 0;
-    b = x;
+    caseReducer = maybeReducerWithPrepare;
   }
-  const toHex = (value) => {
-    const hex = Math.round((value + m) * 255).toString(16);
-    return hex.length === 1 ? `0${hex}` : hex;
-  };
-  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+  context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
 }
-
-// src/utils/isDarkColor.ts
-var isDarkColor = (value) => {
-  const rgb = getRgb(value);
-  if (!rgb) return false;
-  const [r, g, b] = [rgb.r / 255, rgb.g / 255, rgb.b / 255];
-  const [rs, gs, bs] = [r, g, b].map((c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4));
-  const luminance = 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
-  return luminance < 0.5;
-};
-
-// src/useComputedTheme.ts
-function useComputedTheme(appearance, color) {
-  const [theme, setTheme] = useState(null);
-  const computeTheme = useCallback(() => {
-    let resolved = appearance;
-    if (resolved === "system") resolved = Appearance.getColorScheme();
-    if (resolved === "no-preference" || !resolved) resolved = "light";
-    const base = resolved === "dark" ? MD3DarkTheme : MD3LightTheme;
-    const _theme = {
-      ...base,
-      colors: {
-        ...base.colors,
-        elevation: { ...base.colors.elevation }
-      }
-    };
-    const palette = getTriadicPalette(color);
-    const surface = base.colors.surface;
-    _theme.colors.primary = palette.primary;
-    _theme.colors.onPrimary = isDarkColor(palette.primary) ? "#ffffff" : "#000000";
-    _theme.colors.primaryContainer = getBlendedColor(palette.primary, surface, 0.15);
-    _theme.colors.onPrimaryContainer = isDarkColor(_theme.colors.primaryContainer) ? "#ffffff" : "#000000";
-    _theme.colors.secondary = palette.secondary;
-    _theme.colors.onSecondary = isDarkColor(palette.secondary) ? "#ffffff" : "#000000";
-    _theme.colors.secondaryContainer = getBlendedColor(palette.secondary, surface, 0.15);
-    _theme.colors.onSecondaryContainer = isDarkColor(_theme.colors.secondaryContainer) ? "#ffffff" : "#000000";
-    _theme.colors.tertiary = palette.tertiary;
-    _theme.colors.onTertiary = isDarkColor(palette.tertiary) ? "#ffffff" : "#000000";
-    _theme.colors.tertiaryContainer = getBlendedColor(palette.tertiary, surface, 0.15);
-    _theme.colors.onTertiaryContainer = isDarkColor(_theme.colors.tertiaryContainer) ? "#ffffff" : "#000000";
-    const blended = getBlendedColor(color, palette.secondary, 0.5);
-    const tintSurface = (alpha) => getBlendedColor(blended, surface, alpha);
-    _theme.colors.surface = surface;
-    _theme.colors.surfaceVariant = tintSurface(0.2);
-    _theme.colors.outline = getBlendedColor(color, base.colors.outline, 0.45);
-    const grey = base.dark ? "#424242" : "#c2c2c2";
-    const blendedGrey = getBlendedColor(blended, grey, 0.05);
-    _theme.colors.elevation = {
-      ..._theme.colors.elevation,
-      level1: _theme.colors.surface,
-      level2: getBlendedColor(blendedGrey, _theme.colors.surface, 0.25),
-      level3: getBlendedColor(blendedGrey, _theme.colors.surface, 0.4),
-      level4: getBlendedColor(blendedGrey, _theme.colors.surface, 0.55),
-      level5: getBlendedColor(blendedGrey, _theme.colors.surface, 0.7)
-    };
-    setTheme(_theme);
-  }, [appearance, color]);
-  useEffect(() => {
-    computeTheme();
-  }, [computeTheme]);
-  useEffect(() => {
-    const subscription = Appearance.addChangeListener(computeTheme);
-    return subscription.remove;
-  }, [computeTheme]);
-  return theme;
+function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
+  return reducerDefinition._reducerDefinitionType === "asyncThunk";
+}
+function isCaseReducerWithPrepareDefinition(reducerDefinition) {
+  return reducerDefinition._reducerDefinitionType === "reducerWithPrepare";
+}
+function handleThunkCaseReducerDefinition({
+  type,
+  reducerName
+}, reducerDefinition, context, cAT) {
+  if (!cAT) {
+    throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(18) : "Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.");
+  }
+  const {
+    payloadCreator,
+    fulfilled,
+    pending,
+    rejected,
+    settled,
+    options
+  } = reducerDefinition;
+  const thunk = cAT(type, payloadCreator, options);
+  context.exposeAction(reducerName, thunk);
+  if (fulfilled) {
+    context.addCase(thunk.fulfilled, fulfilled);
+  }
+  if (pending) {
+    context.addCase(thunk.pending, pending);
+  }
+  if (rejected) {
+    context.addCase(thunk.rejected, rejected);
+  }
+  if (settled) {
+    context.addMatcher(thunk.settled, settled);
+  }
+  context.exposeCaseReducer(reducerName, {
+    fulfilled: fulfilled || noop,
+    pending: pending || noop,
+    rejected: rejected || noop,
+    settled: settled || noop
+  });
+}
+function noop() {
+}
+var listener = "listener";
+var completed = "completed";
+var cancelled = "cancelled";
+var taskCancelled = `task-${cancelled}`;
+var taskCompleted = `task-${completed}`;
+var listenerCancelled = `${listener}-${cancelled}`;
+var listenerCompleted = `${listener}-${completed}`;
+var {
+  assign
+} = Object;
+var alm = "listenerMiddleware";
+var addListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/add`), {
+  withTypes: () => addListener
+});
+var clearAllListeners = /* @__PURE__ */ createAction(`${alm}/removeAll`);
+var removeListener = /* @__PURE__ */ assign(/* @__PURE__ */ createAction(`${alm}/remove`), {
+  withTypes: () => removeListener
+});
+function formatProdErrorMessage(code) {
+  return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
 }
 
-// src/ThemeProvider.tsx
-import { jsx as jsx6, jsxs } from "react/jsx-runtime";
-function Provider({ appearance, color, children, defaults, onReady, statusBarProps, style }) {
-  const theme = useComputedTheme(appearance, color);
-  const called = useRef(false);
-  useEffect2(() => {
-    if (theme && !called.current) {
-      called.current = true;
-      onReady?.();
-    }
-  }, [theme, onReady]);
-  if (!theme) return null;
-  return /* @__PURE__ */ jsxs(PaperProvider, { theme, children: [
-    /* @__PURE__ */ jsx6(StatusBar, { backgroundColor: theme.colors.background, barStyle: theme.dark ? "light-content" : "dark-content", ...statusBarProps }),
-    /* @__PURE__ */ jsx6(PaperDefaultsContext.Provider, { value: defaults ?? {}, children: /* @__PURE__ */ jsx6(View, { style: [styles.flex, { backgroundColor: theme.colors.background }, style], children }) })
-  ] });
+// src/redux/themeSlice.ts
+var defaultInitialState = {
+  appearance: "system",
+  blur: true,
+  color: "#6750a4",
+  harmony: "split-complementary"
+};
+var reducers = {
+  initialize: (state, action) => ({ ...state, ...action.payload }),
+  setAppearance: (state, action) => ({ ...state, appearance: action.payload }),
+  setBlur: (state, action) => ({ ...state, blur: action.payload }),
+  setColor: (state, action) => ({ ...state, color: action.payload }),
+  setHarmony: (state, action) => ({ ...state, harmony: action.payload })
+};
+function createThemeReducer(initialState) {
+  return createSlice({
+    name: "theme",
+    initialState: { ...defaultInitialState, ...initialState },
+    reducers
+  }).reducer;
 }
-var styles = StyleSheet.create({
-  flex: { flex: 1 }
+var defaultSlice = createSlice({
+  name: "theme",
+  initialState: defaultInitialState,
+  reducers
 });
+var themeActions = defaultSlice.actions;
+var themeReducer = defaultSlice.reducer;
+var selectThemeAppearance = (state) => state.appearance;
+var selectThemeBlur = (state) => state.blur;
+var selectThemeColor = (state) => state.color;
+var selectThemeHarmony = (state) => state.harmony;
+
+// src/useThemeSettings.ts
+import { useContext as useContext5 } from "react";
+var useThemeSettings = () => useContext5(ThemeSettingsContext);
 export {
+  Appbar,
+  AppearancePicker,
+  BlurView,
+  BottomNavigation,
   Button,
   Chip,
+  ColorPicker,
+  Dialog,
   FAB,
+  HarmonyPicker,
   IconButton,
+  Menu,
   Provider,
   TextInput,
+  ThemeSettingsContext,
   createThemeReducer,
+  defaultColors,
+  defaultThemeSettings,
   getBlendedColor,
   getHex,
   getRgb,
   getTriadicPalette,
   isDarkColor,
   selectThemeAppearance,
+  selectThemeBlur,
   selectThemeColor,
+  selectThemeHarmony,
   themeActions,
   themeReducer,
+  useBlur,
   useComputedTheme,
-  usePaperDefaults
+  usePaperDefaults,
+  useThemeSettings
 };