@fde-desktop/fde-core 0.3.8 → 0.4.1

package/dist/chunk-SYGUWGWK.cjs

@@ -0,0 +1,2329 @@
+'use strict';
+
+var chunkLMJE6V4N_cjs = require('./chunk-LMJE6V4N.cjs');
+var chunkYP2PLNOF_cjs = require('./chunk-YP2PLNOF.cjs');
+var chunkICUE6T7J_cjs = require('./chunk-ICUE6T7J.cjs');
+var chunkZX3EDZ5C_cjs = require('./chunk-ZX3EDZ5C.cjs');
+var chunkJ7L2S2GT_cjs = require('./chunk-J7L2S2GT.cjs');
+var chunkZBGWYTCU_cjs = require('./chunk-ZBGWYTCU.cjs');
+var chunk2PSTHGTD_cjs = require('./chunk-2PSTHGTD.cjs');
+var chunkBDO6B7MZ_cjs = require('./chunk-BDO6B7MZ.cjs');
+var chunk6QOUYSEE_cjs = require('./chunk-6QOUYSEE.cjs');
+var chunkZ5YGWL65_cjs = require('./chunk-Z5YGWL65.cjs');
+var chunkE55VXNLK_cjs = require('./chunk-E55VXNLK.cjs');
+var React5 = require('react');
+var reactI18next = require('react-i18next');
+var zustand = require('zustand');
+var middleware = require('zustand/middleware');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React5__namespace = /*#__PURE__*/_interopNamespace(React5);
+
+// src/infrastructure/adapters/DefaultThemeProvider.ts
+var DEFAULT_FDE_THEME_LIGHT = {
+  mode: "light",
+  colors: {
+    desktop: "#f0f4f8",
+    taskbar: "rgba(255, 255, 255, 0.9)",
+    window: "#ffffff",
+    accent: "#339af0"
+  },
+  window: {
+    borderRadius: "8px",
+    headerHeight: 40,
+    minWidth: 400,
+    minHeight: 300,
+    defaultWidth: 800,
+    defaultHeight: 600,
+    shadow: "0 8px 32px rgba(0, 0, 0, 0.2)"
+  },
+  taskbar: {
+    height: 48,
+    position: "bottom",
+    background: "rgba(0, 0, 0, 0.8)",
+    blur: true
+  },
+  desktop: {
+    background: "linear-gradient(135deg, #667eea 0%, #764ba2 100%)",
+    iconSize: 64,
+    iconSpacing: 16
+  }
+};
+var DEFAULT_FDE_THEME_DARK = {
+  mode: "dark",
+  colors: {
+    desktop: "#1a1b1e",
+    taskbar: "rgba(26, 27, 30, 0.9)",
+    window: "#25262b",
+    accent: "#4dabf7"
+  },
+  window: {
+    borderRadius: "8px",
+    headerHeight: 40,
+    minWidth: 400,
+    minHeight: 300,
+    defaultWidth: 800,
+    defaultHeight: 600,
+    shadow: "0 8px 32px rgba(0, 0, 0, 0.2)"
+  },
+  taskbar: {
+    height: 48,
+    position: "bottom",
+    background: "rgba(0, 0, 0, 0.8)",
+    blur: true
+  },
+  desktop: {
+    background: "linear-gradient(135deg, #1a1b1e 0%, #2d1f3d 100%)",
+    iconSize: 64,
+    iconSpacing: 16
+  }
+};
+var DefaultThemeProvider = class {
+  mode;
+  customColors = null;
+  constructor(initialMode = "light") {
+    this.mode = initialMode;
+  }
+  getTheme() {
+    const base = this.mode === "light" ? DEFAULT_FDE_THEME_LIGHT : DEFAULT_FDE_THEME_DARK;
+    if (!this.customColors) return base;
+    return {
+      ...base,
+      colors: {
+        ...base.colors,
+        taskbar: this.customColors.taskbar,
+        window: this.customColors.window,
+        accent: this.customColors.accent
+      }
+    };
+  }
+  setMode(mode) {
+    this.mode = mode;
+  }
+  setCustomColors(colors) {
+    this.customColors = colors;
+  }
+  toggle() {
+    this.mode = this.mode === "light" ? "dark" : "light";
+  }
+};
+
+// src/stores/settingsStore.ts
+var SUPPORTED_LANGUAGES = ["en", "es"];
+var DEFAULT_LANGUAGE = "en";
+var getPersistedThemeMode = () => {
+  try {
+    const newKey = localStorage.getItem("fde-desktop:settings");
+    const legacyKey = localStorage.getItem("fran-desktop:settings");
+    const stored = newKey ?? legacyKey;
+    return JSON.parse(stored ?? "{}")?.state?.theme?.mode ?? null;
+  } catch {
+    return null;
+  }
+};
+var persistedMode = getPersistedThemeMode();
+var detectBrowserLanguage = () => {
+  if (typeof navigator === "undefined" || !navigator.language) {
+    return DEFAULT_LANGUAGE;
+  }
+  const browserLang = navigator.language.split("-")[0];
+  if (SUPPORTED_LANGUAGES.includes(browserLang)) {
+    return browserLang;
+  }
+  return DEFAULT_LANGUAGE;
+};
+var persistedLanguage = (() => {
+  try {
+    const newKey = localStorage.getItem("fde-desktop:settings");
+    const legacyKey = localStorage.getItem("fran-desktop:settings");
+    const storedState = JSON.parse(newKey ?? legacyKey ?? "{}")?.state?.language;
+    if (storedState && SUPPORTED_LANGUAGES.includes(storedState)) {
+      return storedState;
+    }
+    return detectBrowserLanguage();
+  } catch {
+    return detectBrowserLanguage();
+  }
+})();
+var themeProvider = new DefaultThemeProvider(persistedMode ?? "light");
+var useSettingsStore = zustand.create()(
+  middleware.persist(
+    (set) => ({
+      wallpaper: null,
+      wallpaperModule: "default",
+      launcherIcon: "FcElectronics",
+      font: "system-ui",
+      downloadedFonts: [],
+      fontSize: 14,
+      animationDuration: 0.3,
+      theme: themeProvider.getTheme(),
+      themeSetManually: persistedMode !== null,
+      customThemeColors: null,
+      language: persistedLanguage,
+      setWallpaper: (url) => set({ wallpaper: url }),
+      setWallpaperModule: (module) => set({ wallpaperModule: module }),
+      setLauncherIcon: (icon) => set({ launcherIcon: icon }),
+      setFont: (font) => set({ font }),
+      markFontDownloaded: (fontName) => set((state) => ({
+        downloadedFonts: state.downloadedFonts.includes(fontName) ? state.downloadedFonts : [...state.downloadedFonts, fontName]
+      })),
+      setFontSize: (size) => set({ fontSize: size }),
+      setAnimationDuration: (duration) => set({ animationDuration: duration }),
+      setThemeMode: (mode) => {
+        themeProvider.setMode(mode);
+        set({ theme: themeProvider.getTheme(), themeSetManually: true });
+      },
+      toggleTheme: () => {
+        themeProvider.toggle();
+        set({ theme: themeProvider.getTheme(), themeSetManually: true });
+      },
+      setThemeAutomatic: () => set({ themeSetManually: false }),
+      applySystemTheme: (mode) => {
+        themeProvider.setMode(mode);
+        set({ theme: themeProvider.getTheme() });
+      },
+      setCustomThemeColors: (colors) => {
+        set({ customThemeColors: colors });
+      },
+      setLanguage: (lang) => set({ language: lang })
+    }),
+    {
+      name: "fde-desktop:settings",
+      storage: middleware.createJSONStorage(() => localStorage)
+    }
+  )
+);
+
+// src/components/Apps/SettingsApp/sections/sectionRegistry.ts
+var SETTINGS_SECTIONS = [
+  {
+    id: "wallpaper",
+    label: "Wallpaper",
+    fcIcon: "FcPicture",
+    description: "Change the desktop background image."
+  },
+  {
+    id: "appearance",
+    label: "Appearance",
+    fcIcon: "FcBinoculars",
+    description: "Switch between light and dark mode."
+  },
+  {
+    id: "launcher",
+    label: "Launcher",
+    fcIcon: "FcElectronics",
+    description: "Choose the launcher button icon."
+  },
+  {
+    id: "font",
+    label: "Font",
+    fcIcon: "FcEditImage",
+    description: "Select the system font family."
+  },
+  {
+    id: "language",
+    label: "Language",
+    fcIcon: "FcGlobe",
+    description: "Choose your preferred language."
+  },
+  {
+    id: "reset",
+    label: "Reset to Default",
+    fcIcon: "FcDisclaimer",
+    description: "Reset all settings and data to defaults."
+  }
+];
+var SettingsSection = ({ title, description, children }) => /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: "md", p: "md", children: [
+  /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { fw: 600, size: "lg", children: title }),
+  description && /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", c: "dimmed", children: description }),
+  children
+] });
+var SettingsSection_default = SettingsSection;
+var defaultWallpaperSrc = "/Images/wallpaper.jpg";
+var WallpaperSettings = () => {
+  const { t } = reactI18next.useTranslation("settings");
+  const wallpaper = useSettingsStore((state) => state.wallpaper);
+  const wallpaperModule = useSettingsStore((state) => state.wallpaperModule);
+  const setWallpaper = useSettingsStore((state) => state.setWallpaper);
+  const setWallpaperModule = useSettingsStore((state) => state.setWallpaperModule);
+  const [urlInput, setUrlInput] = React5.useState("");
+  const [pickerOpen, setPickerOpen] = React5.useState(false);
+  const fileInputRef = React5.useRef(null);
+  const resolvedWallpaper = chunkICUE6T7J_cjs.useResolvedUrl(wallpaper ?? void 0);
+  const previewSrc = resolvedWallpaper ?? defaultWallpaperSrc;
+  const handleFileChange = React5.useCallback(
+    (e) => {
+      const file = e.target.files?.[0];
+      if (!file) return;
+      const reader = new FileReader();
+      reader.onload = (evt) => {
+        const result = evt.target?.result;
+        if (typeof result === "string") setWallpaper(result);
+      };
+      reader.readAsDataURL(file);
+    },
+    [setWallpaper]
+  );
+  const handleUrlApply = React5.useCallback(() => {
+    const trimmed = urlInput.trim();
+    if (trimmed) setWallpaper(trimmed);
+  }, [urlInput, setWallpaper]);
+  const handleReset = React5.useCallback(() => {
+    setWallpaper(null);
+    setUrlInput("");
+  }, [setWallpaper]);
+  const handleFsImageSelect = React5.useCallback(
+    (node) => {
+      const imageUrl = node.url ? node.url.startsWith("idb://") ? node.url : `${undefined.BASE_URL}${node.url}` : null;
+      if (imageUrl) {
+        setWallpaper(imageUrl);
+      }
+      setPickerOpen(false);
+    },
+    [setWallpaper]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(SettingsSection_default, { title: t("wallpaper.title"), children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { children: /* @__PURE__ */ jsxRuntime.jsx(
+      chunkE55VXNLK_cjs.SegmentedControl,
+      {
+        value: wallpaperModule,
+        onChange: setWallpaperModule,
+        data: [{ value: "default", label: t("wallpaper.staticImage") }],
+        fullWidth: true
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "img",
+      {
+        src: previewSrc,
+        alt: t("wallpaper.wallpaperPreview"),
+        style: { width: "100%", height: 180, objectFit: "cover", borderRadius: 8 }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          ref: fileInputRef,
+          type: "file",
+          accept: "image/*",
+          style: { display: "none" },
+          onChange: handleFileChange,
+          "aria-label": t("wallpaper.uploadAria", { defaultValue: "Upload wallpaper file" })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Button, { variant: "light", onClick: () => setPickerOpen(true), children: t("wallpaper.chooseFromImages") }),
+      /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Button, { variant: "light", onClick: () => fileInputRef.current?.click(), children: t("wallpaper.uploadFromDisk") }),
+      /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Button, { variant: "subtle", color: "red", onClick: handleReset, children: t("wallpaper.resetToDefault") })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { align: "flex-end", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        chunkE55VXNLK_cjs.TextInput,
+        {
+          label: t("wallpaper.orEnterUrl"),
+          placeholder: "https://example.com/image.jpg",
+          value: urlInput,
+          onChange: (e) => setUrlInput(e.currentTarget.value),
+          style: { flex: 1 }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Button, { onClick: handleUrlApply, disabled: !urlInput.trim(), children: t("common:actions.apply") })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      chunkBDO6B7MZ_cjs.FilePickerModal,
+      {
+        opened: pickerOpen,
+        acceptedMimeTypes: ["image/*"],
+        onConfirm: handleFsImageSelect,
+        onCancel: () => setPickerOpen(false)
+      }
+    )
+  ] });
+};
+var WallpaperSettings_default = WallpaperSettings;
+var AppearanceSettings = () => {
+  const { t } = reactI18next.useTranslation("settings");
+  const themeMode = useSettingsStore((state) => state.theme.mode);
+  const themeSetManually = useSettingsStore((state) => state.themeSetManually);
+  const customThemeColors = useSettingsStore((state) => state.customThemeColors);
+  const animationDuration = useSettingsStore((state) => state.animationDuration);
+  const setThemeMode = useSettingsStore((state) => state.setThemeMode);
+  const setThemeAutomatic = useSettingsStore((state) => state.setThemeAutomatic);
+  const setCustomThemeColors = useSettingsStore((state) => state.setCustomThemeColors);
+  const setAnimationDuration = useSettingsStore((state) => state.setAnimationDuration);
+  const currentValue = customThemeColors ? "custom" : themeSetManually ? themeMode : "system";
+  const handleChange = React5.useCallback(
+    (value) => {
+      if (value === "system") {
+        setThemeAutomatic();
+        setCustomThemeColors(null);
+      } else if (value === "custom") {
+        setCustomThemeColors({
+          taskbar: "#339af0",
+          window: "#ffffff",
+          accent: "#339af0"
+        });
+      } else {
+        setThemeMode(value);
+        setCustomThemeColors(null);
+      }
+    },
+    [setThemeMode, setThemeAutomatic, setCustomThemeColors]
+  );
+  const handleColorChange = React5.useCallback(
+    (key) => (color) => {
+      if (customThemeColors) {
+        setCustomThemeColors({ ...customThemeColors, [key]: color });
+      }
+    },
+    [customThemeColors, setCustomThemeColors]
+  );
+  const handleAnimationChange = React5.useCallback(
+    (value) => {
+      setAnimationDuration(value);
+    },
+    [setAnimationDuration]
+  );
+  const isCustom = currentValue === "custom";
+  return /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: "md", p: "md", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { fw: 600, size: "lg", children: t("appearance.title") }),
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", c: "dimmed", children: t("appearance.description") }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      chunkE55VXNLK_cjs.SegmentedControl,
+      {
+        value: currentValue,
+        onChange: handleChange,
+        data: [
+          { label: t("common:theme.light"), value: "light" },
+          { label: t("common:theme.dark"), value: "dark" },
+          { label: t("common:theme.system"), value: "system" },
+          { label: t("common:theme.custom"), value: "custom" }
+        ],
+        "aria-label": t("appearance.themeMode", { defaultValue: "Theme mode" })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: "sm", mt: "md", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Box, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", fw: 500, mb: "xs", c: isCustom ? "dark" : void 0, children: t("appearance.taskbar") }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          chunkLMJE6V4N_cjs.ColorPicker_default,
+          {
+            value: customThemeColors?.taskbar ?? "#339af0",
+            onChange: handleColorChange("taskbar"),
+            disabled: !isCustom
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Box, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", fw: 500, mb: "xs", c: isCustom ? "dark" : void 0, children: t("appearance.window") }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          chunkLMJE6V4N_cjs.ColorPicker_default,
+          {
+            value: customThemeColors?.window ?? "#ffffff",
+            onChange: handleColorChange("window"),
+            disabled: !isCustom
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Box, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", fw: 500, mb: "xs", c: isCustom ? "dark" : void 0, children: t("appearance.accent") }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          chunkLMJE6V4N_cjs.ColorPicker_default,
+          {
+            value: customThemeColors?.accent ?? "#339af0",
+            onChange: handleColorChange("accent"),
+            disabled: !isCustom
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Box, { mt: "md", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", fw: 500, mb: "xs", children: t("appearance.animationDuration") }),
+      /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "xs", c: "dimmed", mb: "sm", children: t("appearance.animationDescription") }),
+      /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { align: "center", gap: "md", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          chunkE55VXNLK_cjs.Slider,
+          {
+            value: animationDuration,
+            onChange: handleAnimationChange,
+            min: 0.1,
+            max: 1,
+            step: 0.1,
+            style: { flex: 1 },
+            marks: [
+              { value: 0.1, label: "0.1s" },
+              { value: 0.5, label: "0.5s" },
+              { value: 1, label: "1.0s" }
+            ],
+            "aria-label": t("appearance.animationDuration")
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Text, { size: "sm", fw: 500, style: { minWidth: 40 }, children: [
+          animationDuration.toFixed(1),
+          "s"
+        ] })
+      ] })
+    ] })
+  ] });
+};
+var AppearanceSettings_default = AppearanceSettings;
+var LauncherSettings = () => {
+  const launcherIcon = useSettingsStore((state) => state.launcherIcon);
+  const setLauncherIcon = useSettingsStore((state) => state.setLauncherIcon);
+  const [allIconNames, setAllIconNames] = React5.useState([]);
+  const [search, setSearch] = React5.useState("");
+  const deferredSearch = React5.useDeferredValue(search);
+  React5.useEffect(() => {
+    import('react-icons/fc').then((mod) => {
+      const names = Object.keys(mod).filter((k) => k.startsWith("Fc")).sort();
+      setAllIconNames(names);
+    });
+  }, []);
+  const filtered = deferredSearch ? allIconNames.filter((n) => n.toLowerCase().includes(deferredSearch.toLowerCase())) : allIconNames;
+  const handleSelect = React5.useCallback(
+    (name) => {
+      setLauncherIcon(name);
+    },
+    [setLauncherIcon]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(SettingsSection_default, { title: "Launcher Icon", description: `Selected: ${launcherIcon}`, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      chunkE55VXNLK_cjs.TextInput,
+      {
+        placeholder: "Search icons...",
+        value: search,
+        onChange: (e) => setSearch(e.currentTarget.value),
+        "aria-label": "Search icons"
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.ScrollArea, { style: { flex: 1, height: 300 }, children: /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.SimpleGrid, { cols: 8, spacing: 4, children: filtered.map((name) => /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Tooltip, { label: name, withArrow: true, openDelay: 400, children: /* @__PURE__ */ jsxRuntime.jsx(
+      chunkE55VXNLK_cjs.UnstyledButton,
+      {
+        onClick: () => handleSelect(name),
+        "aria-label": name,
+        "aria-pressed": name === launcherIcon,
+        style: {
+          padding: 6,
+          borderRadius: 6,
+          background: name === launcherIcon ? "var(--mantine-primary-color-light)" : "transparent",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center"
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsx(chunkJ7L2S2GT_cjs.AppIcon_default, { fcIcon: name, size: 24 })
+      }
+    ) }, name)) }) })
+  ] });
+};
+var LauncherSettings_default = LauncherSettings;
+
+// src/constants/Fonts.ts
+var AVAILABLE_FONTS = [
+  {
+    value: "system-ui",
+    label: "System Default",
+    stack: "system-ui, Avenir, Helvetica, Arial, sans-serif"
+  },
+  { value: "Courier New", label: "Courier New", stack: '"Courier New", monospace' },
+  { value: "Source Code Pro", label: "Source Code Pro", stack: '"Source Code Pro", monospace' },
+  { value: "Open Sans", label: "Open Sans", stack: '"Open Sans", monospace' }
+];
+var FONT_STACKS = Object.fromEntries(
+  AVAILABLE_FONTS.map((f) => [f.value, f.stack])
+);
+var GOOGLE_FONTS_HREF = {
+  "Source Code Pro": "https://fonts.googleapis.com/css2?family=Source+Code+Pro&display=swap",
+  "Open Sans": "https://fonts.googleapis.com/css2?family=Open+Sans&display=swap"
+};
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/subscribable.js
+var Subscribable = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = this.subscribe.bind(this);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    this.onSubscribe();
+    return () => {
+      this.listeners.delete(listener);
+      this.onUnsubscribe();
+    };
+  }
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+  onSubscribe() {
+  }
+  onUnsubscribe() {
+  }
+};
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/focusManager.js
+var FocusManager = class extends Subscribable {
+  #focused;
+  #cleanup;
+  #setup;
+  constructor() {
+    super();
+    this.#setup = (onFocus) => {
+      if (typeof window !== "undefined" && window.addEventListener) {
+        const listener = () => onFocus();
+        window.addEventListener("visibilitychange", listener, false);
+        return () => {
+          window.removeEventListener("visibilitychange", listener);
+        };
+      }
+      return;
+    };
+  }
+  onSubscribe() {
+    if (!this.#cleanup) {
+      this.setEventListener(this.#setup);
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.#cleanup?.();
+      this.#cleanup = void 0;
+    }
+  }
+  setEventListener(setup) {
+    this.#setup = setup;
+    this.#cleanup?.();
+    this.#cleanup = setup((focused) => {
+      if (typeof focused === "boolean") {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    });
+  }
+  setFocused(focused) {
+    const changed = this.#focused !== focused;
+    if (changed) {
+      this.#focused = focused;
+      this.onFocus();
+    }
+  }
+  onFocus() {
+    const isFocused = this.isFocused();
+    this.listeners.forEach((listener) => {
+      listener(isFocused);
+    });
+  }
+  isFocused() {
+    if (typeof this.#focused === "boolean") {
+      return this.#focused;
+    }
+    return globalThis.document?.visibilityState !== "hidden";
+  }
+};
+var focusManager = new FocusManager();
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+var defaultTimeoutProvider = {
+  // We need the wrapper function syntax below instead of direct references to
+  // global setTimeout etc.
+  //
+  // BAD: `setTimeout: setTimeout`
+  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+  //
+  // If we use direct references here, then anything that wants to spy on or
+  // replace the global setTimeout (like tests) won't work since we'll already
+  // have a hard reference to the original implementation at the time when this
+  // file was imported.
+  setTimeout: (callback, delay) => setTimeout(callback, delay),
+  clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+  setInterval: (callback, delay) => setInterval(callback, delay),
+  clearInterval: (intervalId) => clearInterval(intervalId)
+};
+var TimeoutManager = class {
+  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+  // type at app boot; and if we leave that type, then any new timer provider
+  // would need to support the default provider's concrete timer ID, which is
+  // infeasible across environments.
+  //
+  // We settle for type safety for the TimeoutProvider type, and accept that
+  // this class is unsafe internally to allow for extension.
+  #provider = defaultTimeoutProvider;
+  #providerCalled = false;
+  setTimeoutProvider(provider) {
+    if (process.env.NODE_ENV !== "production") {
+      if (this.#providerCalled && provider !== this.#provider) {
+        console.error(
+          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
+          { previous: this.#provider, provider }
+        );
+      }
+    }
+    this.#provider = provider;
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = false;
+    }
+  }
+  setTimeout(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = true;
+    }
+    return this.#provider.setTimeout(callback, delay);
+  }
+  clearTimeout(timeoutId) {
+    this.#provider.clearTimeout(timeoutId);
+  }
+  setInterval(callback, delay) {
+    if (process.env.NODE_ENV !== "production") {
+      this.#providerCalled = true;
+    }
+    return this.#provider.setInterval(callback, delay);
+  }
+  clearInterval(intervalId) {
+    this.#provider.clearInterval(intervalId);
+  }
+};
+var timeoutManager = new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+  setTimeout(callback, 0);
+}
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/utils.js
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {
+}
+function isValidTimeout(value) {
+  return typeof value === "number" && value >= 0 && value !== Infinity;
+}
+function timeUntilStale(updatedAt, staleTime) {
+  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function resolveStaleTime(staleTime, query) {
+  return typeof staleTime === "function" ? staleTime(query) : staleTime;
+}
+function resolveEnabled(enabled, query) {
+  return typeof enabled === "function" ? enabled(query) : enabled;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(a, b, depth = 0) {
+  if (a === b) {
+    return a;
+  }
+  if (depth > 500) return b;
+  const array = isPlainArray(a) && isPlainArray(b);
+  if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
+  const aItems = array ? a : Object.keys(a);
+  const aSize = aItems.length;
+  const bItems = array ? b : Object.keys(b);
+  const bSize = bItems.length;
+  const copy = array ? new Array(bSize) : {};
+  let equalItems = 0;
+  for (let i = 0; i < bSize; i++) {
+    const key = array ? i : bItems[i];
+    const aItem = a[key];
+    const bItem = b[key];
+    if (aItem === bItem) {
+      copy[key] = aItem;
+      if (array ? i < aSize : hasOwn.call(a, key)) equalItems++;
+      continue;
+    }
+    if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+      copy[key] = bItem;
+      continue;
+    }
+    const v = replaceEqualDeep(aItem, bItem, depth + 1);
+    copy[key] = v;
+    if (v === aItem) equalItems++;
+  }
+  return aSize === bSize && equalItems === aSize ? a : copy;
+}
+function shallowEqualObjects(a, b) {
+  if (!b || Object.keys(a).length !== Object.keys(b).length) {
+    return false;
+  }
+  for (const key in a) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  }
+  const ctor = o.constructor;
+  if (ctor === void 0) {
+    return true;
+  }
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot)) {
+    return false;
+  }
+  if (!prot.hasOwnProperty("isPrototypeOf")) {
+    return false;
+  }
+  if (Object.getPrototypeOf(o) !== Object.prototype) {
+    return false;
+  }
+  return true;
+}
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function replaceData(prevData, data, options) {
+  if (typeof options.structuralSharing === "function") {
+    return options.structuralSharing(prevData, data);
+  } else if (options.structuralSharing !== false) {
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        return replaceEqualDeep(prevData, data);
+      } catch (error) {
+        console.error(
+          `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`
+        );
+        throw error;
+      }
+    }
+    return replaceEqualDeep(prevData, data);
+  }
+  return data;
+}
+function shouldThrowError(throwOnError, params) {
+  if (typeof throwOnError === "function") {
+    return throwOnError(...params);
+  }
+  return !!throwOnError;
+}
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/environmentManager.js
+var environmentManager = /* @__PURE__ */ (() => {
+  let isServerFn = () => isServer;
+  return {
+    /**
+     * Returns whether the current runtime should be treated as a server environment.
+     */
+    isServer() {
+      return isServerFn();
+    },
+    /**
+     * Overrides the server check globally.
+     */
+    setIsServer(isServerValue) {
+      isServerFn = isServerValue;
+    }
+  };
+})();
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/thenable.js
+function pendingThenable() {
+  let resolve;
+  let reject;
+  const thenable = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  thenable.status = "pending";
+  thenable.catch(() => {
+  });
+  function finalize(data) {
+    Object.assign(thenable, data);
+    delete thenable.resolve;
+    delete thenable.reject;
+  }
+  thenable.resolve = (value) => {
+    finalize({
+      status: "fulfilled",
+      value
+    });
+    resolve(value);
+  };
+  thenable.reject = (reason) => {
+    finalize({
+      status: "rejected",
+      reason
+    });
+    reject(reason);
+  };
+  return thenable;
+}
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/notifyManager.js
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+  let queue = [];
+  let transactions = 0;
+  let notifyFn = (callback) => {
+    callback();
+  };
+  let batchNotifyFn = (callback) => {
+    callback();
+  };
+  let scheduleFn = defaultScheduler;
+  const schedule = (callback) => {
+    if (transactions) {
+      queue.push(callback);
+    } else {
+      scheduleFn(() => {
+        notifyFn(callback);
+      });
+    }
+  };
+  const flush = () => {
+    const originalQueue = queue;
+    queue = [];
+    if (originalQueue.length) {
+      scheduleFn(() => {
+        batchNotifyFn(() => {
+          originalQueue.forEach((callback) => {
+            notifyFn(callback);
+          });
+        });
+      });
+    }
+  };
+  return {
+    batch: (callback) => {
+      let result;
+      transactions++;
+      try {
+        result = callback();
+      } finally {
+        transactions--;
+        if (!transactions) {
+          flush();
+        }
+      }
+      return result;
+    },
+    /**
+     * All calls to the wrapped function will be batched.
+     */
+    batchCalls: (callback) => {
+      return (...args) => {
+        schedule(() => {
+          callback(...args);
+        });
+      };
+    },
+    schedule,
+    /**
+     * Use this method to set a custom notify function.
+     * This can be used to for example wrap notifications with `React.act` while running tests.
+     */
+    setNotifyFunction: (fn) => {
+      notifyFn = fn;
+    },
+    /**
+     * Use this method to set a custom function to batch notifications together into a single tick.
+     * By default React Query will use the batch function provided by ReactDOM or React Native.
+     */
+    setBatchNotifyFunction: (fn) => {
+      batchNotifyFn = fn;
+    },
+    setScheduler: (fn) => {
+      scheduleFn = fn;
+    }
+  };
+}
+var notifyManager = createNotifyManager();
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/onlineManager.js
+var OnlineManager = class extends Subscribable {
+  #online = true;
+  #cleanup;
+  #setup;
+  constructor() {
+    super();
+    this.#setup = (onOnline) => {
+      if (typeof window !== "undefined" && window.addEventListener) {
+        const onlineListener = () => onOnline(true);
+        const offlineListener = () => onOnline(false);
+        window.addEventListener("online", onlineListener, false);
+        window.addEventListener("offline", offlineListener, false);
+        return () => {
+          window.removeEventListener("online", onlineListener);
+          window.removeEventListener("offline", offlineListener);
+        };
+      }
+      return;
+    };
+  }
+  onSubscribe() {
+    if (!this.#cleanup) {
+      this.setEventListener(this.#setup);
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.#cleanup?.();
+      this.#cleanup = void 0;
+    }
+  }
+  setEventListener(setup) {
+    this.#setup = setup;
+    this.#cleanup?.();
+    this.#cleanup = setup(this.setOnline.bind(this));
+  }
+  setOnline(online) {
+    const changed = this.#online !== online;
+    if (changed) {
+      this.#online = online;
+      this.listeners.forEach((listener) => {
+        listener(online);
+      });
+    }
+  }
+  isOnline() {
+    return this.#online;
+  }
+};
+var onlineManager = new OnlineManager();
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/retryer.js
+function canFetch(networkMode) {
+  return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+}
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/query.js
+function fetchState(data, options) {
+  return {
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+    ...data === void 0 && {
+      error: null,
+      status: "pending"
+    }
+  };
+}
+
+// ../../node_modules/.bun/@tanstack+query-core@5.96.1/node_modules/@tanstack/query-core/build/modern/queryObserver.js
+var QueryObserver = class extends Subscribable {
+  constructor(client, options) {
+    super();
+    this.options = options;
+    this.#client = client;
+    this.#selectError = null;
+    this.#currentThenable = pendingThenable();
+    this.bindMethods();
+    this.setOptions(options);
+  }
+  #client;
+  #currentQuery = void 0;
+  #currentQueryInitialState = void 0;
+  #currentResult = void 0;
+  #currentResultState;
+  #currentResultOptions;
+  #currentThenable;
+  #selectError;
+  #selectFn;
+  #selectResult;
+  // This property keeps track of the last query with defined data.
+  // It will be used to pass the previous data and query to the placeholder function between renders.
+  #lastQueryWithDefinedData;
+  #staleTimeoutId;
+  #refetchIntervalId;
+  #currentRefetchInterval;
+  #trackedProps = /* @__PURE__ */ new Set();
+  bindMethods() {
+    this.refetch = this.refetch.bind(this);
+  }
+  onSubscribe() {
+    if (this.listeners.size === 1) {
+      this.#currentQuery.addObserver(this);
+      if (shouldFetchOnMount(this.#currentQuery, this.options)) {
+        this.#executeFetch();
+      } else {
+        this.updateResult();
+      }
+      this.#updateTimers();
+    }
+  }
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.destroy();
+    }
+  }
+  shouldFetchOnReconnect() {
+    return shouldFetchOn(
+      this.#currentQuery,
+      this.options,
+      this.options.refetchOnReconnect
+    );
+  }
+  shouldFetchOnWindowFocus() {
+    return shouldFetchOn(
+      this.#currentQuery,
+      this.options,
+      this.options.refetchOnWindowFocus
+    );
+  }
+  destroy() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.#clearStaleTimeout();
+    this.#clearRefetchInterval();
+    this.#currentQuery.removeObserver(this);
+  }
+  setOptions(options) {
+    const prevOptions = this.options;
+    const prevQuery = this.#currentQuery;
+    this.options = this.#client.defaultQueryOptions(options);
+    if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, this.#currentQuery) !== "boolean") {
+      throw new Error(
+        "Expected enabled to be a boolean or a callback that returns a boolean"
+      );
+    }
+    this.#updateQuery();
+    this.#currentQuery.setOptions(this.options);
+    if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
+      this.#client.getQueryCache().notify({
+        type: "observerOptionsUpdated",
+        query: this.#currentQuery,
+        observer: this
+      });
+    }
+    const mounted = this.hasListeners();
+    if (mounted && shouldFetchOptionally(
+      this.#currentQuery,
+      prevQuery,
+      this.options,
+      prevOptions
+    )) {
+      this.#executeFetch();
+    }
+    this.updateResult();
+    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) {
+      this.#updateStaleTimeout();
+    }
+    const nextRefetchInterval = this.#computeRefetchInterval();
+    if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) {
+      this.#updateRefetchInterval(nextRefetchInterval);
+    }
+  }
+  getOptimisticResult(options) {
+    const query = this.#client.getQueryCache().build(this.#client, options);
+    const result = this.createResult(query, options);
+    if (shouldAssignObserverCurrentProperties(this, result)) {
+      this.#currentResult = result;
+      this.#currentResultOptions = this.options;
+      this.#currentResultState = this.#currentQuery.state;
+    }
+    return result;
+  }
+  getCurrentResult() {
+    return this.#currentResult;
+  }
+  trackResult(result, onPropTracked) {
+    return new Proxy(result, {
+      get: (target, key) => {
+        this.trackProp(key);
+        onPropTracked?.(key);
+        if (key === "promise") {
+          this.trackProp("data");
+          if (!this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") {
+            this.#currentThenable.reject(
+              new Error(
+                "experimental_prefetchInRender feature flag is not enabled"
+              )
+            );
+          }
+        }
+        return Reflect.get(target, key);
+      }
+    });
+  }
+  trackProp(key) {
+    this.#trackedProps.add(key);
+  }
+  getCurrentQuery() {
+    return this.#currentQuery;
+  }
+  refetch({ ...options } = {}) {
+    return this.fetch({
+      ...options
+    });
+  }
+  fetchOptimistic(options) {
+    const defaultedOptions = this.#client.defaultQueryOptions(options);
+    const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
+    return query.fetch().then(() => this.createResult(query, defaultedOptions));
+  }
+  fetch(fetchOptions) {
+    return this.#executeFetch({
+      ...fetchOptions,
+      cancelRefetch: fetchOptions.cancelRefetch ?? true
+    }).then(() => {
+      this.updateResult();
+      return this.#currentResult;
+    });
+  }
+  #executeFetch(fetchOptions) {
+    this.#updateQuery();
+    let promise = this.#currentQuery.fetch(
+      this.options,
+      fetchOptions
+    );
+    if (!fetchOptions?.throwOnError) {
+      promise = promise.catch(noop);
+    }
+    return promise;
+  }
+  #updateStaleTimeout() {
+    this.#clearStaleTimeout();
+    const staleTime = resolveStaleTime(
+      this.options.staleTime,
+      this.#currentQuery
+    );
+    if (environmentManager.isServer() || this.#currentResult.isStale || !isValidTimeout(staleTime)) {
+      return;
+    }
+    const time = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime);
+    const timeout = time + 1;
+    this.#staleTimeoutId = timeoutManager.setTimeout(() => {
+      if (!this.#currentResult.isStale) {
+        this.updateResult();
+      }
+    }, timeout);
+  }
+  #computeRefetchInterval() {
+    return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false;
+  }
+  #updateRefetchInterval(nextInterval) {
+    this.#clearRefetchInterval();
+    this.#currentRefetchInterval = nextInterval;
+    if (environmentManager.isServer() || resolveEnabled(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
+      return;
+    }
+    this.#refetchIntervalId = timeoutManager.setInterval(() => {
+      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+        this.#executeFetch();
+      }
+    }, this.#currentRefetchInterval);
+  }
+  #updateTimers() {
+    this.#updateStaleTimeout();
+    this.#updateRefetchInterval(this.#computeRefetchInterval());
+  }
+  #clearStaleTimeout() {
+    if (this.#staleTimeoutId) {
+      timeoutManager.clearTimeout(this.#staleTimeoutId);
+      this.#staleTimeoutId = void 0;
+    }
+  }
+  #clearRefetchInterval() {
+    if (this.#refetchIntervalId) {
+      timeoutManager.clearInterval(this.#refetchIntervalId);
+      this.#refetchIntervalId = void 0;
+    }
+  }
+  createResult(query, options) {
+    const prevQuery = this.#currentQuery;
+    const prevOptions = this.options;
+    const prevResult = this.#currentResult;
+    const prevResultState = this.#currentResultState;
+    const prevResultOptions = this.#currentResultOptions;
+    const queryChange = query !== prevQuery;
+    const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
+    const { state } = query;
+    let newState = { ...state };
+    let isPlaceholderData = false;
+    let data;
+    if (options._optimisticResults) {
+      const mounted = this.hasListeners();
+      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+      if (fetchOnMount || fetchOptionally) {
+        newState = {
+          ...newState,
+          ...fetchState(state.data, query.options)
+        };
+      }
+      if (options._optimisticResults === "isRestoring") {
+        newState.fetchStatus = "idle";
+      }
+    }
+    let { error, errorUpdatedAt, status } = newState;
+    data = newState.data;
+    let skipSelect = false;
+    if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
+      let placeholderData;
+      if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
+        placeholderData = prevResult.data;
+        skipSelect = true;
+      } else {
+        placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(
+          this.#lastQueryWithDefinedData?.state.data,
+          this.#lastQueryWithDefinedData
+        ) : options.placeholderData;
+      }
+      if (placeholderData !== void 0) {
+        status = "success";
+        data = replaceData(
+          prevResult?.data,
+          placeholderData,
+          options
+        );
+        isPlaceholderData = true;
+      }
+    }
+    if (options.select && data !== void 0 && !skipSelect) {
+      if (prevResult && data === prevResultState?.data && options.select === this.#selectFn) {
+        data = this.#selectResult;
+      } else {
+        try {
+          this.#selectFn = options.select;
+          data = options.select(data);
+          data = replaceData(prevResult?.data, data, options);
+          this.#selectResult = data;
+          this.#selectError = null;
+        } catch (selectError) {
+          this.#selectError = selectError;
+        }
+      }
+    }
+    if (this.#selectError) {
+      error = this.#selectError;
+      data = this.#selectResult;
+      errorUpdatedAt = Date.now();
+      status = "error";
+    }
+    const isFetching = newState.fetchStatus === "fetching";
+    const isPending = status === "pending";
+    const isError = status === "error";
+    const isLoading = isPending && isFetching;
+    const hasData = data !== void 0;
+    const result = {
+      status,
+      fetchStatus: newState.fetchStatus,
+      isPending,
+      isSuccess: status === "success",
+      isError,
+      isInitialLoading: isLoading,
+      isLoading,
+      data,
+      dataUpdatedAt: newState.dataUpdatedAt,
+      error,
+      errorUpdatedAt,
+      failureCount: newState.fetchFailureCount,
+      failureReason: newState.fetchFailureReason,
+      errorUpdateCount: newState.errorUpdateCount,
+      isFetched: query.isFetched(),
+      isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
+      isFetching,
+      isRefetching: isFetching && !isPending,
+      isLoadingError: isError && !hasData,
+      isPaused: newState.fetchStatus === "paused",
+      isPlaceholderData,
+      isRefetchError: isError && hasData,
+      isStale: isStale(query, options),
+      refetch: this.refetch,
+      promise: this.#currentThenable,
+      isEnabled: resolveEnabled(options.enabled, query) !== false
+    };
+    const nextResult = result;
+    if (this.options.experimental_prefetchInRender) {
+      const hasResultData = nextResult.data !== void 0;
+      const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
+      const finalizeThenableIfPossible = (thenable) => {
+        if (isErrorWithoutData) {
+          thenable.reject(nextResult.error);
+        } else if (hasResultData) {
+          thenable.resolve(nextResult.data);
+        }
+      };
+      const recreateThenable = () => {
+        const pending = this.#currentThenable = nextResult.promise = pendingThenable();
+        finalizeThenableIfPossible(pending);
+      };
+      const prevThenable = this.#currentThenable;
+      switch (prevThenable.status) {
+        case "pending":
+          if (query.queryHash === prevQuery.queryHash) {
+            finalizeThenableIfPossible(prevThenable);
+          }
+          break;
+        case "fulfilled":
+          if (isErrorWithoutData || nextResult.data !== prevThenable.value) {
+            recreateThenable();
+          }
+          break;
+        case "rejected":
+          if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) {
+            recreateThenable();
+          }
+          break;
+      }
+    }
+    return nextResult;
+  }
+  updateResult() {
+    const prevResult = this.#currentResult;
+    const nextResult = this.createResult(this.#currentQuery, this.options);
+    this.#currentResultState = this.#currentQuery.state;
+    this.#currentResultOptions = this.options;
+    if (this.#currentResultState.data !== void 0) {
+      this.#lastQueryWithDefinedData = this.#currentQuery;
+    }
+    if (shallowEqualObjects(nextResult, prevResult)) {
+      return;
+    }
+    this.#currentResult = nextResult;
+    const shouldNotifyListeners = () => {
+      if (!prevResult) {
+        return true;
+      }
+      const { notifyOnChangeProps } = this.options;
+      const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
+      if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !this.#trackedProps.size) {
+        return true;
+      }
+      const includedProps = new Set(
+        notifyOnChangePropsValue ?? this.#trackedProps
+      );
+      if (this.options.throwOnError) {
+        includedProps.add("error");
+      }
+      return Object.keys(this.#currentResult).some((key) => {
+        const typedKey = key;
+        const changed = this.#currentResult[typedKey] !== prevResult[typedKey];
+        return changed && includedProps.has(typedKey);
+      });
+    };
+    this.#notify({ listeners: shouldNotifyListeners() });
+  }
+  #updateQuery() {
+    const query = this.#client.getQueryCache().build(this.#client, this.options);
+    if (query === this.#currentQuery) {
+      return;
+    }
+    const prevQuery = this.#currentQuery;
+    this.#currentQuery = query;
+    this.#currentQueryInitialState = query.state;
+    if (this.hasListeners()) {
+      prevQuery?.removeObserver(this);
+      query.addObserver(this);
+    }
+  }
+  onQueryUpdate() {
+    this.updateResult();
+    if (this.hasListeners()) {
+      this.#updateTimers();
+    }
+  }
+  #notify(notifyOptions) {
+    notifyManager.batch(() => {
+      if (notifyOptions.listeners) {
+        this.listeners.forEach((listener) => {
+          listener(this.#currentResult);
+        });
+      }
+      this.#client.getQueryCache().notify({
+        query: this.#currentQuery,
+        type: "observerResultsUpdated"
+      });
+    });
+  }
+};
+function shouldLoadOnMount(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false);
+}
+function shouldFetchOnMount(query, options) {
+  return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
+}
+function shouldFetchOn(query, options, field) {
+  if (resolveEnabled(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
+    const value = typeof field === "function" ? field(query) : field;
+    return value === "always" || value !== false && isStale(query, options);
+  }
+  return false;
+}
+function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+  return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+}
+function isStale(query, options) {
+  return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+}
+function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+    return true;
+  }
+  return false;
+}
+var QueryClientContext = React5__namespace.createContext(
+  void 0
+);
+var useQueryClient = (queryClient) => {
+  const client = React5__namespace.useContext(QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client;
+};
+var IsRestoringContext = React5__namespace.createContext(false);
+var useIsRestoring = () => React5__namespace.useContext(IsRestoringContext);
+IsRestoringContext.Provider;
+function createValue() {
+  let isReset = false;
+  return {
+    clearReset: () => {
+      isReset = false;
+    },
+    reset: () => {
+      isReset = true;
+    },
+    isReset: () => {
+      return isReset;
+    }
+  };
+}
+var QueryErrorResetBoundaryContext = React5__namespace.createContext(createValue());
+var useQueryErrorResetBoundary = () => React5__namespace.useContext(QueryErrorResetBoundaryContext);
+var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
+  const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
+  if (options.suspense || options.experimental_prefetchInRender || throwOnError) {
+    if (!errorResetBoundary.isReset()) {
+      options.retryOnMount = false;
+    }
+  }
+};
+var useClearResetErrorBoundary = (errorResetBoundary) => {
+  React5__namespace.useEffect(() => {
+    errorResetBoundary.clearReset();
+  }, [errorResetBoundary]);
+};
+var getHasError = ({
+  result,
+  errorResetBoundary,
+  throwOnError,
+  query,
+  suspense
+}) => {
+  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
+};
+
+// ../../node_modules/.bun/@tanstack+react-query@5.96.1+b1ab299f0a400331/node_modules/@tanstack/react-query/build/modern/suspense.js
+var ensureSuspenseTimers = (defaultedOptions) => {
+  if (defaultedOptions.suspense) {
+    const MIN_SUSPENSE_TIME_MS = 1e3;
+    const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
+    const originalStaleTime = defaultedOptions.staleTime;
+    defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
+    if (typeof defaultedOptions.gcTime === "number") {
+      defaultedOptions.gcTime = Math.max(
+        defaultedOptions.gcTime,
+        MIN_SUSPENSE_TIME_MS
+      );
+    }
+  }
+};
+var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
+var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+  errorResetBoundary.clearReset();
+});
+function useBaseQuery(options, Observer, queryClient) {
+  if (process.env.NODE_ENV !== "production") {
+    if (typeof options !== "object" || Array.isArray(options)) {
+      throw new Error(
+        'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+      );
+    }
+  }
+  const isRestoring = useIsRestoring();
+  const errorResetBoundary = useQueryErrorResetBoundary();
+  const client = useQueryClient();
+  const defaultedOptions = client.defaultQueryOptions(options);
+  client.getDefaultOptions().queries?._experimental_beforeQuery?.(
+    defaultedOptions
+  );
+  const query = client.getQueryCache().get(defaultedOptions.queryHash);
+  if (process.env.NODE_ENV !== "production") {
+    if (!defaultedOptions.queryFn) {
+      console.error(
+        `[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
+      );
+    }
+  }
+  defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
+  ensureSuspenseTimers(defaultedOptions);
+  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
+  useClearResetErrorBoundary(errorResetBoundary);
+  const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+  const [observer] = React5__namespace.useState(
+    () => new Observer(
+      client,
+      defaultedOptions
+    )
+  );
+  const result = observer.getOptimisticResult(defaultedOptions);
+  const shouldSubscribe = !isRestoring && options.subscribed !== false;
+  React5__namespace.useSyncExternalStore(
+    React5__namespace.useCallback(
+      (onStoreChange) => {
+        const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
+        observer.updateResult();
+        return unsubscribe;
+      },
+      [observer, shouldSubscribe]
+    ),
+    () => observer.getCurrentResult(),
+    () => observer.getCurrentResult()
+  );
+  React5__namespace.useEffect(() => {
+    observer.setOptions(defaultedOptions);
+  }, [defaultedOptions, observer]);
+  if (shouldSuspend(defaultedOptions, result)) {
+    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+  }
+  if (getHasError({
+    result,
+    errorResetBoundary,
+    throwOnError: defaultedOptions.throwOnError,
+    query,
+    suspense: defaultedOptions.suspense
+  })) {
+    throw result.error;
+  }
+  client.getDefaultOptions().queries?._experimental_afterQuery?.(
+    defaultedOptions,
+    result
+  );
+  if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) {
+    const promise = isNewCacheEntry ? (
+      // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+      fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
+    ) : (
+      // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+      query?.promise
+    );
+    promise?.catch(noop).finally(() => {
+      observer.updateResult();
+    });
+  }
+  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+
+// ../../node_modules/.bun/@tanstack+react-query@5.96.1+b1ab299f0a400331/node_modules/@tanstack/react-query/build/modern/useQuery.js
+function useQuery(options, queryClient) {
+  return useBaseQuery(options, QueryObserver);
+}
+
+// src/hooks/injectFontLink.ts
+var injectFontLink = (font) => {
+  const href = GOOGLE_FONTS_HREF[font];
+  if (!href) return;
+  const existing = document.head.querySelector(`link[data-font="${font}"]`);
+  if (existing) return;
+  const link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.href = href;
+  link.setAttribute("data-font", font);
+  document.head.appendChild(link);
+};
+
+// src/hooks/useFontDownload.ts
+var fetchFontCss = async (font) => {
+  const href = GOOGLE_FONTS_HREF[font];
+  if (!href) {
+    throw new Error(`Font "${font}" not found in Google Fonts`);
+  }
+  const response = await fetch(href);
+  if (!response.ok) {
+    throw new Error(`Failed to download font: HTTP ${response.status}`);
+  }
+  await response.text();
+  injectFontLink(font);
+  return { font, success: true };
+};
+var useFontDownload = (font) => {
+  const queryClient = useQueryClient();
+  const markFontDownloaded = useSettingsStore((state) => state.markFontDownloaded);
+  const downloadedFonts = useSettingsStore((state) => state.downloadedFonts);
+  const isDownloaded = font ? downloadedFonts.includes(font) : false;
+  const needsDownload = font && !isDownloaded && GOOGLE_FONTS_HREF[font];
+  const query = useQuery({
+    queryKey: ["font", font ?? ""],
+    queryFn: async ({ queryKey }) => {
+      const [, fontName] = queryKey;
+      if (!fontName || !GOOGLE_FONTS_HREF[fontName]) {
+        throw new Error(`Font "${fontName}" not available`);
+      }
+      const result = await fetchFontCss(fontName);
+      if (result.success) {
+        markFontDownloaded(fontName);
+      }
+      return result;
+    },
+    enabled: !!needsDownload,
+    staleTime: Infinity,
+    gcTime: Infinity,
+    retry: false
+  });
+  const progress = query.isFetching ? { status: "downloading", loaded: 0, total: null, percent: null, error: null } : query.isError ? {
+    status: "error",
+    loaded: 0,
+    total: null,
+    percent: null,
+    error: query.error?.message ?? "Unknown error"
+  } : query.isSuccess ? { status: "done", loaded: 0, total: 0, percent: 100, error: null } : { status: "idle", loaded: 0, total: null, percent: null, error: null };
+  const reset = () => {
+    if (font) {
+      queryClient.removeQueries({ queryKey: ["font", font] });
+    }
+  };
+  return {
+    ...query,
+    progress,
+    isDownloaded,
+    reset
+  };
+};
+var ERROR_COLOR = chunkZX3EDZ5C_cjs.PRESET_COLORS[1];
+var FontDownloadStatus = ({ status, error, onDownload }) => {
+  const { t } = reactI18next.useTranslation("settings");
+  if (error) {
+    return /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Badge, { color: ERROR_COLOR, variant: "filled", size: "sm", "aria-label": `Download error: ${error}`, children: t("common:status.error") });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    chunkE55VXNLK_cjs.Button,
+    {
+      size: "xs",
+      variant: "light",
+      onClick: onDownload,
+      loading: status === "downloading",
+      "aria-label": t("font.download"),
+      children: t("font.download")
+    }
+  );
+};
+var FontSettings = () => {
+  const { t } = reactI18next.useTranslation("settings");
+  const font = useSettingsStore((state) => state.font);
+  const setFont = useSettingsStore((state) => state.setFont);
+  const fontSize = useSettingsStore((state) => state.fontSize);
+  const setFontSize = useSettingsStore((state) => state.setFontSize);
+  const downloadedFonts = useSettingsStore((state) => state.downloadedFonts);
+  const markFontDownloaded = useSettingsStore((state) => state.markFontDownloaded);
+  const [activeDownload, setActiveDownload] = React5.useState(null);
+  const fontDownload = useFontDownload(activeDownload);
+  React5.useEffect(() => {
+    if (fontDownload.isSuccess && fontDownload.data?.success && activeDownload) {
+      if (!downloadedFonts.includes(activeDownload)) {
+        markFontDownloaded(activeDownload);
+      }
+    }
+  }, [
+    fontDownload.isSuccess,
+    fontDownload.data,
+    activeDownload,
+    downloadedFonts,
+    markFontDownloaded
+  ]);
+  const handleDownloadFont = React5.useCallback((fontName) => {
+    setActiveDownload(fontName);
+  }, []);
+  const getFontStatus = (fontName) => {
+    if (downloadedFonts.includes(fontName)) return "done";
+    if (activeDownload === fontName) {
+      return fontDownload.progress.status;
+    }
+    return "idle";
+  };
+  const getFontError = (fontName) => {
+    if (activeDownload === fontName) {
+      return fontDownload.progress.error;
+    }
+    return null;
+  };
+  const handleDownloadCustomFont = React5.useCallback((customName) => {
+    const trimmed = customName.trim();
+    if (!trimmed) return;
+    const familyParam = trimmed.replace(/\s+/g, "+");
+    const href = `https://fonts.googleapis.com/css2?family=${familyParam}&display=swap`;
+    GOOGLE_FONTS_HREF[trimmed] = href;
+    setActiveDownload(trimmed);
+  }, []);
+  const availableFontValues = AVAILABLE_FONTS.map((f) => f.value);
+  const customFonts = downloadedFonts.filter((f) => !availableFontValues.includes(f));
+  return /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: "md", p: "md", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { fw: 600, size: "lg", children: t("font.title") }),
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", c: "dimmed", children: t("font.description") }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      chunkE55VXNLK_cjs.Radio.Group,
+      {
+        value: font,
+        onChange: setFont,
+        "aria-label": t("font.selectionAria", { defaultValue: "Font selection" }),
+        children: /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: "xs", children: [
+          AVAILABLE_FONTS.map((f) => {
+            const hasGoogleFont = !!GOOGLE_FONTS_HREF[f.value];
+            const isDownloaded = downloadedFonts.includes(f.value);
+            const status = getFontStatus(f.value);
+            const error = getFontError(f.value);
+            const isReady = !hasGoogleFont || isDownloaded || status === "done";
+            return /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Paper, { p: "sm", withBorder: true, radius: "md", children: /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: "xs", children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { justify: "space-between", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  chunkE55VXNLK_cjs.Radio,
+                  {
+                    value: f.value,
+                    label: f.label,
+                    "aria-label": f.label,
+                    disabled: !isReady
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { gap: "xs", align: "center", children: [
+                  isReady && /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", c: "dimmed", style: { fontFamily: f.stack }, children: "AaBbCcDd" }),
+                  hasGoogleFont && /* @__PURE__ */ jsxRuntime.jsx(
+                    FontDownloadStatus,
+                    {
+                      fontLabel: f.label,
+                      status,
+                      error,
+                      onDownload: () => handleDownloadFont(f.value),
+                      isDownloaded
+                    }
+                  )
+                ] })
+              ] }),
+              hasGoogleFont && status === "downloading" && /* @__PURE__ */ jsxRuntime.jsx(chunk2PSTHGTD_cjs.DownloadProgress_default, { state: fontDownload.progress })
+            ] }) }, f.value);
+          }),
+          customFonts.map((fontName) => /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Paper, { p: "sm", withBorder: true, radius: "md", children: /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { justify: "space-between", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Radio, { value: fontName, label: fontName, "aria-label": fontName }),
+            /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", c: "dimmed", style: { fontFamily: `"${fontName}"` }, children: "AaBbCcDd" })
+          ] }) }, fontName))
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Paper, { p: "sm", withBorder: true, radius: "md", children: /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: "xs", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { justify: "space-between", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", fw: 500, children: t("font.fontSize") }),
+        /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Text, { size: "sm", c: "dimmed", children: [
+          fontSize,
+          "px"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        chunkE55VXNLK_cjs.Slider,
+        {
+          value: fontSize,
+          onChange: setFontSize,
+          min: 10,
+          max: 24,
+          step: 1,
+          marks: [{ value: 10 }, { value: 14 }, { value: 18 }, { value: 20 }, { value: 24 }],
+          "aria-label": t("font.fontSizeAria", { defaultValue: "Font size" })
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      CustomFontDownloader,
+      {
+        onDownload: handleDownloadCustomFont,
+        activeDownload,
+        fontDownload
+      }
+    )
+  ] });
+};
+var CustomFontDownloader = ({
+  onDownload,
+  activeDownload,
+  fontDownload
+}) => {
+  const { t } = reactI18next.useTranslation("settings");
+  const [customFontName, setCustomFontName] = React5.useState("");
+  const isActive = activeDownload === customFontName.trim();
+  const status = isActive ? fontDownload.progress.status : "idle";
+  const hasError = isActive && fontDownload.progress.status === "error";
+  const handleNameChange = React5.useCallback(
+    (value) => {
+      setCustomFontName(value);
+      if (hasError) {
+        fontDownload.reset?.();
+      }
+    },
+    [hasError, fontDownload]
+  );
+  const handleDownloadClick = React5.useCallback(() => {
+    onDownload(customFontName);
+  }, [customFontName, onDownload]);
+  const isSuccess = isActive && status === "done";
+  return /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Paper, { p: "sm", withBorder: true, radius: "md", children: /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: "xs", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Text, { size: "sm", fw: 500, children: [
+      t("font.downloadByName"),
+      " ",
+      /* @__PURE__ */ jsxRuntime.jsx("a", { href: "https://fonts.google.com/", target: "_blank", rel: "noreferrer", children: t("font.fromGoogleFonts") })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { gap: "xs", align: "flex-start", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        chunkE55VXNLK_cjs.TextInput,
+        {
+          placeholder: t("font.namePlaceholder", { defaultValue: "e.g. Open Sans" }),
+          value: customFontName,
+          onChange: (e) => handleNameChange(e.currentTarget.value),
+          style: { flex: 1 },
+          "aria-label": t("font.customNameAria", { defaultValue: "Custom font name" }),
+          error: hasError ? t("font.downloadError") : void 0
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        chunkE55VXNLK_cjs.Button,
+        {
+          onClick: handleDownloadClick,
+          disabled: !customFontName.trim() || status === "downloading",
+          loading: status === "downloading",
+          "aria-label": t("font.downloadCustomAria", { defaultValue: "Download custom font" }),
+          style: { marginTop: hasError ? 0 : void 0 },
+          children: t("font.download")
+        }
+      )
+    ] }),
+    status === "downloading" && /* @__PURE__ */ jsxRuntime.jsx(chunk2PSTHGTD_cjs.DownloadProgress_default, { state: fontDownload.progress }),
+    isSuccess && /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "xs", c: "dimmed", children: t("font.downloadSuccess") })
+  ] }) });
+};
+var FontSettings_default = FontSettings;
+
+// src/infrastructure/i18nConstants.ts
+var SUPPORTED_LANGUAGES2 = ["en", "es"];
+var DEFAULT_LANGUAGE2 = "en";
+
+// src/components/Shared/LanguageFlag/LanguageFlag.module.css
+var LanguageFlag_default = {};
+var FLAGS = {
+  en: /* @__PURE__ */ jsxRuntime.jsxs("svg", { viewBox: "0 0 60 40", className: LanguageFlag_default.flag, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("rect", { fill: "#012169", width: "60", height: "40" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M0,0 L60,40 M60,0 L0,40", stroke: "#fff", strokeWidth: "6" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M0,0 L60,40 M60,0 L0,40", stroke: "#C8102E", strokeWidth: "4" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M30,0 V40 M0,20 H60", stroke: "#fff", strokeWidth: "10" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M30,0 V40 M0,20 H60", stroke: "#C8102E", strokeWidth: "6" })
+  ] }),
+  es: /* @__PURE__ */ jsxRuntime.jsxs("svg", { viewBox: "0 0 60 40", className: LanguageFlag_default.flag, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("rect", { fill: "#C60B1E", width: "60", height: "40" }),
+    /* @__PURE__ */ jsxRuntime.jsx("rect", { fill: "#FFC400", y: "10", width: "60", height: "20" })
+  ] })
+};
+var LanguageFlag = ({ lang, size = 20 }) => /* @__PURE__ */ jsxRuntime.jsx(
+  "div",
+  {
+    style: { width: size * 1.5, height: size },
+    className: LanguageFlag_default.container,
+    "aria-label": lang === "en" ? "English" : "Espa\xF1ol",
+    "data-testid": `flag-${lang}`,
+    children: FLAGS[lang]
+  }
+);
+var LanguageFlag_default2 = LanguageFlag;
+var LANGUAGE_NAMES = {
+  en: "English",
+  es: "Espa\xF1ol"
+};
+var LanguageSettings = () => {
+  const { t } = reactI18next.useTranslation("settings");
+  const language = useSettingsStore((state) => state.language);
+  const setLanguage = useSettingsStore((state) => state.setLanguage);
+  const handleSelect = React5.useCallback(
+    (lang) => {
+      setLanguage(lang);
+    },
+    [setLanguage]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(SettingsSection_default, { title: t("language.title"), description: t("language.description"), children: /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Stack, { gap: "xs", children: SUPPORTED_LANGUAGES2.map((lang) => /* @__PURE__ */ jsxRuntime.jsx(
+    chunkE55VXNLK_cjs.UnstyledButton,
+    {
+      onClick: () => handleSelect(lang),
+      "aria-label": LANGUAGE_NAMES[lang],
+      "aria-pressed": lang === language,
+      style: {
+        padding: "12px 16px",
+        borderRadius: 8,
+        width: "100%",
+        background: lang === language ? "var(--mantine-primary-color-light)" : "transparent",
+        border: lang === language ? "1px solid var(--mantine-primary-color-filled)" : "1px solid transparent",
+        transition: "all 0.15s ease",
+        cursor: "pointer"
+      },
+      children: /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { gap: "sm", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(LanguageFlag_default2, { lang, size: 24 }),
+        /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { fw: lang === language ? 600 : 400, children: LANGUAGE_NAMES[lang] })
+      ] })
+    },
+    lang
+  )) }) });
+};
+var LanguageSettings_default = LanguageSettings;
+
+// src/utils/clearBrowserData.ts
+async function clearBrowserData(options) {
+  const globalScope = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : void 0;
+  if (!globalScope) {
+    return;
+  }
+  if (!options?.keepServiceWorker && "serviceWorker" in globalScope.navigator) {
+    const registrations = await globalScope.navigator.serviceWorker.getRegistrations();
+    for (const registration of registrations) {
+      await registration.unregister();
+    }
+  }
+  if ("caches" in globalScope) {
+    const cacheNames = await globalScope.caches.keys();
+    for (const name of cacheNames) {
+      await globalScope.caches.delete(name);
+    }
+  }
+  if (!options?.keepIndexedDB && "indexedDB" in globalScope) {
+    const dbs = await globalScope.indexedDB.databases();
+    for (const db of dbs) {
+      if (db.name) {
+        globalScope.indexedDB.deleteDatabase(db.name);
+      }
+    }
+  }
+  if (!options?.keepLocalStorage && "localStorage" in globalScope) {
+    globalScope.localStorage.clear();
+  }
+  if (!options?.keepSessionStorage && "sessionStorage" in globalScope) {
+    globalScope.sessionStorage.clear();
+  }
+}
+
+// src/utils/resetDockerWorkspace.ts
+async function resetDockerWorkspace() {
+  if (!chunkZ5YGWL65_cjs.isDocker()) return;
+  await fetch("/api/fs/reset", { method: "POST" });
+  await fetch("/api/fs/seed", { method: "POST" });
+}
+var ResetSettings = () => {
+  const { t } = reactI18next.useTranslation("settings");
+  const [modalOpen, setModalOpen] = React5.useState(false);
+  const handleOpenModal = React5.useCallback(() => {
+    setModalOpen(true);
+  }, []);
+  const handleCloseModal = React5.useCallback(() => {
+    setModalOpen(false);
+  }, []);
+  const handleConfirmReset = React5.useCallback(async () => {
+    await resetDockerWorkspace();
+    await clearBrowserData();
+    window.location.reload();
+  }, []);
+  const handleKeepFiles = React5.useCallback(async () => {
+    await resetDockerWorkspace();
+    await clearBrowserData({ keepIndexedDB: true });
+    window.location.reload();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs(SettingsSection_default, { title: t("reset.title"), description: t("reset.description"), children: [
+    /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Button, { color: "red", onClick: handleOpenModal, style: { alignSelf: "flex-start" }, children: t("reset.resetButton") }),
+    modalOpen && /* @__PURE__ */ jsxRuntime.jsx(
+      chunkE55VXNLK_cjs.Box,
+      {
+        style: {
+          position: "fixed",
+          top: 0,
+          left: 0,
+          right: 0,
+          bottom: 0,
+          background: "rgba(0,0,0,0.5)",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          zIndex: 1e3
+        },
+        role: "dialog",
+        "aria-label": "Confirm reset",
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          chunkE55VXNLK_cjs.Box,
+          {
+            style: {
+              background: "var(--mantine-color-default)",
+              borderRadius: 8,
+              padding: 24,
+              maxWidth: 400,
+              width: "100%"
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: "md", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { fw: 600, size: "lg", ta: "center", children: t("reset.modalTitle") }),
+              /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", c: "dimmed", ta: "center", children: t("reset.modalDescription") }),
+              /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Group, { justify: "center", gap: "xs", mt: "md", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Button, { variant: "default", onClick: handleCloseModal, children: t("reset.goBack") }),
+                /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Button, { color: "blue", onClick: handleKeepFiles, children: t("reset.keepFiles") }),
+                /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Button, { color: "red", onClick: handleConfirmReset, children: t("reset.burnEverything") })
+              ] })
+            ] })
+          }
+        )
+      }
+    )
+  ] });
+};
+var ResetSettings_default = ResetSettings;
+
+// src/components/Apps/SettingsApp/SettingsApp.module.css
+var SettingsApp_default = {};
+
+// src/constants/profileData.ts
+var PROFILE = {
+  name: "Francisco N\xFA\xF1ez Palomares",
+  title: "Fullstack Developer & DevOps",
+  email: "frannunpal@gmail.com",
+  phone: "+34 600 275 210",
+  location: "Spain",
+  linkedin: "https://www.linkedin.com/in/francisco-n\xFA\xF1ez-palomares-74a484171/",
+  github: "https://github.com/frannunpal",
+  cvUrls: {
+    en: "Desktop/CV_2026_English.pdf",
+    es: "Desktop/CV 2026.pdf"
+  }
+};
+var APP_VERSION = "0.4.0";
+var getVersionString = () => APP_VERSION;
+var SECTION_COMPONENTS = {
+  wallpaper: WallpaperSettings_default,
+  appearance: AppearanceSettings_default,
+  launcher: LauncherSettings_default,
+  font: FontSettings_default,
+  language: LanguageSettings_default,
+  reset: ResetSettings_default
+};
+var SettingsApp = ({ window: window2, notifyReady }) => {
+  const { t } = reactI18next.useTranslation("settings");
+  const [activeSectionId, setActiveSectionId] = React5.useState(null);
+  const [isDirty, setIsDirty] = React5.useState(false);
+  const windows = chunk6QOUYSEE_cjs.useDesktopStore((state) => state.windows);
+  const windowId = window2?.id ?? windows.find((w) => w.content === "settings")?.id;
+  const wallpaper = useSettingsStore((state) => state.wallpaper);
+  const wallpaperModule = useSettingsStore((state) => state.wallpaperModule);
+  const theme = useSettingsStore((state) => state.theme);
+  const font = useSettingsStore((state) => state.font);
+  const fontSize = useSettingsStore((state) => state.fontSize);
+  const launcherIcon = useSettingsStore((state) => state.launcherIcon);
+  const customThemeColors = useSettingsStore((state) => state.customThemeColors);
+  const animationDuration = useSettingsStore((state) => state.animationDuration);
+  const setWallpaper = useSettingsStore((state) => state.setWallpaper);
+  const setWallpaperModule = useSettingsStore((state) => state.setWallpaperModule);
+  const setFont = useSettingsStore((state) => state.setFont);
+  const setFontSize = useSettingsStore((state) => state.setFontSize);
+  const setLauncherIcon = useSettingsStore((state) => state.setLauncherIcon);
+  const setThemeMode = useSettingsStore((state) => state.setThemeMode);
+  const setCustomThemeColors = useSettingsStore((state) => state.setCustomThemeColors);
+  const setThemeAutomatic = useSettingsStore((state) => state.setThemeAutomatic);
+  const setAnimationDuration = useSettingsStore((state) => state.setAnimationDuration);
+  const snapshotRef = React5.useRef(null);
+  React5.useEffect(() => {
+    if (snapshotRef.current !== null) return;
+    snapshotRef.current = {
+      wallpaper,
+      wallpaperModule,
+      themeMode: theme.mode,
+      font,
+      fontSize,
+      launcherIcon,
+      customThemeColors,
+      animationDuration
+    };
+  }, [
+    wallpaper,
+    wallpaperModule,
+    theme.mode,
+    font,
+    fontSize,
+    launcherIcon,
+    customThemeColors,
+    animationDuration
+  ]);
+  React5.useEffect(() => {
+    if (!snapshotRef.current) return;
+    const current = {
+      wallpaper,
+      wallpaperModule,
+      themeMode: theme.mode,
+      font,
+      fontSize,
+      launcherIcon,
+      customThemeColors,
+      animationDuration
+    };
+    const dirty = JSON.stringify(current) !== JSON.stringify(snapshotRef.current);
+    setIsDirty(dirty);
+  }, [
+    wallpaper,
+    wallpaperModule,
+    theme.mode,
+    font,
+    fontSize,
+    launcherIcon,
+    customThemeColors,
+    animationDuration
+  ]);
+  const revertToSnapshot = React5.useCallback(() => {
+    const snapshot = snapshotRef.current;
+    if (!snapshot) return;
+    setWallpaper(snapshot.wallpaper);
+    setWallpaperModule(snapshot.wallpaperModule);
+    setFont(snapshot.font);
+    setFontSize(snapshot.fontSize);
+    setLauncherIcon(snapshot.launcherIcon);
+    setAnimationDuration(snapshot.animationDuration);
+    if (snapshot.customThemeColors) {
+      setCustomThemeColors(snapshot.customThemeColors);
+    } else {
+      setCustomThemeColors(null);
+      setThemeAutomatic();
+    }
+    setThemeMode(snapshot.themeMode);
+    setIsDirty(false);
+  }, [
+    setWallpaper,
+    setWallpaperModule,
+    setFont,
+    setFontSize,
+    setLauncherIcon,
+    setAnimationDuration,
+    setThemeMode,
+    setCustomThemeColors,
+    setThemeAutomatic
+  ]);
+  React5.useEffect(() => {
+    if (!windowId) return;
+    chunkYP2PLNOF_cjs.useSettingsAppStore.getState().reset(windowId);
+  }, [windowId]);
+  React5.useEffect(() => {
+    if (!windowId) return;
+    chunkYP2PLNOF_cjs.useSettingsAppStore.getState().setIsDirty(windowId, isDirty);
+  }, [windowId, isDirty]);
+  React5.useEffect(() => {
+    notifyReady?.({
+      ...window2?.contentData ?? {},
+      discard: revertToSnapshot
+    });
+  }, [window2, notifyReady, revertToSnapshot]);
+  const isDirtyGetter = React5.useCallback(() => {
+    if (!snapshotRef.current) return false;
+    const current = {
+      wallpaper: useSettingsStore.getState().wallpaper,
+      wallpaperModule: useSettingsStore.getState().wallpaperModule,
+      themeMode: useSettingsStore.getState().theme.mode,
+      font: useSettingsStore.getState().font,
+      fontSize: useSettingsStore.getState().fontSize,
+      launcherIcon: useSettingsStore.getState().launcherIcon,
+      customThemeColors: useSettingsStore.getState().customThemeColors,
+      animationDuration: useSettingsStore.getState().animationDuration
+    };
+    return JSON.stringify(current) !== JSON.stringify(snapshotRef.current);
+  }, []);
+  chunkZBGWYTCU_cjs.useCloseInterceptor({
+    isDirtyGetter,
+    windowId,
+    onDiscard: revertToSnapshot,
+    onSave: () => {
+    }
+  });
+  const handleSelectSection = React5.useCallback((id) => {
+    setActiveSectionId(id);
+  }, []);
+  const handleShowAll = React5.useCallback(() => {
+    setActiveSectionId(null);
+  }, []);
+  const handleContactMe = React5.useCallback(() => {
+    globalThis.location.href = `mailto:${PROFILE.email}`;
+  }, []);
+  const ActiveSection = activeSectionId ? SECTION_COMPONENTS[activeSectionId] : null;
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: SettingsApp_default.root, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("aside", { className: SettingsApp_default.sidebar, children: /* @__PURE__ */ jsxRuntime.jsxs("nav", { "aria-label": "Settings sections", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          className: SettingsApp_default.navItem,
+          "data-active": activeSectionId === null || void 0,
+          onClick: handleShowAll,
+          "aria-label": "All Settings",
+          "aria-current": activeSectionId === null ? "page" : void 0,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(chunkJ7L2S2GT_cjs.AppIcon_default, { fcIcon: "FcList", size: 16 }),
+            /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "xs", ml: 6, truncate: true, children: t("all") })
+          ]
+        }
+      ),
+      SETTINGS_SECTIONS.map((section) => /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          className: SettingsApp_default.navItem,
+          "data-active": activeSectionId === section.id || void 0,
+          onClick: () => handleSelectSection(section.id),
+          "aria-label": section.label,
+          "aria-current": activeSectionId === section.id ? "page" : void 0,
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(chunkJ7L2S2GT_cjs.AppIcon_default, { fcIcon: section.fcIcon, size: 16 }),
+            /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "xs", ml: 6, truncate: true, children: t(`sections.${section.id}.label`) })
+          ]
+        },
+        section.id
+      ))
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx("main", { className: SettingsApp_default.content, children: ActiveSection ? /* @__PURE__ */ jsxRuntime.jsx(ActiveSection, {}) : /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { className: SettingsApp_default.overviewPadding, h: "100%", justify: "space-between", gap: 0, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { fw: 500, mb: "md", size: "sm", c: "dimmed", children: t("all") }),
+        /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.SimpleGrid, { cols: 2, spacing: "sm", children: SETTINGS_SECTIONS.map((section) => /* @__PURE__ */ jsxRuntime.jsx(
+          chunkE55VXNLK_cjs.Card,
+          {
+            withBorder: true,
+            padding: "md",
+            radius: "md",
+            className: SettingsApp_default.sectionCard,
+            onClick: () => handleSelectSection(section.id),
+            role: "button",
+            "aria-label": `Open ${section.label} settings`,
+            children: /* @__PURE__ */ jsxRuntime.jsxs(chunkE55VXNLK_cjs.Stack, { gap: 6, align: "flex-start", children: [
+              /* @__PURE__ */ jsxRuntime.jsx(chunkJ7L2S2GT_cjs.AppIcon_default, { fcIcon: section.fcIcon, size: 28 }),
+              /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "sm", fw: 500, children: t(`sections.${section.id}.label`) }),
+              /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "xs", c: "dimmed", children: t(`sections.${section.id}.description`) })
+            ] })
+          },
+          section.id
+        )) })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Button, { gradient: { from: "blue", to: "cyan", deg: 90 }, onClick: handleContactMe, children: "FDE: Fran Desktop Environment" }),
+      /* @__PURE__ */ jsxRuntime.jsx(chunkE55VXNLK_cjs.Text, { size: "xs", c: "dimmed", ta: "center", className: SettingsApp_default.versionFooter, children: getVersionString() })
+    ] }) })
+  ] });
+};
+var SettingsApp_default2 = SettingsApp;
+
+exports.AVAILABLE_FONTS = AVAILABLE_FONTS;
+exports.DEFAULT_LANGUAGE = DEFAULT_LANGUAGE2;
+exports.DefaultThemeProvider = DefaultThemeProvider;
+exports.FONT_STACKS = FONT_STACKS;
+exports.GOOGLE_FONTS_HREF = GOOGLE_FONTS_HREF;
+exports.LanguageFlag_default = LanguageFlag_default2;
+exports.PROFILE = PROFILE;
+exports.SETTINGS_SECTIONS = SETTINGS_SECTIONS;
+exports.SUPPORTED_LANGUAGES = SUPPORTED_LANGUAGES2;
+exports.SettingsApp_default = SettingsApp_default2;
+exports.SettingsSection_default = SettingsSection_default;
+exports.clearBrowserData = clearBrowserData;
+exports.getPersistedThemeMode = getPersistedThemeMode;
+exports.injectFontLink = injectFontLink;
+exports.useFontDownload = useFontDownload;
+exports.useSettingsStore = useSettingsStore;