@edrlab/thorium-web 1.3.1 → 1.4.1

package/dist/chunk-OD75GC5N.mjs

@@ -0,0 +1,3953 @@
+import { propsToCSSVars } from './chunk-2YRT7RNW.mjs';
+import { useBreakpoints, useForcedColors, useMonochrome, useReducedMotion, useReducedTransparency } from './chunk-GFSLVQIG.mjs';
+import { ThGlobalPreferencesContext } from './chunk-AE6P4KJB.mjs';
+import { useAppSelector } from './chunk-A575ZW4A.mjs';
+import { useColorScheme, useContrast } from './chunk-NQ2ZSGCX.mjs';
+import { isSupportedLocale, supportedLocales } from './chunk-GNROODJB.mjs';
+import { createContext, useMemo, useState, useCallback, useEffect, useContext, useRef } from 'react';
+import { I18nProvider, useLocale } from 'react-aria';
+import { jsx } from 'react/jsx-runtime';
+import fontStacks from '@readium/css/css/vars/fontStacks.json';
+import ReadiumCSSColors from '@readium/css/css/vars/colors.json';
+
+// src/preferences/globalPreferences.ts
+var createGlobalPreferences = (params) => {
+  if (params.locale) {
+    const languageCode = params.locale.split("-")[0];
+    if (!isSupportedLocale(languageCode)) {
+      console.warn(`Locale "${params.locale}" is not supported. Supported locales: ${supportedLocales.join(", ")}. Falling back to browser/OS language settings.`);
+      return { ...params, locale: void 0 };
+    }
+  }
+  return params;
+};
+
+// src/preferences/adapters/ThGlobalMemoryPreferencesAdapter.ts
+var ThGlobalMemoryPreferencesAdapter = class {
+  preferences;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(initialPreferences = {}) {
+    this.preferences = { ...initialPreferences };
+  }
+  getPreferences() {
+    return { ...this.preferences };
+  }
+  setPreferences(prefs) {
+    this.preferences = { ...prefs };
+    this.listeners.forEach((cb) => cb({ ...this.preferences }));
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    callback(this.getPreferences());
+  }
+  unsubscribe(callback) {
+    this.listeners.delete(callback);
+  }
+};
+var ThDirectionSetter = ({ children }) => {
+  const { direction } = useLocale();
+  useEffect(() => {
+    document.documentElement.dir = direction;
+  }, [direction]);
+  return children;
+};
+function ThGlobalPreferencesProvider({ adapter, initialPreferences, children }) {
+  const effectiveAdapter = useMemo(
+    () => adapter || new ThGlobalMemoryPreferencesAdapter(initialPreferences),
+    [adapter, initialPreferences]
+  );
+  const [preferences, setPreferences] = useState(
+    () => createGlobalPreferences(initialPreferences ?? {})
+  );
+  const handlePreferenceChange = useCallback((newPrefs) => {
+    setPreferences((prev) => {
+      const validated = createGlobalPreferences(newPrefs);
+      return JSON.stringify(prev) === JSON.stringify(validated) ? prev : validated;
+    });
+  }, []);
+  useEffect(() => {
+    effectiveAdapter.subscribe(handlePreferenceChange);
+    return () => effectiveAdapter.unsubscribe(handlePreferenceChange);
+  }, [effectiveAdapter, handlePreferenceChange]);
+  const contextValue = useMemo(() => ({
+    preferences,
+    updatePreferences: (newPrefs) => {
+      effectiveAdapter.setPreferences(newPrefs);
+    }
+  }), [preferences, effectiveAdapter]);
+  return /* @__PURE__ */ jsx(ThGlobalPreferencesContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(I18nProvider, { locale: preferences.locale, children: /* @__PURE__ */ jsx(ThDirectionSetter, { children }) }) });
+}
+
+// src/preferences/models/actions.ts
+var ThActionsKeys = /* @__PURE__ */ ((ThActionsKeys3) => {
+  ThActionsKeys3["fullscreen"] = "fullscreen";
+  ThActionsKeys3["jumpToPosition"] = "jumpToPosition";
+  ThActionsKeys3["settings"] = "settings";
+  ThActionsKeys3["toc"] = "toc";
+  return ThActionsKeys3;
+})(ThActionsKeys || {});
+var ThDockingKeys = /* @__PURE__ */ ((ThDockingKeys3) => {
+  ThDockingKeys3["start"] = "dockingStart";
+  ThDockingKeys3["end"] = "dockingEnd";
+  ThDockingKeys3["transient"] = "dockingTransient";
+  return ThDockingKeys3;
+})(ThDockingKeys || {});
+var ThDockingTypes = /* @__PURE__ */ ((ThDockingTypes2) => {
+  ThDockingTypes2["none"] = "none";
+  ThDockingTypes2["both"] = "both";
+  ThDockingTypes2["start"] = "start";
+  ThDockingTypes2["end"] = "end";
+  return ThDockingTypes2;
+})(ThDockingTypes || {});
+var ThSheetTypes = /* @__PURE__ */ ((ThSheetTypes3) => {
+  ThSheetTypes3["popover"] = "popover";
+  ThSheetTypes3["compactPopover"] = "compactPopover";
+  ThSheetTypes3["modal"] = "modal";
+  ThSheetTypes3["fullscreen"] = "fullscreen";
+  ThSheetTypes3["dockedStart"] = "docked start";
+  ThSheetTypes3["dockedEnd"] = "docked end";
+  ThSheetTypes3["bottomSheet"] = "bottomSheet";
+  return ThSheetTypes3;
+})(ThSheetTypes || {});
+var ThSheetHeaderVariant = /* @__PURE__ */ ((ThSheetHeaderVariant2) => {
+  ThSheetHeaderVariant2["close"] = "close";
+  ThSheetHeaderVariant2["previous"] = "previous";
+  return ThSheetHeaderVariant2;
+})(ThSheetHeaderVariant || {});
+var defaultActionKeysObject = {
+  visibility: "partially" /* partially */,
+  shortcut: null
+};
+var defaultSettingsAction = {
+  visibility: "partially" /* partially */,
+  shortcut: null,
+  // `${ UnstableShortcutMetaKeywords.shift }+${ ShortcutMetaKeywords.alt }+P`,
+  sheet: {
+    defaultSheet: "popover" /* popover */,
+    breakpoints: {
+      ["compact" /* compact */]: "bottomSheet" /* bottomSheet */
+    }
+  },
+  docked: {
+    dockable: "none" /* none */,
+    width: 340
+  },
+  snapped: {
+    scrim: true,
+    peekHeight: 50,
+    minHeight: 30,
+    maxHeight: 100
+  }
+};
+var defaultFullscreenAction = {
+  visibility: "partially" /* partially */,
+  shortcut: null
+};
+var defaultTocAction = {
+  visibility: "partially" /* partially */,
+  shortcut: null,
+  // `${ UnstableShortcutMetaKeywords.shift }+${ ShortcutMetaKeywords.alt }+T`,
+  sheet: {
+    defaultSheet: "popover" /* popover */,
+    breakpoints: {
+      ["compact" /* compact */]: "fullscreen" /* fullscreen */,
+      ["medium" /* medium */]: "fullscreen" /* fullscreen */
+    }
+  },
+  docked: {
+    dockable: "both" /* both */,
+    dragIndicator: false,
+    width: 360,
+    minWidth: 320,
+    maxWidth: 450
+  }
+};
+var defaultJumpToPositionAction = {
+  visibility: "overflow" /* overflow */,
+  shortcut: null,
+  // `${ UnstableShortcutMetaKeywords.shift }+${ ShortcutMetaKeywords.alt }+J`,
+  sheet: {
+    defaultSheet: "popover" /* popover */,
+    breakpoints: {
+      ["compact" /* compact */]: "bottomSheet" /* bottomSheet */
+    }
+  },
+  docked: {
+    dockable: "none" /* none */
+  },
+  snapped: {
+    scrim: true,
+    minHeight: "content-height"
+  }
+};
+
+// src/preferences/models/settings.ts
+var ThSettingsKeys = /* @__PURE__ */ ((ThSettingsKeys2) => {
+  ThSettingsKeys2["columns"] = "columns";
+  ThSettingsKeys2["fontFamily"] = "fontFamily";
+  ThSettingsKeys2["fontWeight"] = "fontWeight";
+  ThSettingsKeys2["hyphens"] = "hyphens";
+  ThSettingsKeys2["layout"] = "layout";
+  ThSettingsKeys2["letterSpacing"] = "letterSpacing";
+  ThSettingsKeys2["ligatures"] = "ligatures";
+  ThSettingsKeys2["lineHeight"] = "lineHeight";
+  ThSettingsKeys2["noRuby"] = "noRuby";
+  ThSettingsKeys2["paragraphIndent"] = "paragraphIndent";
+  ThSettingsKeys2["paragraphSpacing"] = "paragraphSpacing";
+  ThSettingsKeys2["publisherStyles"] = "publisherStyles";
+  ThSettingsKeys2["spacingGroup"] = "spacingGroup";
+  ThSettingsKeys2["spacingPresets"] = "spacingPresets";
+  ThSettingsKeys2["textAlign"] = "textAlign";
+  ThSettingsKeys2["textGroup"] = "textGroup";
+  ThSettingsKeys2["textNormalize"] = "textNormalize";
+  ThSettingsKeys2["theme"] = "theme";
+  ThSettingsKeys2["wordSpacing"] = "wordSpacing";
+  ThSettingsKeys2["zoom"] = "zoom";
+  return ThSettingsKeys2;
+})(ThSettingsKeys || {});
+var ThTextSettingsKeys = /* @__PURE__ */ ((ThTextSettingsKeys3) => {
+  ThTextSettingsKeys3["fontFamily"] = "fontFamily";
+  ThTextSettingsKeys3["fontWeight"] = "fontWeight";
+  ThTextSettingsKeys3["hyphens"] = "hyphens";
+  ThTextSettingsKeys3["ligatures"] = "ligatures";
+  ThTextSettingsKeys3["noRuby"] = "noRuby";
+  ThTextSettingsKeys3["textAlign"] = "textAlign";
+  ThTextSettingsKeys3["textNormalize"] = "textNormalize";
+  return ThTextSettingsKeys3;
+})(ThTextSettingsKeys || {});
+var ThSpacingSettingsKeys = /* @__PURE__ */ ((ThSpacingSettingsKeys3) => {
+  ThSpacingSettingsKeys3["letterSpacing"] = "letterSpacing";
+  ThSpacingSettingsKeys3["lineHeight"] = "lineHeight";
+  ThSpacingSettingsKeys3["paragraphIndent"] = "paragraphIndent";
+  ThSpacingSettingsKeys3["paragraphSpacing"] = "paragraphSpacing";
+  ThSpacingSettingsKeys3["publisherStyles"] = "publisherStyles";
+  ThSpacingSettingsKeys3["spacingPresets"] = "spacingPresets";
+  ThSpacingSettingsKeys3["wordSpacing"] = "wordSpacing";
+  return ThSpacingSettingsKeys3;
+})(ThSpacingSettingsKeys || {});
+var ThSettingsContainerKeys = /* @__PURE__ */ ((ThSettingsContainerKeys2) => {
+  ThSettingsContainerKeys2["initial"] = "initial";
+  ThSettingsContainerKeys2["text"] = "text";
+  ThSettingsContainerKeys2["spacing"] = "spacing";
+  return ThSettingsContainerKeys2;
+})(ThSettingsContainerKeys || {});
+var ThSettingsRangeVariant = /* @__PURE__ */ ((ThSettingsRangeVariant2) => {
+  ThSettingsRangeVariant2["slider"] = "slider";
+  ThSettingsRangeVariant2["incrementedSlider"] = "incrementedSlider";
+  ThSettingsRangeVariant2["numberField"] = "numberField";
+  ThSettingsRangeVariant2["sliderWithPresets"] = "sliderWithPresets";
+  ThSettingsRangeVariant2["presetsGroup"] = "presetsGroup";
+  return ThSettingsRangeVariant2;
+})(ThSettingsRangeVariant || {});
+var ThSettingsRangePlaceholder = /* @__PURE__ */ ((ThSettingsRangePlaceholder2) => {
+  ThSettingsRangePlaceholder2["range"] = "range";
+  ThSettingsRangePlaceholder2["none"] = "none";
+  return ThSettingsRangePlaceholder2;
+})(ThSettingsRangePlaceholder || {});
+var ThSpacingPresetKeys = /* @__PURE__ */ ((ThSpacingPresetKeys4) => {
+  ThSpacingPresetKeys4["publisher"] = "publisher";
+  ThSpacingPresetKeys4["tight"] = "tight";
+  ThSpacingPresetKeys4["balanced"] = "balanced";
+  ThSpacingPresetKeys4["loose"] = "loose";
+  ThSpacingPresetKeys4["accessible"] = "accessible";
+  ThSpacingPresetKeys4["custom"] = "custom";
+  return ThSpacingPresetKeys4;
+})(ThSpacingPresetKeys || {});
+var ThLayoutOptions = /* @__PURE__ */ ((ThLayoutOptions2) => {
+  ThLayoutOptions2["scroll"] = "scroll_option";
+  ThLayoutOptions2["paginated"] = "page_option";
+  return ThLayoutOptions2;
+})(ThLayoutOptions || {});
+var ThTextAlignOptions = /* @__PURE__ */ ((ThTextAlignOptions2) => {
+  ThTextAlignOptions2["publisher"] = "publisher";
+  ThTextAlignOptions2["start"] = "start";
+  ThTextAlignOptions2["justify"] = "justify";
+  return ThTextAlignOptions2;
+})(ThTextAlignOptions || {});
+var ThLineHeightOptions = /* @__PURE__ */ ((ThLineHeightOptions3) => {
+  ThLineHeightOptions3["publisher"] = "publisher";
+  ThLineHeightOptions3["small"] = "small";
+  ThLineHeightOptions3["medium"] = "medium";
+  ThLineHeightOptions3["large"] = "large";
+  return ThLineHeightOptions3;
+})(ThLineHeightOptions || {});
+var defaultTextSettingsMain = ["fontFamily" /* fontFamily */];
+var defaultTextSettingsSubpanel = [
+  "fontFamily" /* fontFamily */,
+  "textAlign" /* textAlign */,
+  "hyphens" /* hyphens */,
+  "fontWeight" /* fontWeight */,
+  "textNormalize" /* textNormalize */,
+  "ligatures" /* ligatures */,
+  "noRuby" /* noRuby */
+];
+var defaultSpacingSettingsMain = [
+  "spacingPresets" /* spacingPresets */
+];
+var defaultSpacingSettingsSubpanel = [
+  "spacingPresets" /* spacingPresets */,
+  "lineHeight" /* lineHeight */,
+  "paragraphSpacing" /* paragraphSpacing */,
+  "paragraphIndent" /* paragraphIndent */,
+  "wordSpacing" /* wordSpacing */,
+  "letterSpacing" /* letterSpacing */
+];
+var defaultSpacingPresetsOrder = [
+  "publisher" /* publisher */,
+  "accessible" /* accessible */,
+  "custom" /* custom */,
+  "tight" /* tight */,
+  "balanced" /* balanced */,
+  "loose" /* loose */
+];
+var defaultParagraphSpacing = {
+  variant: "numberField" /* numberField */,
+  placeholder: "range" /* range */,
+  range: [0, 3],
+  step: 0.25
+};
+var defaultParagraphIndent = {
+  variant: "numberField" /* numberField */,
+  placeholder: "range" /* range */,
+  range: [0, 2],
+  step: 0.25
+};
+var defaultWordSpacing = {
+  variant: "numberField" /* numberField */,
+  placeholder: "range" /* range */,
+  range: [0, 1],
+  step: 0.1
+};
+var defaultLetterSpacing = {
+  variant: "numberField" /* numberField */,
+  placeholder: "range" /* range */,
+  range: [0, 0.5],
+  step: 0.05
+};
+var defaultLineHeights = {
+  ["small" /* small */]: 1.35,
+  ["medium" /* medium */]: 1.5,
+  ["large" /* large */]: 1.75
+};
+var defaultZoom = {
+  variant: "numberField" /* numberField */,
+  placeholder: "range" /* range */,
+  range: [0.7, 4],
+  step: 0.05
+};
+var defaultSpacingPresets = {
+  ["tight" /* tight */]: {
+    ["lineHeight" /* lineHeight */]: "small" /* small */,
+    ["paragraphSpacing" /* paragraphSpacing */]: 0.25,
+    ["paragraphIndent" /* paragraphIndent */]: 1
+  },
+  ["balanced" /* balanced */]: {
+    ["lineHeight" /* lineHeight */]: "medium" /* medium */,
+    ["paragraphSpacing" /* paragraphSpacing */]: 1,
+    ["paragraphIndent" /* paragraphIndent */]: 1
+  },
+  ["loose" /* loose */]: {
+    ["lineHeight" /* lineHeight */]: "large" /* large */,
+    ["paragraphSpacing" /* paragraphSpacing */]: 1.5,
+    ["paragraphIndent" /* paragraphIndent */]: 1
+  },
+  ["accessible" /* accessible */]: {
+    ["lineHeight" /* lineHeight */]: "large" /* large */,
+    ["paragraphSpacing" /* paragraphSpacing */]: 2.5,
+    ["paragraphIndent" /* paragraphIndent */]: 1,
+    ["letterSpacing" /* letterSpacing */]: 0.1,
+    ["wordSpacing" /* wordSpacing */]: 0.3
+  }
+};
+
+// src/preferences/models/audio.ts
+var ThAudioActionKeys = /* @__PURE__ */ ((ThAudioActionKeys2) => {
+  ThAudioActionKeys2["toc"] = "audio.toc";
+  ThAudioActionKeys2["volume"] = "audio.volume";
+  ThAudioActionKeys2["playbackRate"] = "audio.playbackRate";
+  ThAudioActionKeys2["sleepTimer"] = "audio.sleepTimer";
+  ThAudioActionKeys2["remotePlayback"] = "audio.remotePlayback";
+  return ThAudioActionKeys2;
+})(ThAudioActionKeys || {});
+var ThAudioKeys = /* @__PURE__ */ ((ThAudioKeys2) => {
+  ThAudioKeys2["theme"] = "theme";
+  ThAudioKeys2["volume"] = "volume";
+  ThAudioKeys2["playbackRate"] = "playbackRate";
+  ThAudioKeys2["skipBackwardInterval"] = "skipBackwardInterval";
+  ThAudioKeys2["skipForwardInterval"] = "skipForwardInterval";
+  ThAudioKeys2["skipInterval"] = "skipInterval";
+  ThAudioKeys2["autoPlay"] = "autoPlay";
+  ThAudioKeys2["sleepTimer"] = "sleepTimer";
+  return ThAudioKeys2;
+})(ThAudioKeys || {});
+var ThSettingsTimerVariant = /* @__PURE__ */ ((ThSettingsTimerVariant2) => {
+  ThSettingsTimerVariant2["presetList"] = "presetList";
+  ThSettingsTimerVariant2["durationField"] = "durationField";
+  return ThSettingsTimerVariant2;
+})(ThSettingsTimerVariant || {});
+var defaultAudioVolume = {
+  variant: "slider" /* slider */,
+  range: [0, 1],
+  step: 0.1,
+  placeholder: "range" /* range */
+};
+var defaultAudioPlaybackRate = {
+  variant: "sliderWithPresets" /* sliderWithPresets */,
+  range: [0.5, 4],
+  step: 0.05,
+  placeholder: "range" /* range */,
+  presets: [0.75, 1, 1.25, 1.5, 1.75, 2]
+};
+var defaultAudioSkipBackwardInterval = {
+  variant: "presetsGroup" /* presetsGroup */,
+  range: [5, 60],
+  step: 5,
+  placeholder: "range" /* range */,
+  presets: [5, 10, 30]
+};
+var defaultAudioSkipForwardInterval = {
+  variant: "presetsGroup" /* presetsGroup */,
+  range: [5, 60],
+  step: 5,
+  placeholder: "range" /* range */,
+  presets: [5, 10, 30]
+};
+var defaultAudioSkipInterval = {
+  variant: "presetsGroup" /* presetsGroup */,
+  range: [5, 60],
+  step: 5,
+  placeholder: "range" /* range */,
+  presets: [5, 10, 30]
+};
+var defaultAudioSleepTimer = {
+  variant: "durationField" /* durationField */,
+  maxHours: 23
+};
+var defaultAudioSleepTimerPresetList = {
+  variant: "presetList" /* presetList */,
+  presets: [15, 30, 45, 60, 90, "endOfFragment", "endOfResource"]
+};
+var defaultAudioVolumeAction = {
+  visibility: "always" /* always */,
+  shortcut: null,
+  sheet: {
+    defaultSheet: "compactPopover" /* compactPopover */,
+    breakpoints: {}
+  },
+  docked: { dockable: "none" /* none */ }
+};
+var defaultAudioPlaybackRateAction = {
+  visibility: "always" /* always */,
+  shortcut: null,
+  sheet: {
+    defaultSheet: "compactPopover" /* compactPopover */,
+    breakpoints: { ["compact" /* compact */]: "bottomSheet" /* bottomSheet */ }
+  },
+  snapped: {
+    minHeight: "content-height"
+  },
+  docked: { dockable: "none" /* none */ }
+};
+var defaultAudioSleepTimerAction = {
+  visibility: "partially" /* partially */,
+  shortcut: null,
+  sheet: {
+    defaultSheet: "modal" /* modal */,
+    breakpoints: {
+      ["compact" /* compact */]: "bottomSheet" /* bottomSheet */,
+      ["medium" /* medium */]: "bottomSheet" /* bottomSheet */
+    }
+  },
+  snapped: {
+    minHeight: "content-height"
+  },
+  docked: { dockable: "none" /* none */ }
+};
+var defaultAudioRemotePlaybackAction = {
+  visibility: "always" /* always */,
+  shortcut: null
+};
+var defaultAudioTocAction = {
+  visibility: "partially" /* partially */,
+  shortcut: null,
+  sheet: {
+    defaultSheet: "modal" /* modal */,
+    breakpoints: {
+      ["compact" /* compact */]: "fullscreen" /* fullscreen */,
+      ["medium" /* medium */]: "fullscreen" /* fullscreen */
+    }
+  },
+  docked: {
+    dockable: "both" /* both */,
+    dragIndicator: false,
+    width: 360,
+    minWidth: 320,
+    maxWidth: 450
+  }
+};
+
+// src/preferences/helpers/buildThemeObject.ts
+var buildThemeObject = ({
+  theme,
+  themeKeys,
+  systemThemes,
+  colorScheme
+}) => {
+  if (!theme) {
+    return {};
+  }
+  if (theme === "auto" && colorScheme && systemThemes) {
+    theme = colorScheme === "dark" /* dark */ ? systemThemes.dark : systemThemes.light;
+  }
+  let themeProps = {};
+  const themeToken = themeKeys[theme];
+  if (themeToken) {
+    themeProps = {
+      backgroundColor: themeToken.background,
+      textColor: themeToken.text,
+      linkColor: themeToken.link,
+      selectionBackgroundColor: themeToken.select,
+      selectionTextColor: themeToken.onSelect,
+      visitedColor: themeToken.visited
+    };
+  } else {
+    console.warn(`Theme key "${String(theme)}" not found in themeKeys.`);
+    themeProps = {
+      backgroundColor: null,
+      textColor: null,
+      linkColor: null,
+      selectionBackgroundColor: null,
+      selectionTextColor: null,
+      visitedColor: null
+    };
+  }
+  return themeProps;
+};
+
+// src/preferences/helpers/fontPref/bunnyFonts.ts
+var DEFAULT_FALLBACK = "sans-serif";
+var createDefinitionsFromBunnyFonts = (params) => {
+  const { cssUrl, options } = params;
+  const { fallbacks, order, labels } = options || {};
+  const processedUrl = cssUrl.includes("@import") ? cssUrl.match(/@import\s+url\(['"]?([^'")]+)['"]?\)/i)?.[1] || cssUrl : cssUrl.includes("href=") ? cssUrl.match(/href=["']([^"']+)["']/)?.[1] || cssUrl : cssUrl;
+  const url = new URL(processedUrl);
+  if (!url.hostname.includes("fonts.bunny.net")) {
+    throw new Error("Invalid Bunny Fonts URL");
+  }
+  const familyParam = url.searchParams.get("family");
+  if (!familyParam) {
+    throw new Error("No family parameter found in Bunny Fonts URL");
+  }
+  const fontEntries = familyParam.split("|").map((familyStr) => {
+    const [familyName, weightsStr = ""] = familyStr.split(":");
+    if (!familyName) {
+      throw new Error(`Invalid font family format: ${familyStr}`);
+    }
+    const weightStyles = /* @__PURE__ */ new Map();
+    if (weightsStr) {
+      weightsStr.split(",").forEach((weightStr) => {
+        const isItalic = weightStr.endsWith("i");
+        const weightValue = parseInt(isItalic ? weightStr.slice(0, -1) : weightStr, 10);
+        if (!isNaN(weightValue)) {
+          if (!weightStyles.has(weightValue)) {
+            weightStyles.set(weightValue, /* @__PURE__ */ new Set());
+          }
+          weightStyles.get(weightValue)?.add(isItalic ? "italic" : "normal");
+        }
+      });
+    }
+    const weights = Array.from(weightStyles.keys()).sort((a, b) => a - b);
+    const hasItalic = Array.from(weightStyles.values()).some((styles2) => styles2.has("italic"));
+    const styles = hasItalic ? ["normal", "italic"] : ["normal"];
+    const fontId = familyName;
+    const familyDisplayName = familyName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+    return [
+      fontId,
+      {
+        id: fontId,
+        name: familyDisplayName,
+        ...labels?.[fontId] && { label: labels[fontId] },
+        source: {
+          type: "custom",
+          provider: "bunny"
+        },
+        spec: {
+          family: familyDisplayName,
+          fallbacks: fallbacks?.[fontId] || [DEFAULT_FALLBACK],
+          weights: {
+            type: "static",
+            values: weights.length ? weights : [400]
+          },
+          styles
+        }
+      }
+    ];
+  });
+  const result = Object.fromEntries(fontEntries);
+  if (order && order.length > 0) {
+    const orderedResult = {};
+    order.forEach((fontId) => {
+      if (result[fontId]) {
+        orderedResult[fontId] = result[fontId];
+      }
+    });
+    Object.entries(result).forEach(([fontId, definition]) => {
+      if (!orderedResult[fontId]) {
+        orderedResult[fontId] = definition;
+      }
+    });
+    return orderedResult;
+  }
+  return result;
+};
+
+// src/preferences/helpers/fontPref/googleFonts.ts
+var DEFAULT_FALLBACK2 = "sans-serif";
+var DEFAULT_WIDTH_STEP = 20;
+var DEFAULT_WEIGHT_STEP = 20;
+var createDefinitionsFromGoogleFonts = (params) => {
+  const { cssUrl, options } = params;
+  const { widthStep = DEFAULT_WIDTH_STEP, weightStep = DEFAULT_WEIGHT_STEP, display, labels, fallbacks, order } = options || {};
+  const processedUrl = cssUrl.includes("@import") ? cssUrl.match(/@import\s+url\(['"]?([^'")]+)['"]?\)/i)?.[1] || cssUrl : cssUrl.includes("href=") ? cssUrl.match(/href=["']([^"']+)["']/)?.[1] || cssUrl : cssUrl;
+  const url = new URL(processedUrl);
+  if (!url.hostname.includes("fonts.googleapis.com")) {
+    throw new Error("Invalid Google Fonts URL");
+  }
+  const familyParams = url.searchParams.getAll("family");
+  if (familyParams.length === 0) {
+    throw new Error("No family parameter found in Google Fonts URL");
+  }
+  const families = familyParams.map((familyParam) => {
+    const decodedFamily = decodeURIComponent(familyParam);
+    const [familyName, axesStr] = decodedFamily.split(":");
+    if (!familyName) {
+      throw new Error(`Invalid family format: ${familyParam}`);
+    }
+    const family = {
+      name: familyName.replace(/\+/g, " "),
+      styles: ["normal"],
+      weights: { type: "static", values: [400] }
+      // Default weight
+    };
+    let hasExplicitWeights = false;
+    if (axesStr) {
+      const [axisNames, valuesStr] = axesStr.split("@");
+      if (axisNames && valuesStr) {
+        const axes = axisNames.split(",");
+        const variations = valuesStr.split(";");
+        variations.forEach((variation) => {
+          const values = variation.split(",");
+          axes.forEach((axis, index) => {
+            const value = values[index];
+            if (!value) return;
+            switch (axis) {
+              case "ital":
+                if (value === "1") {
+                  family.styles = Array.from(/* @__PURE__ */ new Set([...family.styles, "italic"]));
+                }
+                break;
+              case "wght":
+                if (value.includes("..")) {
+                  const [min, max] = value.split("..").map(Number);
+                  if (!isNaN(min) && !isNaN(max)) {
+                    family.weights = {
+                      type: "variable",
+                      min,
+                      max,
+                      step: weightStep
+                    };
+                  }
+                } else {
+                  const weight = Number(value);
+                  if (!isNaN(weight) && family.weights.type === "static") {
+                    const currentWeights = family.weights.values;
+                    const newWeights = !hasExplicitWeights ? [weight] : Array.from(/* @__PURE__ */ new Set([...currentWeights, weight])).sort((a, b) => a - b);
+                    family.weights = {
+                      type: "static",
+                      values: newWeights
+                    };
+                    hasExplicitWeights = true;
+                  }
+                }
+                break;
+              case "wdth":
+                if (value.includes("..")) {
+                  const [min, max] = value.split("..").map(Number);
+                  if (!isNaN(min) && !isNaN(max)) {
+                    family.widths = {
+                      min,
+                      max,
+                      step: widthStep
+                    };
+                  }
+                }
+                break;
+            }
+          });
+        });
+      }
+    }
+    return family;
+  });
+  const fontEntries = families.map((family) => {
+    const fontId = family.name.toLowerCase().replace(/\s+/g, "-");
+    return [
+      fontId,
+      {
+        id: fontId,
+        name: family.name,
+        ...labels?.[fontId] && { label: labels[fontId] },
+        source: { type: "custom", provider: "google" },
+        spec: {
+          family: family.name,
+          fallbacks: fallbacks?.[fontId] || [DEFAULT_FALLBACK2],
+          weights: family.weights,
+          styles: family.styles,
+          ...family.widths && { widths: family.widths },
+          ...display && { display }
+        }
+      }
+    ];
+  });
+  if (order && order.length > 0) {
+    const orderedEntries = [];
+    const fontMap = new Map(fontEntries);
+    for (const fontId of order) {
+      const fontEntry = fontMap.get(fontId);
+      if (fontEntry) {
+        orderedEntries.push([fontId, fontEntry]);
+        fontMap.delete(fontId);
+      }
+    }
+    for (const [fontId, fontEntry] of fontMap.entries()) {
+      orderedEntries.push([fontId, fontEntry]);
+    }
+    return Object.fromEntries(orderedEntries);
+  }
+  return Object.fromEntries(fontEntries);
+};
+
+// src/preferences/helpers/fontPref/localFonts.ts
+var createDefinitionFromStaticFonts = (params) => {
+  const { id, name, files, family, label, fallbacks = ["sans-serif"] } = params;
+  if (!files || files.length === 0) {
+    throw new Error("No files provided to infer font specification");
+  }
+  if (!files.every((file) => file.weight !== void 0)) {
+    throw new Error("All files must have explicit weights for static font specification inference");
+  }
+  const weights = Array.from(new Set(files.map((file) => file.weight))).sort((a, b) => a - b);
+  const styles = Array.from(new Set(files.map((file) => file.style)));
+  const source = {
+    type: "custom",
+    provider: "local",
+    variant: "static",
+    files
+  };
+  const spec = {
+    family: family || name,
+    fallbacks,
+    weights: {
+      type: "static",
+      values: weights
+    },
+    styles
+  };
+  return {
+    id,
+    name,
+    ...label && { label },
+    source,
+    spec
+  };
+};
+
+// src/preferences/helpers/validateObjectKeys.ts
+var validateObjectKeys = (orderArrays, keysObj, context, specialCase, fallback) => {
+  const allOrders = new Set(
+    orderArrays.flatMap((arr) => {
+      if (!specialCase) return arr;
+      return arr.filter((k) => {
+        if (Array.isArray(specialCase)) {
+          return !specialCase.includes(k);
+        } else {
+          return k !== specialCase;
+        }
+      });
+    })
+  );
+  const availableKeys = Object.keys(keysObj);
+  allOrders.forEach((key) => {
+    if (!availableKeys.includes(key)) {
+      if (fallback) keysObj[key] = fallback;
+      console.warn(
+        `Key "${key}" in ${context} order arrays not found in ${context}.keys.${fallback ? `
+Using fallback: ${JSON.stringify(fallback)}` : ""}`
+      );
+    }
+  });
+};
+
+// src/preferences/models/fonts.ts
+var readiumCSSFontCollection = {
+  oldStyle: {
+    id: "oldStyle",
+    name: "Old Style",
+    label: "reader.preferences.fontFamily.oldStyle.descriptive",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__oldStyleTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  },
+  modern: {
+    id: "modern",
+    name: "Modern",
+    label: "reader.preferences.fontFamily.modern.descriptive",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__modernTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  },
+  sans: {
+    id: "sans",
+    name: "Sans",
+    label: "reader.preferences.fontFamily.sans",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__sansTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  },
+  humanist: {
+    id: "humanist",
+    name: "Humanist",
+    label: "reader.preferences.fontFamily.humanist.descriptive",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__humanistTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  },
+  monospace: {
+    id: "monospace",
+    name: "Monospace",
+    label: "reader.preferences.fontFamily.monospace",
+    source: { type: "system" },
+    spec: {
+      family: fontStacks.RS__monospaceTf,
+      weights: { type: "static", values: [400, 700] },
+      fallbacks: []
+    }
+  }
+};
+var defaultFontCollection = {
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Atkinson+Hyperlegible+Next:ital,wght@0,200..800;1,200..800&family=Literata:ital,opsz,wght@0,7..72,200..900;1,7..72,200..900",
+    options: {
+      order: ["literata", "atkinson-hyperlegible-next"],
+      fallbacks: {
+        "literata": ["serif"],
+        "atkinson-hyperlegible-next": ["sans-serif"]
+      }
+    }
+  }),
+  luciole: createDefinitionFromStaticFonts({
+    id: "luciole",
+    name: "Luciole",
+    files: [
+      { path: "/fonts/Luciole/Luciole-Regular.woff2", weight: 400, style: "normal" },
+      { path: "/fonts/Luciole/Luciole-Italic.woff2", weight: 400, style: "italic" },
+      { path: "/fonts/Luciole/Luciole-Bold.woff2", weight: 700, style: "normal" },
+      { path: "/fonts/Luciole/Luciole-BoldItalic.woff2", weight: 700, style: "italic" }
+    ]
+  }),
+  ...readiumCSSFontCollection,
+  iAWriterDuo: createDefinitionFromStaticFonts({
+    id: "iAWriterDuo",
+    name: "iA Writer Duo",
+    label: "iA Writer Duospace",
+    fallbacks: ["monospace"],
+    files: [
+      { path: "/fonts/iAWriterDuo/iAWriterDuoS-Regular.woff2", weight: 400, style: "normal" },
+      { path: "/fonts/iAWriterDuo/iAWriterDuoS-Bold.woff2", weight: 700, style: "normal" },
+      { path: "/fonts/iAWriterDuo/iAWriterDuoS-Italic.woff2", weight: 400, style: "italic" },
+      { path: "/fonts/iAWriterDuo/iAWriterDuoS-BoldItalic.woff2", weight: 700, style: "italic" }
+    ]
+  }),
+  openDyslexic: createDefinitionFromStaticFonts({
+    id: "openDyslexic",
+    name: "Open Dyslexic",
+    files: [
+      { path: "/fonts/OpenDyslexic/OpenDyslexic-Regular.otf", weight: 400, style: "normal" },
+      { path: "/fonts/OpenDyslexic/OpenDyslexic-Italic.otf", weight: 400, style: "italic" },
+      { path: "/fonts/OpenDyslexic/OpenDyslexic-Bold.otf", weight: 700, style: "normal" },
+      { path: "/fonts/OpenDyslexic/OpenDyslexic-BoldItalic.otf", weight: 700, style: "italic" }
+    ]
+  }),
+  accessibleDfA: createDefinitionFromStaticFonts({
+    id: "accessibleDfA",
+    name: "Accessible DfA",
+    files: [
+      { path: "/fonts/AccessibleDfA/AccessibleDfA-Regular.woff2", weight: 400, style: "normal" },
+      { path: "/fonts/AccessibleDfA/AccessibleDfA-Italic.woff2", weight: 400, style: "italic" },
+      { path: "/fonts/AccessibleDfA/AccessibleDfA-Bold.woff2", weight: 700, style: "normal" }
+    ]
+  })
+};
+var tamilCollection = {
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Anek+Tamil:wght@100..800&family=Catamaran:wght@100..900&family=Hind+Madurai:wght@400;700&family=Mukta+Malar:wght@400;700&family=Noto+Sans+Tamil:wght@100..900&family=Noto+Serif+Tamil:ital,wght@0,100..900;1,100..900",
+    options: {
+      order: ["noto-sans-tamil", "noto-serif-tamil", "anek-tamil", "catamaran", "hind-madurai", "mukta-malar"],
+      labels: {
+        "noto-sans-tamil": "Noto Sans",
+        "noto-serif-tamil": "Noto Serif",
+        "anek-tamil": "\u0B85\u0BA9\u0BC7\u0B95\u0BCD \u0BA4\u0BAE\u0BBF\u0BB4\u0BCD",
+        "catamaran": "\u0B95\u0B9F\u0BCD\u0B9F\u0BC1\u0BAE\u0BB0\u0BA9\u0BCD",
+        "mukta-malar": "\u0BAE\u0BC1\u0B95\u0BCD\u0BA4 \u0BAE\u0BB2\u0BB0\u0BCD"
+      },
+      fallbacks: {
+        "noto-serif-tamil": ["serif"]
+      }
+    }
+  })
+};
+var sysFontDef = (id, name, family) => ({
+  id,
+  name,
+  source: { type: "system" },
+  spec: { family, fallbacks: [], weights: { type: "static", values: [400, 700] } }
+});
+var arabicFarsiCollection = {
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Noto+Sans+Arabic:wght@100..900&family=Noto+Naskh+Arabic:wght@400..700&family=Scheherazade+New:wght@400..700",
+    options: {
+      order: ["noto-sans-arabic", "noto-naskh-arabic", "scheherazade-new"],
+      labels: {
+        "noto-sans-arabic": "Noto Sans",
+        "noto-naskh-arabic": "Noto Naskh"
+      },
+      fallbacks: {
+        "noto-naskh-arabic": ["serif"],
+        "scheherazade-new": ["serif"]
+      }
+    }
+  })
+};
+var hebrewCollection = {
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Noto+Sans+Hebrew:wght@100..900&family=Frank+Ruhl+Libre:wght@300..900&family=Heebo:wght@100..800",
+    options: {
+      order: ["noto-sans-hebrew", "frank-ruhl-libre", "heebo"],
+      labels: {
+        "frank-ruhl-libre": "Frank R\xFChl Libre"
+      },
+      fallbacks: {
+        "frank-ruhl-libre": ["serif"]
+      }
+    }
+  })
+};
+var chineseSimplifiedCollection = {
+  "chinese-hans-sans": sysFontDef("chinese-hans-sans", "Sans-Serif", '"PingFang SC", "Microsoft YaHei", "WenQuanYi Micro Hei", sans-serif'),
+  "chinese-hans-serif": sysFontDef("chinese-hans-serif", "Serif", '"STSong", "SimSun", "AR PL UMing CN", serif'),
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Noto+Sans+SC:wght@100..900&family=Noto+Serif+SC:wght@200..900",
+    options: {
+      labels: {
+        "noto-sans-sc": "Noto Sans SC",
+        "noto-serif-sc": "Noto Serif SC"
+      },
+      fallbacks: {
+        "noto-serif-sc": ["serif"]
+      }
+    }
+  })
+};
+var chineseTraditionalCollection = {
+  "chinese-hant-sans": sysFontDef("chinese-hant-sans", "Sans-Serif", '"PingFang TC", "Microsoft JhengHei", "WenQuanYi Micro Hei", sans-serif'),
+  "chinese-hant-serif": sysFontDef("chinese-hant-serif", "Serif", '"MingLiU", "AR PL UMing TW", serif'),
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Noto+Sans+TC:wght@100..900&family=Noto+Serif+TC:wght@200..900",
+    options: {
+      labels: {
+        "noto-sans-tc": "Noto Sans TC",
+        "noto-serif-tc": "Noto Serif TC"
+      },
+      fallbacks: {
+        "noto-serif-tc": ["serif"]
+      }
+    }
+  })
+};
+var japaneseCollection = {
+  "japanese-sans": sysFontDef("japanese-sans", "Sans-Serif", '"Hiragino Kaku Gothic ProN", "Yu Gothic", "Meiryo", sans-serif'),
+  "japanese-serif": sysFontDef("japanese-serif", "Serif", '"Hiragino Mincho ProN", "Yu Mincho", "MS PMincho", serif'),
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Noto+Sans+JP:wght@100..900&family=Noto+Serif+JP:wght@200..900",
+    options: {
+      labels: {
+        "noto-sans-jp": "Noto Sans JP",
+        "noto-serif-jp": "Noto Serif JP"
+      },
+      fallbacks: {
+        "noto-serif-jp": ["serif"]
+      }
+    }
+  })
+};
+var japaneseVerticalCollection = {
+  "japanese-v-serif": sysFontDef("japanese-v-serif", "Serif", '"Hiragino Mincho ProN", "Yu Mincho", "MS PMincho", serif'),
+  "japanese-v-sans": sysFontDef("japanese-v-sans", "Sans-Serif", '"Hiragino Kaku Gothic ProN", "Yu Gothic", "Meiryo", sans-serif'),
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Noto+Serif+JP:wght@200..900&family=Shippori+Mincho:wght@400..800&family=Noto+Sans+JP:wght@100..900",
+    options: {
+      order: ["noto-serif-jp", "shippori-mincho", "noto-sans-jp"],
+      labels: {
+        "noto-serif-jp": "Noto Serif JP",
+        "noto-sans-jp": "Noto Sans JP"
+      },
+      fallbacks: {
+        "noto-serif-jp": ["serif"],
+        "shippori-mincho": ["serif"]
+      }
+    }
+  })
+};
+var koreanCollection = {
+  "korean-sans": sysFontDef("korean-sans", "Sans-Serif", '"Apple SD Gothic Neo", "Malgun Gothic", "Dotum", sans-serif'),
+  "korean-serif": sysFontDef("korean-serif", "Serif", '"Batang", "Gungsuh", "Apple Myungjo", serif'),
+  ...createDefinitionsFromGoogleFonts({
+    cssUrl: "https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@100..900&family=Noto+Serif+KR:wght@200..900&family=Nanum+Myeongjo:wght@400;700;800",
+    options: {
+      order: ["noto-sans-kr", "noto-serif-kr", "nanum-myeongjo"],
+      labels: {
+        "noto-sans-kr": "Noto Sans KR",
+        "noto-serif-kr": "Noto Serif KR"
+      },
+      fallbacks: {
+        "noto-serif-kr": ["serif"],
+        "nanum-myeongjo": ["serif"]
+      }
+    }
+  })
+};
+
+// src/preferences/models/protection.ts
+var resolveContentProtectionConfig = (contentProtection, t) => {
+  if (!contentProtection) return void 0;
+  let resolvedWatermark;
+  if (contentProtection.protectPrinting?.watermark) {
+    if (typeof contentProtection.protectPrinting.watermark === "object" && "key" in contentProtection.protectPrinting.watermark) {
+      resolvedWatermark = t(contentProtection.protectPrinting.watermark.key, {
+        defaultValue: contentProtection.protectPrinting.watermark.fallback
+      });
+    } else if (typeof contentProtection.protectPrinting.watermark === "string") {
+      resolvedWatermark = t(contentProtection.protectPrinting.watermark);
+    }
+  }
+  const resolved = {
+    protectCopy: contentProtection.protectCopy,
+    disableContextMenu: contentProtection.disableContextMenu,
+    disableDragAndDrop: contentProtection.disableDragAndDrop,
+    protectPrinting: contentProtection.protectPrinting?.disable ? {
+      disable: true,
+      watermark: resolvedWatermark
+    } : void 0,
+    disableSelectAll: contentProtection.disableSelectAll,
+    disableSave: contentProtection.disableSave,
+    monitorDevTools: contentProtection.monitorDevTools
+    // TODO: When we implement it in non-audio navigators, uncomment
+    // disableRemotePlayback: contentProtection.disableRemotePlayback
+  };
+  return resolved;
+};
+var resolveAudioContentProtectionConfig = (contentProtection, t) => {
+  if (!contentProtection) return void 0;
+  let resolvedWatermark;
+  if (contentProtection.protectPrinting?.watermark) {
+    if (typeof contentProtection.protectPrinting.watermark === "object" && "key" in contentProtection.protectPrinting.watermark) {
+      resolvedWatermark = t(contentProtection.protectPrinting.watermark.key, {
+        defaultValue: contentProtection.protectPrinting.watermark.fallback
+      });
+    } else if (typeof contentProtection.protectPrinting.watermark === "string") {
+      resolvedWatermark = t(contentProtection.protectPrinting.watermark);
+    }
+  }
+  return {
+    protectCopy: contentProtection.protectCopy,
+    disableContextMenu: contentProtection.disableContextMenu,
+    disableDragAndDrop: contentProtection.disableDragAndDrop,
+    protectPrinting: contentProtection.protectPrinting?.disable ? {
+      disable: true,
+      watermark: resolvedWatermark
+    } : void 0,
+    disableSelectAll: contentProtection.disableSelectAll,
+    disableSave: contentProtection.disableSave,
+    monitorDevTools: contentProtection.monitorDevTools,
+    disableRemotePlayback: contentProtection.disableRemotePlayback
+  };
+};
+var defaultContentProtectionConfig = {
+  protectCopy: false,
+  disableContextMenu: false,
+  disableDragAndDrop: false,
+  protectPrinting: {
+    disable: false,
+    watermark: "reader.app.printingDisabled"
+  },
+  disableSelectAll: false,
+  disableSave: false,
+  monitorDevTools: false
+};
+var defaultAudioContentProtectionConfig = {
+  protectCopy: false,
+  disableContextMenu: false,
+  disableDragAndDrop: false,
+  protectPrinting: {
+    disable: false,
+    watermark: "reader.app.printingDisabled"
+  },
+  disableSelectAll: false,
+  disableSave: false,
+  monitorDevTools: false,
+  disableRemotePlayback: false
+};
+var devContentProtectionConfig = {
+  protectCopy: false,
+  disableContextMenu: false,
+  disableDragAndDrop: false,
+  protectPrinting: {
+    disable: false
+  },
+  disableSelectAll: false,
+  disableSave: false,
+  monitorDevTools: false,
+  disableRemotePlayback: false
+};
+var ThThemeKeys = /* @__PURE__ */ ((ThThemeKeys3) => {
+  ThThemeKeys3["light"] = "light";
+  ThThemeKeys3["sepia"] = "sepia";
+  ThThemeKeys3["dark"] = "dark";
+  ThThemeKeys3["paper"] = "paper";
+  ThThemeKeys3["contrast1"] = "contrast1";
+  ThThemeKeys3["contrast2"] = "contrast2";
+  ThThemeKeys3["contrast3"] = "contrast3";
+  return ThThemeKeys3;
+})(ThThemeKeys || {});
+var lightTheme = {
+  background: ReadiumCSSColors.RS__backgroundColor,
+  // Color of background
+  text: ReadiumCSSColors.RS__textColor,
+  // Color of text
+  link: "#0000ee",
+  // Color of links
+  visited: "#551a8b",
+  // Color of visited links
+  subdue: "#808080",
+  // Color of subdued elements
+  disable: "#808080",
+  // color for :disabled
+  hover: "#d9d9d9",
+  // color of background for :hover
+  onHover: ReadiumCSSColors.RS__textColor,
+  // color of text for :hover
+  select: "#b4d8fe",
+  // color of selected background
+  onSelect: "inherit",
+  // color of selected text
+  focus: "#0067f4",
+  // color of :focus-visible
+  elevate: "0px 0px 2px #808080",
+  // drop shadow of containers
+  immerse: "0.6"
+  // opacity of immersive mode
+};
+var darkTheme = {
+  background: "#000000",
+  text: "#FEFEFE",
+  link: "#63caff",
+  visited: "#0099E5",
+  subdue: "#808080",
+  disable: "#808080",
+  hover: "#404040",
+  onHover: "#FEFEFE",
+  select: "#b4d8fe",
+  onSelect: "inherit",
+  focus: "#0067f4",
+  elevate: "0px 0px 2px #808080",
+  immerse: "0.4"
+};
+var paperTheme = {
+  background: "#faf4e8",
+  text: "#121212",
+  link: "#0000EE",
+  visited: "#551A8B",
+  subdue: "#8c8c8c",
+  disable: "#8c8c8c",
+  hover: "#edd7ab",
+  onHover: "#121212",
+  select: "#b4d8fe",
+  onSelect: "inherit",
+  focus: "#0067f4",
+  elevate: "0px 0px 2px #8c8c8c",
+  immerse: "0.5"
+};
+var sepiaTheme = {
+  background: "#e9ddc8",
+  text: "#000000",
+  link: "#0000EE",
+  visited: "#551A8B",
+  subdue: "#8c8c8c",
+  disable: "#8c8c8c",
+  hover: "#ccb07f",
+  onHover: "#000000",
+  select: "#b4d8fe",
+  onSelect: "inherit",
+  focus: "#004099",
+  elevate: "0px 0px 2px #8c8c8c",
+  immerse: "0.45"
+};
+var contrast1Theme = {
+  background: "#000000",
+  text: "#ffff00",
+  link: "#63caff",
+  visited: "#0099E5",
+  subdue: "#808000",
+  disable: "#808000",
+  hover: "#404040",
+  onHover: "#ffff00",
+  select: "#b4d8fe",
+  onSelect: "inherit",
+  focus: "#0067f4",
+  elevate: "0px 0px 2px #808000",
+  immerse: "0.4"
+};
+var contrast2Theme = {
+  background: "#181842",
+  text: "#ffffff",
+  link: "#adcfff",
+  visited: "#7ab2ff",
+  subdue: "#808080",
+  disable: "#808080",
+  hover: "#4444bb",
+  onHover: "#ffffff",
+  select: "#b4d8fe",
+  onSelect: "inherit",
+  focus: "#6BA9FF",
+  elevate: "0px 0px 2px #808080",
+  immerse: "0.4"
+};
+var contrast3Theme = {
+  background: "#c5e7cd",
+  text: "#000000",
+  link: "#0000EE",
+  visited: "#551A8B",
+  subdue: "#8c8c8c",
+  disable: "#8c8c8c",
+  hover: "#6fc383",
+  onHover: "#000000",
+  select: "#b4d8fe",
+  onSelect: "inherit",
+  focus: "#004099",
+  elevate: "0px 0px 2px #8c8c8c",
+  immerse: "0.45"
+};
+
+// src/preferences/audioPreferences.ts
+var ThAudioAffordance = /* @__PURE__ */ ((ThAudioAffordance2) => {
+  ThAudioAffordance2["timeline"] = "timeline";
+  ThAudioAffordance2["readingOrder"] = "readingOrder";
+  ThAudioAffordance2["toc"] = "toc";
+  return ThAudioAffordance2;
+})(ThAudioAffordance || {});
+var validateRangePresets = (pref, context) => {
+  if (pref.variant !== "sliderWithPresets" /* sliderWithPresets */ || !pref.presets?.length) return;
+  const [min, max] = [Math.min(...pref.range), Math.max(...pref.range)];
+  const step = pref.step;
+  const tolerance = step * 1e-9;
+  const invalid = pref.presets.filter((p) => {
+    if (p < min || p > max) return true;
+    const offset = (p - min) / step;
+    return Math.abs(offset - Math.round(offset)) > tolerance;
+  });
+  if (invalid.length > 0) {
+    console.warn(
+      `${context}: presets [${invalid.join(", ")}] are not reachable with range=[${min}, ${max}] and step=${step}.`
+    );
+  }
+};
+var createAudioPreferences = (params) => {
+  if (params.actions?.secondary) {
+    validateObjectKeys(
+      [params.actions.secondary.displayOrder],
+      params.actions.secondary.keys,
+      "actions.secondary"
+    );
+  }
+  if (params.settings?.order) {
+    const order = params.settings.order;
+    const hasSkipInterval = order.includes("skipInterval" /* skipInterval */);
+    const hasSplitIntervals = order.includes("skipBackwardInterval" /* skipBackwardInterval */) || order.includes("skipForwardInterval" /* skipForwardInterval */);
+    if (hasSkipInterval && hasSplitIntervals) {
+      console.warn(
+        `settings.order contains both "${"skipInterval" /* skipInterval */}" and split interval keys. Use one or the other.`
+      );
+    }
+  }
+  if (params.theming?.themes) {
+    validateObjectKeys(
+      [params.theming.themes.audioOrder],
+      params.theming.themes.keys,
+      "theming.themes",
+      "auto"
+    );
+  }
+  if (params.theming?.layout?.publicationMetadata?.order) {
+    const order = params.theming.layout.publicationMetadata.order;
+    const titleVariants = [
+      "title" /* title */,
+      "titleWithSubtitle" /* titleWithSubtitle */,
+      "subtitleWithTitle" /* subtitleWithTitle */
+    ];
+    const titleVariantsInOrder = order.filter((c) => titleVariants.includes(c));
+    if (titleVariantsInOrder.length > 1) {
+      console.warn(
+        `publicationMetadata.order contains multiple title variants [${titleVariantsInOrder.join(", ")}]. Using first one only.`
+      );
+      const firstTitleIndex = order.findIndex((c) => titleVariants.includes(c));
+      params.theming.layout.publicationMetadata.order = order.filter((component, index) => {
+        if (component === "authors" /* authors */) return true;
+        return index === firstTitleIndex;
+      });
+    }
+  }
+  Object.entries(params.settings?.keys ?? {}).forEach(([key, pref]) => {
+    if (pref && typeof pref === "object" && "variant" in pref) {
+      validateRangePresets(pref, `settings.keys.${key}`);
+    }
+  });
+  return params;
+};
+
+// src/preferences/defaultAudioPreferences.ts
+var defaultAudioPreferences = createAudioPreferences({
+  theming: {
+    header: {
+      backLink: {
+        variant: "arrow" /* arrow */,
+        visibility: "partially",
+        href: "/"
+      }
+    },
+    icon: {
+      size: 24,
+      tooltipOffset: 10
+    },
+    layout: {
+      compact: {
+        order: [
+          "cover" /* cover */,
+          "metadata" /* metadata */,
+          "playbackControls" /* playbackControls */,
+          "progressBar" /* progressBar */,
+          "mediaActions" /* mediaActions */
+        ]
+      },
+      expanded: {
+        start: [
+          "cover" /* cover */,
+          "metadata" /* metadata */
+        ],
+        end: [
+          "playbackControls" /* playbackControls */,
+          "progressBar" /* progressBar */,
+          "mediaActions" /* mediaActions */
+        ]
+      },
+      publicationMetadata: {
+        order: [
+          "titleWithSubtitle" /* titleWithSubtitle */
+        ]
+      },
+      radius: 5,
+      spacing: 20,
+      progressBar: {
+        variant: "segmented" /* segmented */
+      },
+      defaults: {
+        dockingWidth: 340,
+        scrim: "rgba(0, 0, 0, 0.2)"
+      },
+      constraints: {
+        ["bottomSheet" /* bottomSheet */]: 600,
+        ["popover" /* popover */]: 600,
+        ["modal" /* modal */]: 600,
+        cover: 300
+      }
+    },
+    breakpoints: {
+      ["compact" /* compact */]: 600,
+      ["medium" /* medium */]: 840,
+      ["expanded" /* expanded */]: 1200,
+      ["large" /* large */]: 1600,
+      ["xLarge" /* xLarge */]: null
+    },
+    themes: {
+      audioOrder: [
+        "auto",
+        "light" /* light */,
+        "dark" /* dark */
+      ],
+      systemThemes: {
+        light: "light" /* light */,
+        dark: "dark" /* dark */
+      },
+      keys: {
+        ["light" /* light */]: lightTheme,
+        ["dark" /* dark */]: darkTheme
+      }
+    }
+  },
+  actions: {
+    primary: {
+      displayOrder: [
+        "audio.volume" /* volume */,
+        "audio.playbackRate" /* playbackRate */,
+        "audio.toc" /* toc */,
+        "audio.sleepTimer" /* sleepTimer */
+      ],
+      keys: {
+        ["audio.volume" /* volume */]: defaultAudioVolumeAction,
+        ["audio.playbackRate" /* playbackRate */]: defaultAudioPlaybackRateAction,
+        ["audio.toc" /* toc */]: defaultAudioTocAction,
+        ["audio.sleepTimer" /* sleepTimer */]: defaultAudioSleepTimerAction
+      }
+    },
+    secondary: {
+      displayOrder: [
+        "audio.remotePlayback" /* remotePlayback */,
+        "settings" /* settings */
+      ],
+      collapse: {
+        ["compact" /* compact */]: 2,
+        ["medium" /* medium */]: 3
+      },
+      keys: {
+        ["audio.remotePlayback" /* remotePlayback */]: defaultAudioRemotePlaybackAction,
+        ["settings" /* settings */]: defaultSettingsAction
+      }
+    }
+  },
+  settings: {
+    order: [
+      "theme" /* theme */,
+      "skipBackwardInterval" /* skipBackwardInterval */,
+      "skipForwardInterval" /* skipForwardInterval */,
+      "autoPlay" /* autoPlay */
+    ],
+    keys: {
+      ["volume" /* volume */]: defaultAudioVolume,
+      ["playbackRate" /* playbackRate */]: defaultAudioPlaybackRate,
+      ["skipBackwardInterval" /* skipBackwardInterval */]: defaultAudioSkipBackwardInterval,
+      ["skipForwardInterval" /* skipForwardInterval */]: defaultAudioSkipForwardInterval,
+      ["sleepTimer" /* sleepTimer */]: defaultAudioSleepTimer
+    }
+  },
+  contentProtection: defaultAudioContentProtectionConfig,
+  affordances: {
+    previous: "toc" /* toc */,
+    next: "toc" /* toc */
+  },
+  shortcuts: {
+    representation: "symbol" /* symbol */,
+    joiner: "+"
+  },
+  docking: {
+    displayOrder: [
+      "dockingTransient" /* transient */,
+      "dockingStart" /* start */,
+      "dockingEnd" /* end */
+    ],
+    // Only toc is dockable; others have dockable:none so dock panels are TOC-only
+    // Matches EPUB config: no docking on compact/medium (mobile/tablet portrait)
+    dock: {
+      ["compact" /* compact */]: "none" /* none */,
+      ["medium" /* medium */]: "none" /* none */,
+      ["expanded" /* expanded */]: "start" /* start */,
+      ["large" /* large */]: "both" /* both */,
+      ["xLarge" /* xLarge */]: "both" /* both */
+    },
+    collapse: true,
+    keys: {
+      ["dockingStart" /* start */]: { visibility: "overflow" /* overflow */, shortcut: null },
+      ["dockingEnd" /* end */]: { visibility: "overflow" /* overflow */, shortcut: null },
+      ["dockingTransient" /* transient */]: { visibility: "overflow" /* overflow */, shortcut: null }
+    }
+  }
+});
+var ThAudioPreferencesContext = createContext(null);
+var defaultAudioPreferencesContextValue = {
+  preferences: defaultAudioPreferences,
+  updatePreferences: () => {
+    throw new Error("updatePreferences must be used within a ThAudioPreferencesProvider");
+  }
+};
+
+// src/preferences/adapters/ThAudioMemoryPreferencesAdapter.ts
+var ThAudioMemoryPreferencesAdapter = class {
+  currentPreferences;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(initialPreferences) {
+    this.currentPreferences = { ...initialPreferences };
+  }
+  getPreferences() {
+    return { ...this.currentPreferences };
+  }
+  setPreferences(prefs) {
+    this.currentPreferences = { ...prefs };
+    this.notifyListeners(this.currentPreferences);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+  }
+  unsubscribe(listener) {
+    this.listeners.delete(listener);
+  }
+  notifyListeners(prefs) {
+    this.listeners.forEach((listener) => listener({ ...prefs }));
+  }
+};
+function ThAudioPreferencesProvider({
+  adapter,
+  initialPreferences,
+  devMode,
+  children
+}) {
+  const effectiveAdapter = useMemo(() => {
+    let fallback = defaultAudioPreferencesContextValue.preferences;
+    if (devMode && !initialPreferences) {
+      fallback = { ...fallback, contentProtection: devContentProtectionConfig };
+    }
+    return adapter || new ThAudioMemoryPreferencesAdapter(
+      initialPreferences || fallback
+    );
+  }, [adapter, initialPreferences, devMode]);
+  const [preferences, setPreferences] = useState(
+    (() => {
+      let fallback = defaultAudioPreferencesContextValue.preferences;
+      if (devMode && !initialPreferences) {
+        fallback = { ...fallback, contentProtection: devContentProtectionConfig };
+      }
+      return initialPreferences || fallback;
+    })()
+  );
+  const handlePreferenceChange = useCallback((newPrefs) => {
+    setPreferences(
+      (prev) => JSON.stringify(prev) === JSON.stringify(newPrefs) ? prev : newPrefs
+    );
+  }, []);
+  useEffect(() => {
+    effectiveAdapter.subscribe(handlePreferenceChange);
+    return () => {
+      effectiveAdapter.unsubscribe(handlePreferenceChange);
+    };
+  }, [effectiveAdapter, handlePreferenceChange]);
+  const contextValue = useMemo(() => ({
+    preferences,
+    updatePreferences: (newPrefs) => {
+      effectiveAdapter.setPreferences(newPrefs);
+    }
+  }), [preferences, effectiveAdapter]);
+  return /* @__PURE__ */ jsx(ThAudioPreferencesContext.Provider, { value: contextValue, children });
+}
+
+// src/preferences/preferences.ts
+var createPreferences = (params) => {
+  if (params.actions) {
+    validateObjectKeys(
+      [
+        params.actions.reflowOrder,
+        params.actions.fxlOrder,
+        params.actions.webPubOrder
+      ],
+      params.actions.keys,
+      "actions"
+    );
+  }
+  if (params.theming?.themes) {
+    validateObjectKeys(
+      [params.theming.themes.reflowOrder, params.theming.themes.fxlOrder],
+      params.theming.themes.keys,
+      "theming.themes",
+      "auto"
+      // Special case for themes
+    );
+  }
+  if (params.settings.spacing?.presets) {
+    validateObjectKeys(
+      [params.settings.spacing.presets.reflowOrder],
+      params.settings.spacing.presets.keys,
+      "settings.spacing.presets",
+      ["publisher", "custom"]
+    );
+  }
+  if (params.settings?.spacing?.presets?.keys && params.settings?.keys) {
+    const spacingSettings = params.settings.spacing.presets.keys;
+    const spacingThemes = params.settings.spacing.presets.keys;
+    const adjustSpacingValue = (key, value, context) => {
+      const settingKey = Object.values(ThSettingsKeys).find((k) => k === key);
+      if (!settingKey) {
+        return value;
+      }
+      const setting = spacingSettings[settingKey];
+      if (!setting) {
+        return value;
+      }
+      let range;
+      let step;
+      if (setting && typeof setting === "object" && "range" in setting) {
+        range = setting.range;
+        step = setting.step;
+      } else if (setting && typeof setting === "object") {
+        return value;
+      }
+      let adjustedValue = value;
+      if (range) {
+        const [min, max] = range;
+        if (adjustedValue < min) {
+          console.warn(`Adjusting value ${value} for ${context.join(".")} to minimum allowed value ${min}`);
+          adjustedValue = min;
+        } else if (adjustedValue > max) {
+          console.warn(`Adjusting value ${value} for ${context.join(".")} to maximum allowed value ${max}`);
+          adjustedValue = max;
+        }
+      }
+      if (step && range) {
+        const [min] = range;
+        const steps = Math.round((adjustedValue - min) / step);
+        const steppedValue = parseFloat((min + steps * step).toFixed(10));
+        const finalValue = Math.min(Math.max(steppedValue, range[0]), range[1]);
+        if (Math.abs(finalValue - adjustedValue) > Number.EPSILON) {
+          console.warn(`Adjusting value ${value} for ${context.join(".")} to nearest step value ${finalValue}`);
+          adjustedValue = finalValue;
+        }
+      }
+      return adjustedValue;
+    };
+    for (const [themeName, spacingTheme] of Object.entries(spacingThemes)) {
+      if (spacingTheme && typeof spacingTheme === "object") {
+        const adjustedTheme = {};
+        let hasAdjustedValues = false;
+        for (const [key, value] of Object.entries(spacingTheme)) {
+          if (typeof value === "number") {
+            const context = ["theming", "spacing", "keys", themeName, key];
+            const adjustedValue = adjustSpacingValue(key, value, context);
+            adjustedTheme[key] = adjustedValue;
+            if (adjustedValue !== value) {
+              hasAdjustedValues = true;
+            }
+          } else {
+            adjustedTheme[key] = value;
+          }
+        }
+        if (hasAdjustedValues) {
+          spacingThemes[themeName] = adjustedTheme;
+        }
+      }
+    }
+  }
+  if (params.settings?.keys?.fontFamily) {
+    const fontFamilyPref = params.settings.keys.fontFamily;
+    const languageMap = /* @__PURE__ */ new Map();
+    Object.entries(fontFamilyPref).forEach(([collectionName, collectionData]) => {
+      if (collectionName === "default") return;
+      const supportedLangs = "supportedLanguages" in collectionData ? collectionData.supportedLanguages : null;
+      if (supportedLangs && Array.isArray(supportedLangs)) {
+        supportedLangs.forEach((lang) => {
+          if (!languageMap.has(lang)) {
+            languageMap.set(lang, []);
+          }
+          languageMap.get(lang).push(collectionName);
+        });
+      }
+    });
+    languageMap.forEach((collections, language) => {
+      if (collections.length > 1) {
+        console.warn(`Language "${language}" is supported by multiple font collections: ${collections.join(", ")}. This may cause ambiguous font selection. Consider consolidating to a single collection per language.`);
+      }
+    });
+  }
+  const validateRangePresets2 = (pref, context) => {
+    if (pref.variant !== "sliderWithPresets" /* sliderWithPresets */ || !pref.presets?.length) return;
+    const [min, max] = [Math.min(...pref.range), Math.max(...pref.range)];
+    const step = pref.step;
+    const tolerance = step * 1e-9;
+    const invalid = pref.presets.filter((p) => {
+      if (p < min || p > max) return true;
+      const offset = (p - min) / step;
+      return Math.abs(offset - Math.round(offset)) > tolerance;
+    });
+    if (invalid.length > 0) {
+      console.warn(`${context}: presets [${invalid.join(", ")}] are not reachable with range=[${min}, ${max}] and step=${step}.`);
+    }
+  };
+  Object.entries(params.settings?.keys ?? {}).forEach(([key, pref]) => {
+    if (pref && typeof pref === "object" && "variant" in pref) {
+      validateRangePresets2(pref, `settings.keys.${key}`);
+    }
+  });
+  return params;
+};
+
+// src/preferences/defaultPreferences.ts
+var defaultPreferences = createPreferences({
+  //  direction: ThLayoutDirection.ltr,
+  //  locale: "en",
+  experiments: {
+    reflow: ["experimentalHeaderFiltering", "experimentalZoom"],
+    webPub: ["experimentalHeaderFiltering", "experimentalZoom"]
+  },
+  metadata: {
+    documentTitle: {
+      format: "title" /* title */
+    }
+  },
+  typography: {
+    minimalLineLength: 40,
+    // undefined | null | number of characters. If 2 cols will switch to 1 based on this
+    optimalLineLength: 55,
+    // number of characters. If auto layout, picks colCount based on this
+    maximalLineLength: 70,
+    // undefined | null | number of characters.
+    pageGutter: 20
+  },
+  theming: {
+    header: {
+      backLink: {
+        variant: "arrow" /* arrow */,
+        visibility: "partially",
+        href: "/"
+      },
+      runningHead: {
+        format: {
+          reflow: {
+            default: {
+              variants: "chapter" /* chapter */,
+              displayInImmersive: true,
+              displayInFullscreen: false
+            },
+            breakpoints: {
+              ["compact" /* compact */]: {
+                variants: "chapter" /* chapter */,
+                displayInImmersive: false,
+                displayInFullscreen: false
+              }
+            }
+          },
+          fxl: {
+            default: {
+              variants: "title" /* title */,
+              displayInImmersive: true,
+              displayInFullscreen: true
+            },
+            breakpoints: {
+              ["compact" /* compact */]: {
+                variants: "title" /* title */,
+                displayInImmersive: false,
+                displayInFullscreen: true
+              }
+            }
+          },
+          webPub: {
+            default: {
+              variants: "chapter" /* chapter */,
+              displayInImmersive: true,
+              displayInFullscreen: true
+            }
+          }
+        }
+      }
+    },
+    progression: {
+      format: {
+        reflow: {
+          default: {
+            variants: [
+              "positionsPercentOfTotal" /* positionsPercentOfTotal */,
+              "progressionOfResource" /* progressionOfResource */
+            ],
+            displayInImmersive: true,
+            displayInFullscreen: false
+          },
+          breakpoints: {
+            ["compact" /* compact */]: {
+              variants: [
+                "positionsOfTotal" /* positionsOfTotal */,
+                "resourceProgression" /* resourceProgression */
+              ],
+              displayInImmersive: false,
+              displayInFullscreen: false
+            }
+          }
+        },
+        fxl: {
+          default: {
+            variants: [
+              "positionsOfTotal" /* positionsOfTotal */,
+              "overallProgression" /* overallProgression */,
+              "none" /* none */
+            ],
+            displayInImmersive: true,
+            displayInFullscreen: true
+          },
+          breakpoints: {
+            ["compact" /* compact */]: {
+              variants: [
+                "positions" /* positions */,
+                "overallProgression" /* overallProgression */,
+                "none" /* none */
+              ],
+              displayInImmersive: false,
+              displayInFullscreen: true
+            }
+          }
+        },
+        webPub: {
+          default: {
+            variants: [
+              "readingOrderIndex" /* readingOrderIndex */,
+              "none" /* none */
+            ],
+            displayInImmersive: true,
+            displayInFullscreen: true
+          }
+        }
+      }
+    },
+    arrow: {
+      size: 40,
+      // Size of the left and right arrows in px
+      offset: 5
+      // offset of the arrows from the edges in px
+    },
+    icon: {
+      size: 24,
+      // Size of icons in px
+      tooltipOffset: 10
+      // offset of tooltip in px
+    },
+    layout: {
+      ui: {
+        reflow: "layered-ui" /* layered */,
+        fxl: "layered-ui" /* layered */,
+        webPub: "stacked-ui" /* stacked */
+      },
+      radius: 5,
+      // border-radius of containers
+      spacing: 20,
+      // padding of containers/sheets
+      defaults: {
+        dockingWidth: 340,
+        // default width of resizable panels
+        scrim: "rgba(0, 0, 0, 0.2)"
+        // default scrim/underlay bg-color
+      },
+      constraints: {
+        ["bottomSheet" /* bottomSheet */]: 600,
+        // Max-width of all bottom sheets
+        ["popover" /* popover */]: 600,
+        // Max-width of all popover sheets
+        ["modal" /* modal */]: 600,
+        // Max-width of all modal sheets
+        pagination: 1024,
+        // Max-width of pagination component
+        dropdown: 250
+        // Max-height of main UI dropdowns
+      }
+    },
+    breakpoints: {
+      // See https://m3.material.io/foundations/layout/applying-layout/window-size-classes
+      ["compact" /* compact */]: 600,
+      // Phone in portrait
+      ["medium" /* medium */]: 840,
+      // Tablet in portrait, Foldable in portrait (unfolded)
+      ["expanded" /* expanded */]: 1200,
+      // Phone in landscape, Tablet in landscape, Foldable in landscape (unfolded), Desktop
+      ["large" /* large */]: 1600,
+      // Desktop
+      ["xLarge" /* xLarge */]: null
+      // Desktop Ultra-wide
+    },
+    themes: {
+      reflowOrder: [
+        "auto",
+        "light" /* light */,
+        "paper" /* paper */,
+        "sepia" /* sepia */,
+        "dark" /* dark */,
+        "contrast1" /* contrast1 */,
+        "contrast2" /* contrast2 */,
+        "contrast3" /* contrast3 */
+      ],
+      fxlOrder: [
+        "auto",
+        "light" /* light */,
+        "dark" /* dark */
+      ],
+      systemThemes: {
+        light: "light" /* light */,
+        dark: "dark" /* dark */
+      },
+      keys: {
+        ["light" /* light */]: lightTheme,
+        ["dark" /* dark */]: darkTheme,
+        ["paper" /* paper */]: paperTheme,
+        ["sepia" /* sepia */]: sepiaTheme,
+        ["contrast1" /* contrast1 */]: contrast1Theme,
+        ["contrast2" /* contrast2 */]: contrast2Theme,
+        ["contrast3" /* contrast3 */]: contrast3Theme
+      }
+    }
+  },
+  contentProtection: defaultContentProtectionConfig,
+  affordances: {
+    scroll: {
+      hintInImmersive: true,
+      toggleOnMiddlePointer: ["tap", "click"],
+      hideOnForwardScroll: true,
+      showOnBackwardScroll: true
+    },
+    paginated: {
+      reflow: {
+        default: {
+          variant: "layered" /* layered */,
+          discard: ["navigation"],
+          hint: ["layoutChange"]
+        },
+        breakpoints: {
+          ["large" /* large */]: {
+            variant: "stacked" /* stacked */
+          },
+          ["xLarge" /* xLarge */]: {
+            variant: "stacked" /* stacked */
+          }
+        }
+      },
+      fxl: {
+        // Note FXL arrows are always layered
+        // FXL navigator is using the window width to calculate the layout
+        // so we need to force the layered variant to prevent layout issues
+        default: {
+          variant: "layered" /* layered */,
+          discard: ["navigation"],
+          hint: "none"
+        }
+      }
+    }
+  },
+  shortcuts: {
+    representation: "symbol" /* symbol */,
+    joiner: "+"
+  },
+  actions: {
+    reflowOrder: [
+      "settings" /* settings */,
+      "toc" /* toc */,
+      "fullscreen" /* fullscreen */,
+      "jumpToPosition" /* jumpToPosition */
+    ],
+    fxlOrder: [
+      "settings" /* settings */,
+      "toc" /* toc */,
+      "fullscreen" /* fullscreen */,
+      "jumpToPosition" /* jumpToPosition */
+    ],
+    webPubOrder: [
+      "settings" /* settings */,
+      "toc" /* toc */,
+      "fullscreen" /* fullscreen */
+    ],
+    collapse: true,
+    keys: {
+      ["settings" /* settings */]: defaultSettingsAction,
+      ["fullscreen" /* fullscreen */]: defaultFullscreenAction,
+      ["toc" /* toc */]: defaultTocAction,
+      ["jumpToPosition" /* jumpToPosition */]: defaultJumpToPositionAction
+    }
+  },
+  docking: {
+    displayOrder: [
+      "dockingTransient" /* transient */,
+      "dockingStart" /* start */,
+      "dockingEnd" /* end */
+    ],
+    dock: {
+      ["compact" /* compact */]: "none" /* none */,
+      ["medium" /* medium */]: "none" /* none */,
+      ["expanded" /* expanded */]: "start" /* start */,
+      ["large" /* large */]: "both" /* both */,
+      ["xLarge" /* xLarge */]: "both" /* both */
+    },
+    collapse: true,
+    keys: {
+      ["dockingStart" /* start */]: {
+        visibility: "overflow" /* overflow */,
+        shortcut: null
+      },
+      ["dockingEnd" /* end */]: {
+        visibility: "overflow" /* overflow */,
+        shortcut: null
+      },
+      ["dockingTransient" /* transient */]: {
+        visibility: "overflow" /* overflow */,
+        shortcut: null
+      }
+    }
+  },
+  settings: {
+    reflowOrder: [
+      "zoom" /* zoom */,
+      "textGroup" /* textGroup */,
+      "theme" /* theme */,
+      "spacingGroup" /* spacingGroup */,
+      "layout" /* layout */,
+      "columns" /* columns */
+    ],
+    fxlOrder: [
+      "theme" /* theme */,
+      "columns" /* columns */
+    ],
+    webPubOrder: [
+      "zoom" /* zoom */,
+      "textGroup" /* textGroup */,
+      "spacingGroup" /* spacingGroup */
+    ],
+    keys: {
+      ["fontFamily" /* fontFamily */]: {
+        default: defaultFontCollection,
+        arabic: { supportedLanguages: ["ar", "fa"], fonts: arabicFarsiCollection },
+        hebrew: { supportedLanguages: ["he"], fonts: hebrewCollection },
+        "chinese-simplified": { supportedLanguages: ["zh", "zh-hans", "zh-cn"], fonts: chineseSimplifiedCollection },
+        "chinese-traditional": { supportedLanguages: ["zh-hant", "zh-tw", "zh-hk"], fonts: chineseTraditionalCollection },
+        japanese: { supportedLanguages: ["ja"], fonts: japaneseCollection },
+        "japanese-vertical": { supportedLanguages: ["ja-v"], fonts: japaneseVerticalCollection },
+        korean: { supportedLanguages: ["ko"], fonts: koreanCollection },
+        tamil: { supportedLanguages: ["ta"], fonts: tamilCollection }
+      },
+      ["letterSpacing" /* letterSpacing */]: defaultLetterSpacing,
+      ["lineHeight" /* lineHeight */]: {
+        allowUnset: false,
+        keys: defaultLineHeights
+      },
+      ["paragraphIndent" /* paragraphIndent */]: defaultParagraphIndent,
+      ["paragraphSpacing" /* paragraphSpacing */]: defaultParagraphSpacing,
+      ["wordSpacing" /* wordSpacing */]: defaultWordSpacing,
+      ["zoom" /* zoom */]: defaultZoom
+    },
+    text: {
+      header: "previous" /* previous */,
+      main: defaultTextSettingsMain,
+      subPanel: defaultTextSettingsSubpanel
+    },
+    spacing: {
+      header: "previous" /* previous */,
+      main: defaultSpacingSettingsMain,
+      subPanel: defaultSpacingSettingsSubpanel,
+      presets: {
+        reflowOrder: defaultSpacingPresetsOrder,
+        webPubOrder: defaultSpacingPresetsOrder,
+        keys: defaultSpacingPresets
+      }
+    }
+  }
+});
+
+// src/preferences/ThPreferencesContext.ts
+var ThPreferencesContext = createContext(null);
+var defaultPreferencesContextValue = {
+  preferences: defaultPreferences,
+  updatePreferences: () => {
+    throw new Error("updatePreferences must be used within a ThPreferencesProvider with an adapter");
+  }
+};
+
+// src/preferences/adapters/ThMemoryPreferencesAdapter.ts
+var ThMemoryPreferencesAdapter = class {
+  currentPreferences;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(initialPreferences) {
+    this.currentPreferences = { ...initialPreferences };
+  }
+  getPreferences() {
+    return { ...this.currentPreferences };
+  }
+  setPreferences(prefs) {
+    this.currentPreferences = { ...prefs };
+    this.notifyListeners(this.currentPreferences);
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+  }
+  unsubscribe(listener) {
+    this.listeners.delete(listener);
+  }
+  notifyListeners(prefs) {
+    this.listeners.forEach((listener) => listener({ ...prefs }));
+  }
+};
+function ThPreferencesProvider({
+  adapter,
+  initialPreferences,
+  devMode,
+  children
+}) {
+  const effectiveAdapter = useMemo(() => {
+    let fallbackPreferences = defaultPreferencesContextValue.preferences;
+    if (devMode && !initialPreferences) {
+      fallbackPreferences = {
+        ...fallbackPreferences,
+        contentProtection: devContentProtectionConfig
+      };
+    }
+    return adapter || new ThMemoryPreferencesAdapter(
+      initialPreferences || fallbackPreferences
+    );
+  }, [adapter, initialPreferences, devMode]);
+  const [preferences, setPreferences] = useState(
+    (() => {
+      let fallbackPreferences = defaultPreferencesContextValue.preferences;
+      if (devMode && !initialPreferences) {
+        fallbackPreferences = {
+          ...fallbackPreferences,
+          contentProtection: devContentProtectionConfig
+        };
+      }
+      return initialPreferences || fallbackPreferences;
+    })()
+  );
+  const handlePreferenceChange = useCallback((newPrefs) => {
+    setPreferences((prev) => {
+      return JSON.stringify(prev) === JSON.stringify(newPrefs) ? prev : newPrefs;
+    });
+  }, []);
+  useEffect(() => {
+    effectiveAdapter.subscribe(handlePreferenceChange);
+    return () => {
+      effectiveAdapter.unsubscribe(handlePreferenceChange);
+    };
+  }, [effectiveAdapter, handlePreferenceChange]);
+  const contextValue = useMemo(() => ({
+    preferences,
+    updatePreferences: (newPrefs) => {
+      effectiveAdapter.setPreferences(newPrefs);
+    }
+  }), [preferences, effectiveAdapter]);
+  return /* @__PURE__ */ jsx(ThPreferencesContext.Provider, { value: contextValue, children });
+}
+var useActionsPreferences = () => {
+  const audioCtx = useContext(ThAudioPreferencesContext);
+  const readerCtx = useContext(ThPreferencesContext);
+  const audioPrimaryKeys = audioCtx?.preferences.actions.primary.keys;
+  const audioSecondaryKeys = audioCtx?.preferences.actions.secondary.keys;
+  const audioDocking = audioCtx?.preferences.docking;
+  const audioActionsKeys = useMemo(() => {
+    if (!audioPrimaryKeys && !audioSecondaryKeys) return null;
+    return { ...audioPrimaryKeys, ...audioSecondaryKeys };
+  }, [audioPrimaryKeys, audioSecondaryKeys]);
+  const audioResult = useMemo(() => {
+    if (!audioCtx || !audioActionsKeys || !audioDocking) return null;
+    return { docking: audioDocking, actionsKeys: audioActionsKeys };
+  }, [audioCtx, audioDocking, audioActionsKeys]);
+  const readerResult = useMemo(() => {
+    if (!readerCtx) return null;
+    return {
+      docking: readerCtx.preferences.docking,
+      actionsKeys: readerCtx.preferences.actions.keys
+    };
+  }, [readerCtx]);
+  if (audioResult) return audioResult;
+  if (readerResult) return readerResult;
+  throw new Error("useActionsPreferences must be used within a ThPreferencesProvider or ThAudioPreferencesProvider");
+};
+var useAudioActionsPreferences = () => {
+  const audioCtx = useContext(ThAudioPreferencesContext);
+  if (!audioCtx) {
+    throw new Error("useAudioActionsPreferences must be used within a ThAudioPreferencesProvider");
+  }
+  return {
+    docking: audioCtx.preferences.docking,
+    primaryActionsKeys: audioCtx.preferences.actions.primary.keys,
+    secondaryActionsKeys: audioCtx.preferences.actions.secondary.keys
+  };
+};
+function useAudioPreferences() {
+  const context = useContext(ThAudioPreferencesContext);
+  if (!context) {
+    throw new Error("useAudioPreferences must be used within a ThAudioPreferencesProvider");
+  }
+  return {
+    preferences: context.preferences,
+    updatePreferences: context.updatePreferences
+  };
+}
+
+// src/preferences/services/createBunnyFontResources.ts
+var buildBunnyFontsUrl = ({
+  family,
+  weights,
+  styles = ["normal"]
+}) => {
+  if (weights.type !== "static") {
+    throw new Error("Bunny Fonts only supports static fonts");
+  }
+  const weightValues = weights.values;
+  const variants = /* @__PURE__ */ new Set();
+  for (const weight of weightValues) {
+    variants.add(weight.toString());
+    if (styles.includes("italic")) {
+      variants.add(`${weight}i`);
+    }
+  }
+  const variantList = Array.from(variants).sort();
+  const familyParam = family.replace(/ /g, "-").toLowerCase();
+  const variantParam = variantList.join(",");
+  return `https://fonts.bunny.net/css?family=${familyParam}:${variantParam}`;
+};
+var createBunnyFontResources = (font) => {
+  if (font.source.type !== "custom" || font.source.provider !== "bunny" || font.spec.weights.type !== "static") {
+    return null;
+  }
+  const { family, weights, styles } = font.spec;
+  const url = buildBunnyFontsUrl({
+    family,
+    weights,
+    styles
+  });
+  return {
+    as: "link",
+    rel: "stylesheet",
+    url
+  };
+};
+
+// src/preferences/services/createGoogleFontResources.ts
+var buildGoogleFontsV2Url = ({
+  family,
+  weights,
+  styles = ["normal"],
+  widths,
+  display = "block",
+  text
+}) => {
+  if (text) {
+    return `https://fonts.googleapis.com/css2?family=${family.replace(/ /g, "+")}&text=${encodeURIComponent(text)}`;
+  }
+  const hasItalic = styles.includes("italic");
+  const hasWidth = !!widths;
+  const weightValues = weights.type === "static" ? weights.values.join(",") : `${weights.min}..${weights.max}`;
+  const widthValues = hasWidth && widths ? `${widths.min}..${widths.max}` : void 0;
+  const familyParam = family.replace(/ /g, "+");
+  let axesParam;
+  if (hasItalic && hasWidth) {
+    const variants = [
+      `0,${widthValues},${weightValues}`,
+      // normal
+      `1,${widthValues},${weightValues}`
+      // italic
+    ];
+    axesParam = `:ital,wdth,wght@${variants.join(";")}`;
+  } else if (hasItalic) {
+    const variants = [
+      `0,${weightValues}`,
+      // normal
+      `1,${weightValues}`
+      // italic
+    ];
+    axesParam = `:ital,wght@${variants.join(";")}`;
+  } else if (hasWidth) {
+    axesParam = `:wdth,wght@${widthValues},${weightValues}`;
+  } else {
+    axesParam = `:wght@${weightValues}`;
+  }
+  const displayParam = display ? `&display=${display}` : "";
+  return `https://fonts.googleapis.com/css2?family=${familyParam}${axesParam}${displayParam}`;
+};
+var createGoogleFontResources = (font, text) => {
+  if (font.source.type !== "custom" || font.source.provider !== "google") {
+    return null;
+  }
+  const { family, weights, display, styles, widths } = font.spec;
+  const url = buildGoogleFontsV2Url({
+    family,
+    weights,
+    display,
+    styles,
+    widths,
+    text
+  });
+  return {
+    as: "link",
+    rel: "stylesheet",
+    url
+  };
+};
+
+// src/preferences/services/createLocalFontResources.ts
+var getFontFormat = (path) => {
+  const ext = path.split(".").pop()?.toLowerCase();
+  switch (ext) {
+    case "woff":
+      return "woff";
+    case "woff2":
+      return "woff2";
+    case "ttf":
+      return "truetype";
+    case "otf":
+      return "opentype";
+    case "eot":
+      return "embedded-opentype";
+    case "svg":
+      return "svg";
+    default:
+      return "woff2";
+  }
+};
+var createLocalFontResources = (font) => {
+  if (font.source.type !== "custom" || font.source.provider !== "local") {
+    return null;
+  }
+  const { family, weights, display, widths } = font.spec;
+  const fontFiles = font.source.files || [];
+  const cssContent = fontFiles.map((fontFile) => {
+    const format = getFontFormat(fontFile.path);
+    const fontUrl = new URL(fontFile.path, window.location.origin).toString();
+    const isVariable = font.source.type === "custom" && font.source.provider === "local" && "variant" in font.source && font.source.variant === "variable";
+    const rules = [
+      `@font-face {`,
+      `  font-family: "${family}";`,
+      `  src: url("${fontUrl}") format("${format}");`
+    ];
+    if (isVariable && weights.type === "variable") {
+      rules.push(`  font-weight: ${weights.min} ${weights.max};`);
+    } else if ("weight" in fontFile) {
+      rules.push(`  font-weight: ${fontFile.weight};`);
+    }
+    if ("style" in fontFile) {
+      rules.push(`  font-style: ${fontFile.style};`);
+    }
+    if (isVariable && widths) {
+      rules.push(`  font-stretch: ${widths.min}% ${widths.max}%;`);
+    }
+    if (display) {
+      rules.push(`  font-display: ${display};`);
+    } else {
+      rules.push(`  font-display: block;`);
+    }
+    return rules.join("\n") + "\n}";
+  }).filter(Boolean).join("\n\n");
+  const blob = new Blob([cssContent], { type: "text/css" });
+  return {
+    as: "link",
+    rel: "stylesheet",
+    blob
+  };
+};
+
+// src/preferences/services/fonts.ts
+var createFontService = (fontFamilyPref) => {
+  const allSupportedLanguages = [];
+  const parsedFonts = /* @__PURE__ */ new Map();
+  const bunnyFonts = /* @__PURE__ */ new Map();
+  const googleFonts = /* @__PURE__ */ new Map();
+  const localFonts = /* @__PURE__ */ new Map();
+  const resolveFontLanguage = (bcp47Tag, scriptMode = "ltr") => {
+    if (!bcp47Tag) return "default";
+    if (allSupportedLanguages.includes(bcp47Tag)) {
+      return bcp47Tag;
+    }
+    const parts = bcp47Tag.split(/[-_]/);
+    const language = parts[0].toLowerCase();
+    const scriptOrRegion = parts[1]?.toLowerCase();
+    if (scriptOrRegion) {
+      const langScriptOrRegion = `${language}-${scriptOrRegion}`;
+      if (allSupportedLanguages.includes(langScriptOrRegion)) {
+        return langScriptOrRegion;
+      }
+    }
+    if (language === "ja" && !scriptOrRegion) {
+      if (scriptMode === "cjk-vertical" && allSupportedLanguages.includes("ja-v")) {
+        return "ja-v";
+      }
+      if (allSupportedLanguages.includes("ja")) {
+        return "ja";
+      }
+    }
+    const shouldFilter = language === "mn" && (scriptOrRegion === "mong" || scriptOrRegion === "cyrl") || language === "zh" && (scriptOrRegion === "hant" || scriptOrRegion === "tw" || scriptOrRegion === "hk");
+    if (!shouldFilter && allSupportedLanguages.includes(language)) {
+      return language;
+    }
+    return "default";
+  };
+  Object.entries(fontFamilyPref).forEach(([collectionName, collectionData]) => {
+    const fontCollection = "fonts" in collectionData ? collectionData.fonts : collectionData;
+    if ("supportedLanguages" in collectionData) {
+      const reducedLanguages = collectionData.supportedLanguages.map((lang) => {
+        const parts = lang.split(/[-_]/);
+        const language = parts[0].toLowerCase();
+        const scriptOrRegion = parts[1]?.toLowerCase();
+        return scriptOrRegion ? `${language}-${scriptOrRegion}` : language;
+      });
+      allSupportedLanguages.push(...reducedLanguages);
+    }
+    bunnyFonts.set(collectionName, []);
+    googleFonts.set(collectionName, []);
+    localFonts.set(collectionName, []);
+    const collectionBunnyFonts = bunnyFonts.get(collectionName);
+    const collectionGoogleFonts = googleFonts.get(collectionName);
+    const collectionLocalFonts = localFonts.get(collectionName);
+    Object.entries(fontCollection).forEach(([id, font]) => {
+      const fontFamily = font.spec.family;
+      let fontStack = fontFamily;
+      if (font.source.type === "custom") {
+        switch (font.source.provider) {
+          case "bunny":
+            collectionBunnyFonts.push(font);
+            break;
+          case "google":
+            collectionGoogleFonts.push(font);
+            break;
+          case "local":
+            collectionLocalFonts.push(font);
+            break;
+        }
+      }
+      const wrapIfNeeded = (name) => {
+        const trimmed = name.trim();
+        if (!trimmed) return "";
+        if (trimmed.includes(" ") && !/^['"].*['"]$/.test(trimmed)) {
+          return `"${trimmed}"`;
+        }
+        return trimmed;
+      };
+      const wrappedFontFamily = wrapIfNeeded(fontFamily);
+      if (font.spec.fallbacks?.length) {
+        const uniqueFallbacks = [...new Set(
+          font.spec.fallbacks.filter((fallback) => fallback.toLowerCase() !== fontFamily.toLowerCase()).map(wrapIfNeeded)
+        )];
+        if (uniqueFallbacks.length > 0) {
+          fontStack = [wrappedFontFamily, ...uniqueFallbacks].join(", ");
+        }
+      }
+      parsedFonts.set(id, {
+        fontStack: fontStack || wrappedFontFamily,
+        fontFamily: wrappedFontFamily,
+        weights: font.spec.weights || null,
+        widths: font.spec.widths || null
+      });
+    });
+  });
+  const defaultBunnyFonts = bunnyFonts.get("default") || [];
+  const defaultGoogleFonts = googleFonts.get("default") || [];
+  const defaultLocalFonts = localFonts.get("default") || [];
+  const processFonts = (bunnyFontsList, googleFontsList, localFontsList, optimize = false) => {
+    const result = {
+      allowedDomains: [],
+      prepend: [],
+      append: []
+    };
+    const bunnyResources = bunnyFontsList.map((font) => createBunnyFontResources(font)).filter((resource) => resource !== null);
+    if (bunnyResources.length > 0) {
+      result.allowedDomains.push(
+        "https://fonts.bunny.net"
+      );
+      result.prepend.push(
+        {
+          as: "link",
+          rel: "preconnect",
+          url: "https://fonts.bunny.net"
+        }
+      );
+      result.append.push(...bunnyResources);
+    }
+    const googleResources = googleFontsList.map((font) => createGoogleFontResources(font, optimize ? font.name : void 0)).filter((resource) => resource !== null);
+    if (googleResources.length > 0) {
+      result.allowedDomains.push(
+        "https://fonts.googleapis.com",
+        "https://fonts.gstatic.com"
+      );
+      result.prepend.push(
+        {
+          as: "link",
+          rel: "preconnect",
+          url: "https://fonts.googleapis.com"
+        },
+        {
+          as: "link",
+          rel: "preconnect",
+          url: "https://fonts.gstatic.com",
+          attributes: { crossOrigin: "anonymous" }
+        }
+      );
+      result.append.push(...googleResources);
+    }
+    const localResources = localFontsList.map(createLocalFontResources).filter((resource) => resource !== null);
+    if (localResources.length > 0) {
+      result.allowedDomains.push(window.location.origin);
+      result.append.push(...localResources);
+    }
+    return result.append.length > 0 ? result : null;
+  };
+  const getInjectables = (options, optimize = false) => {
+    if (options && "key" in options) {
+      const { key } = options;
+      if (!key || !(key in fontFamilyPref)) {
+        return null;
+      }
+      return processFonts(bunnyFonts.get(key) || [], googleFonts.get(key) || [], localFonts.get(key) || [], optimize);
+    }
+    if (options && "language" in options) {
+      const { language: publicationLanguage } = options;
+      for (const [collectionName, collectionData] of Object.entries(fontFamilyPref)) {
+        if (collectionName === "default") continue;
+        const supportedLangs = "supportedLanguages" in collectionData ? collectionData.supportedLanguages : null;
+        if (supportedLangs && Array.isArray(supportedLangs) && publicationLanguage && supportedLangs.includes(publicationLanguage)) {
+          return processFonts(bunnyFonts.get(collectionName) || [], googleFonts.get(collectionName) || [], localFonts.get(collectionName) || [], optimize);
+        }
+      }
+    }
+    return processFonts(defaultBunnyFonts, defaultGoogleFonts, defaultLocalFonts, optimize);
+  };
+  const getFontMetadata = (fontId) => {
+    const parsed = parsedFonts.get(fontId);
+    return parsed || { fontStack: null, fontFamily: null, weights: null, widths: null };
+  };
+  const getFontCollection = (options) => {
+    if (options && "key" in options) {
+      const { key } = options;
+      if (!key || !(key in fontFamilyPref)) {
+        return fontFamilyPref.default;
+      }
+      if (key === "default") {
+        return fontFamilyPref.default;
+      }
+      const prefRecord = fontFamilyPref;
+      const collection = prefRecord[key];
+      if (collection && "fonts" in collection) {
+        return collection.fonts;
+      }
+      return fontFamilyPref.default;
+    }
+    if (options && "language" in options) {
+      const { language: publicationLanguage } = options;
+      for (const [collectionName, collectionData] of Object.entries(fontFamilyPref)) {
+        if (collectionName === "default") continue;
+        const collection = "fonts" in collectionData ? collectionData : { fonts: collectionData };
+        const supportedLangs = "supportedLanguages" in collection ? collection.supportedLanguages : null;
+        if (supportedLangs?.includes(publicationLanguage)) {
+          return collection.fonts;
+        }
+      }
+      return fontFamilyPref.default;
+    }
+    return fontFamilyPref.default;
+  };
+  return {
+    getInjectables,
+    getFontMetadata,
+    getFontCollection,
+    resolveFontLanguage
+  };
+};
+
+// src/preferences/hooks/usePreferences.ts
+function usePreferences() {
+  const context = useContext(ThPreferencesContext);
+  if (!context) {
+    throw new Error("usePreferences must be used within a ThPreferencesProvider");
+  }
+  const fontService = createFontService(context.preferences.settings.keys.fontFamily);
+  return {
+    preferences: context.preferences,
+    updatePreferences: context.updatePreferences,
+    getFontInjectables: (options, optimize) => {
+      return fontService.getInjectables(options, optimize);
+    },
+    getFontsList: (options) => {
+      return fontService.getFontCollection(options);
+    },
+    getFontMetadata: (fontId) => {
+      return fontService.getFontMetadata(fontId);
+    },
+    resolveFontLanguage: (bcp47Tag, scriptMode) => {
+      return fontService.resolveFontLanguage(bcp47Tag, scriptMode);
+    }
+  };
+}
+
+// src/preferences/hooks/usePreferenceKeys.ts
+var usePreferenceKeys = () => {
+  const { preferences } = usePreferences();
+  const reflowActionKeys = preferences.actions.reflowOrder;
+  const fxlActionKeys = preferences.actions.fxlOrder;
+  const webPubActionKeys = preferences.actions.webPubOrder;
+  const reflowThemeKeys = preferences.theming.themes.reflowOrder;
+  const fxlThemeKeys = preferences.theming.themes.fxlOrder;
+  const reflowSettingsKeys = preferences.settings.reflowOrder;
+  const fxlSettingsKeys = preferences.settings.fxlOrder;
+  const webPubSettingsKeys = preferences.settings.webPubOrder;
+  const mainTextSettingsKeys = preferences.settings.text?.main ?? defaultTextSettingsMain;
+  const subPanelTextSettingsKeys = preferences.settings.text?.subPanel ?? defaultTextSettingsSubpanel;
+  const mainSpacingSettingsKeys = preferences.settings.spacing?.main ?? defaultSpacingSettingsMain;
+  const subPanelSpacingSettingsKeys = preferences.settings.spacing?.subPanel ?? defaultSpacingSettingsSubpanel;
+  const reflowSpacingPresetKeys = preferences.settings.spacing?.presets?.reflowOrder ?? defaultSpacingPresetsOrder;
+  const fxlSpacingPresetKeys = [];
+  const webPubSpacingPresetKeys = preferences.settings.spacing?.presets?.webPubOrder ?? defaultSpacingPresetsOrder;
+  return {
+    reflowActionKeys,
+    fxlActionKeys,
+    webPubActionKeys,
+    reflowThemeKeys,
+    fxlThemeKeys,
+    reflowSettingsKeys,
+    fxlSettingsKeys,
+    webPubSettingsKeys,
+    mainTextSettingsKeys,
+    subPanelTextSettingsKeys,
+    mainSpacingSettingsKeys,
+    subPanelSpacingSettingsKeys,
+    reflowSpacingPresetKeys,
+    fxlSpacingPresetKeys,
+    webPubSpacingPresetKeys
+  };
+};
+var EXCLUDED_CJK = [
+  "textAlign" /* textAlign */,
+  "hyphens" /* hyphens */,
+  "ligatures" /* ligatures */,
+  "paragraphIndent" /* paragraphIndent */,
+  "wordSpacing" /* wordSpacing */,
+  "textNormalize" /* textNormalize */
+];
+var EXCLUDED_BY_SCRIPT_MODE = {
+  "ltr": [
+    "noRuby" /* noRuby */
+  ],
+  "rtl": [
+    "hyphens" /* hyphens */,
+    "letterSpacing" /* letterSpacing */,
+    "textNormalize" /* textNormalize */,
+    "noRuby" /* noRuby */
+  ],
+  "cjk-horizontal": EXCLUDED_CJK,
+  "cjk-vertical": [...EXCLUDED_CJK, "layout" /* layout */],
+  "mongolian-vertical": [...EXCLUDED_CJK, "layout" /* layout */]
+};
+var useFilteredPreferenceKeys = () => {
+  const keys = usePreferenceKeys();
+  const scriptMode = useAppSelector((state) => state.publication.scriptMode);
+  const isFXL = useAppSelector((state) => state.publication.isFXL);
+  return useMemo(() => {
+    const excluded = [
+      ...EXCLUDED_BY_SCRIPT_MODE[scriptMode] ?? [],
+      ...(scriptMode === "cjk-vertical" || scriptMode === "mongolian-vertical") && !isFXL ? ["columns" /* columns */] : []
+    ];
+    if (excluded.length === 0) return keys;
+    const filter = (arr) => arr.filter((k) => !excluded.includes(k));
+    return {
+      ...keys,
+      reflowSettingsKeys: filter(keys.reflowSettingsKeys),
+      fxlSettingsKeys: filter(keys.fxlSettingsKeys),
+      webPubSettingsKeys: filter(keys.webPubSettingsKeys),
+      mainTextSettingsKeys: filter(keys.mainTextSettingsKeys),
+      subPanelTextSettingsKeys: filter(keys.subPanelTextSettingsKeys),
+      mainSpacingSettingsKeys: filter(keys.mainSpacingSettingsKeys),
+      subPanelSpacingSettingsKeys: filter(keys.subPanelSpacingSettingsKeys)
+    };
+  }, [keys, scriptMode, isFXL]);
+};
+
+// src/core/Helpers/prefixString.ts
+var PREFIXES = {
+  short: "th",
+  full: "thorium_web"
+};
+var prefixString = (str, variant = "short") => {
+  return `${PREFIXES[variant]}-${str}`;
+};
+
+// node_modules/.pnpm/colorthief@3.3.1_sharp@0.34.5/node_modules/colorthief/dist/index.js
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function srgbToLinear(c) {
+  const s = c / 255;
+  return s <= 0.04045 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+}
+function linearToSrgb(c) {
+  const s = c <= 31308e-7 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+  return Math.round(Math.max(0, Math.min(255, s * 255)));
+}
+function rgbToOklch(r, g, b) {
+  const lr = srgbToLinear(r);
+  const lg = srgbToLinear(g);
+  const lb = srgbToLinear(b);
+  const l_ = 0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb;
+  const m_ = 0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb;
+  const s_ = 0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb;
+  const l3 = Math.cbrt(l_);
+  const m3 = Math.cbrt(m_);
+  const s3 = Math.cbrt(s_);
+  const L = 0.2104542553 * l3 + 0.793617785 * m3 - 0.0040720468 * s3;
+  const a = 1.9779984951 * l3 - 2.428592205 * m3 + 0.4505937099 * s3;
+  const bLab = 0.0259040371 * l3 + 0.7827717662 * m3 - 0.808675766 * s3;
+  const C = Math.sqrt(a * a + bLab * bLab);
+  let H = Math.atan2(bLab, a) * (180 / Math.PI);
+  if (H < 0) H += 360;
+  return { l: L, c: C, h: H };
+}
+function oklchToRgb(l, c, h) {
+  const hRad = h * (Math.PI / 180);
+  const a = c * Math.cos(hRad);
+  const bLab = c * Math.sin(hRad);
+  const l3 = l + 0.3963377774 * a + 0.2158037573 * bLab;
+  const m3 = l - 0.1055613458 * a - 0.0638541728 * bLab;
+  const s3 = l - 0.0894841775 * a - 1.291485548 * bLab;
+  const l_ = l3 * l3 * l3;
+  const m_ = m3 * m3 * m3;
+  const s_ = s3 * s3 * s3;
+  const lr = 4.0767416621 * l_ - 3.3077115913 * m_ + 0.2309699292 * s_;
+  const lg = -1.2684380046 * l_ + 2.6097574011 * m_ - 0.3413193965 * s_;
+  const lb = -0.0041960863 * l_ - 0.7034186147 * m_ + 1.707614701 * s_;
+  return [linearToSrgb(lr), linearToSrgb(lg), linearToSrgb(lb)];
+}
+function pixelsRgbToOklchScaled(pixels) {
+  const out = new Array(pixels.length);
+  for (let i = 0; i < pixels.length; i++) {
+    const [r, g, b] = pixels[i];
+    const { l, c, h } = rgbToOklch(r, g, b);
+    out[i] = [
+      Math.round(l * 255),
+      Math.round(c / 0.4 * 255),
+      Math.round(h / 360 * 255)
+    ];
+  }
+  return out;
+}
+function paletteOklchScaledToRgb(colors) {
+  return colors.map(({ color: [ls, cs, hs], population }) => {
+    const l = ls / 255;
+    const c = cs / 255 * 0.4;
+    const h = hs / 255 * 360;
+    return { color: oklchToRgb(l, c, h), population };
+  });
+}
+var init_color_space = __esm({
+  "src/color-space.ts"() {
+  }
+});
+function rgbToHsl(r, g, b) {
+  const r1 = r / 255;
+  const g1 = g / 255;
+  const b1 = b / 255;
+  const max = Math.max(r1, g1, b1);
+  const min = Math.min(r1, g1, b1);
+  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);
+    if (max === r1) {
+      h = ((g1 - b1) / d + (g1 < b1 ? 6 : 0)) / 6;
+    } else if (max === g1) {
+      h = ((b1 - r1) / d + 2) / 6;
+    } else {
+      h = ((r1 - g1) / d + 4) / 6;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function relativeLuminance(r, g, b) {
+  const toLinear = (c) => {
+    const s = c / 255;
+    return s <= 0.04045 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  };
+  return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+}
+function contrastRatio(l1, l2) {
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function createColor(r, g, b, population, proportion = 0) {
+  return new ColorImpl(r, g, b, population, proportion);
+}
+var ColorImpl;
+var init_color = __esm({
+  "src/color.ts"() {
+    init_color_space();
+    ColorImpl = class {
+      constructor(r, g, b, population, proportion) {
+        this._r = r;
+        this._g = g;
+        this._b = b;
+        this.population = population;
+        this.proportion = proportion;
+      }
+      rgb() {
+        return { r: this._r, g: this._g, b: this._b };
+      }
+      hex() {
+        const toHex = (n) => n.toString(16).padStart(2, "0");
+        return `#${toHex(this._r)}${toHex(this._g)}${toHex(this._b)}`;
+      }
+      hsl() {
+        if (!this._hsl) {
+          this._hsl = rgbToHsl(this._r, this._g, this._b);
+        }
+        return this._hsl;
+      }
+      oklch() {
+        if (!this._oklch) {
+          this._oklch = rgbToOklch(this._r, this._g, this._b);
+        }
+        return this._oklch;
+      }
+      css(format = "rgb") {
+        switch (format) {
+          case "hsl": {
+            const { h, s, l } = this.hsl();
+            return `hsl(${h}, ${s}%, ${l}%)`;
+          }
+          case "oklch": {
+            const { l, c, h } = this.oklch();
+            return `oklch(${l.toFixed(3)} ${c.toFixed(3)} ${h.toFixed(1)})`;
+          }
+          case "rgb":
+          default:
+            return `rgb(${this._r}, ${this._g}, ${this._b})`;
+        }
+      }
+      array() {
+        return [this._r, this._g, this._b];
+      }
+      toString() {
+        return this.hex();
+      }
+      get textColor() {
+        return this.isDark ? "#ffffff" : "#000000";
+      }
+      get luminance() {
+        if (this._luminance === void 0) {
+          this._luminance = relativeLuminance(this._r, this._g, this._b);
+        }
+        return this._luminance;
+      }
+      get isDark() {
+        return this.luminance <= 0.179;
+      }
+      get isLight() {
+        return !this.isDark;
+      }
+      get contrast() {
+        if (!this._contrast) {
+          const lum = this.luminance;
+          const white = contrastRatio(lum, 1);
+          const black = contrastRatio(lum, 0);
+          const foreground = this.isDark ? createColor(255, 255, 255, 0, 0) : createColor(0, 0, 0, 0, 0);
+          this._contrast = {
+            white: Math.round(white * 100) / 100,
+            black: Math.round(black * 100) / 100,
+            foreground
+          };
+        }
+        return this._contrast;
+      }
+    };
+  }
+});
+var pipeline_exports = {};
+__export(pipeline_exports, {
+  computeFallbackColor: () => computeFallbackColor,
+  createPixelArray: () => createPixelArray,
+  extractPalette: () => extractPalette,
+  validateOptions: () => validateOptions
+});
+function validateOptions(options) {
+  let { colorCount, quality } = options;
+  if (typeof colorCount === "undefined" || !Number.isInteger(colorCount)) {
+    colorCount = 10;
+  } else if (colorCount === 1) {
+    throw new Error(
+      "colorCount should be between 2 and 20. To get one color, call getColor() instead of getPalette()"
+    );
+  } else {
+    colorCount = Math.max(colorCount, 2);
+    colorCount = Math.min(colorCount, 20);
+  }
+  if (typeof quality === "undefined" || !Number.isInteger(quality) || quality < 1) {
+    quality = 10;
+  }
+  const ignoreWhite = options.ignoreWhite !== void 0 ? !!options.ignoreWhite : true;
+  const whiteThreshold = typeof options.whiteThreshold === "number" ? options.whiteThreshold : 250;
+  const alphaThreshold = typeof options.alphaThreshold === "number" ? options.alphaThreshold : 125;
+  const minSaturation = typeof options.minSaturation === "number" ? Math.max(0, Math.min(1, options.minSaturation)) : 0;
+  const colorSpace = options.colorSpace ?? "oklch";
+  return {
+    colorCount,
+    quality,
+    ignoreWhite,
+    whiteThreshold,
+    alphaThreshold,
+    minSaturation,
+    colorSpace
+  };
+}
+function createPixelArray(data, pixelCount, quality, filterOptions) {
+  const {
+    ignoreWhite = true,
+    whiteThreshold = 250,
+    alphaThreshold = 125,
+    minSaturation = 0
+  } = filterOptions;
+  const pixelArray = [];
+  for (let i = 0; i < pixelCount; i += quality) {
+    const offset = i * 4;
+    const r = data[offset];
+    const g = data[offset + 1];
+    const b = data[offset + 2];
+    const a = data[offset + 3];
+    if (a !== void 0 && a < alphaThreshold) continue;
+    if (ignoreWhite && r > whiteThreshold && g > whiteThreshold && b > whiteThreshold)
+      continue;
+    if (minSaturation > 0) {
+      const max = Math.max(r, g, b);
+      if (max === 0 || (max - Math.min(r, g, b)) / max < minSaturation)
+        continue;
+    }
+    pixelArray.push([r, g, b]);
+  }
+  return pixelArray;
+}
+function computeFallbackColor(data, pixelCount, quality) {
+  let rTotal = 0;
+  let gTotal = 0;
+  let bTotal = 0;
+  let count = 0;
+  for (let i = 0; i < pixelCount; i += quality) {
+    const offset = i * 4;
+    rTotal += data[offset];
+    gTotal += data[offset + 1];
+    bTotal += data[offset + 2];
+    count++;
+  }
+  if (count === 0) return null;
+  return [
+    Math.round(rTotal / count),
+    Math.round(gTotal / count),
+    Math.round(bTotal / count)
+  ];
+}
+function extractPalette(data, width, height, opts, quantizer) {
+  const pixelCount = width * height;
+  const filterOptions = {
+    ignoreWhite: opts.ignoreWhite,
+    whiteThreshold: opts.whiteThreshold,
+    alphaThreshold: opts.alphaThreshold,
+    minSaturation: opts.minSaturation
+  };
+  let pixelArray = createPixelArray(data, pixelCount, opts.quality, filterOptions);
+  if (pixelArray.length === 0) {
+    pixelArray = createPixelArray(data, pixelCount, opts.quality, {
+      ...filterOptions,
+      ignoreWhite: false
+    });
+  }
+  if (pixelArray.length === 0) {
+    pixelArray = createPixelArray(data, pixelCount, opts.quality, {
+      ...filterOptions,
+      ignoreWhite: false,
+      alphaThreshold: 0
+    });
+  }
+  let quantized;
+  if (opts.colorSpace === "oklch") {
+    const scaled = pixelsRgbToOklchScaled(pixelArray);
+    quantized = paletteOklchScaledToRgb(
+      quantizer.quantize(scaled, opts.colorCount)
+    );
+  } else {
+    quantized = quantizer.quantize(pixelArray, opts.colorCount);
+  }
+  if (quantized.length > 0) {
+    const totalPopulation = quantized.reduce((sum, q) => sum + q.population, 0);
+    return quantized.map(
+      ({ color: [r, g, b], population }) => createColor(r, g, b, population, totalPopulation > 0 ? population / totalPopulation : 0)
+    );
+  }
+  const fallback = computeFallbackColor(data, pixelCount, opts.quality);
+  return fallback ? [createColor(fallback[0], fallback[1], fallback[2], 1, 1)] : null;
+}
+var init_pipeline = __esm({
+  "src/pipeline.ts"() {
+    init_color();
+    init_color_space();
+  }
+});
+var browser_exports = {};
+__export(browser_exports, {
+  BrowserPixelLoader: () => BrowserPixelLoader
+});
+var BrowserPixelLoader;
+var init_browser = __esm({
+  "src/loaders/browser.ts"() {
+    BrowserPixelLoader = class {
+      async load(source) {
+        if (typeof HTMLImageElement !== "undefined" && source instanceof HTMLImageElement) {
+          return this.loadFromImage(source);
+        }
+        if (typeof HTMLCanvasElement !== "undefined" && source instanceof HTMLCanvasElement) {
+          return this.loadFromCanvas(source);
+        }
+        if (typeof ImageData !== "undefined" && source instanceof ImageData) {
+          return {
+            data: source.data,
+            width: source.width,
+            height: source.height
+          };
+        }
+        if (typeof HTMLVideoElement !== "undefined" && source instanceof HTMLVideoElement) {
+          return this.loadFromVideo(source);
+        }
+        if (typeof ImageBitmap !== "undefined" && source instanceof ImageBitmap) {
+          return this.loadFromImageBitmap(source);
+        }
+        if (typeof OffscreenCanvas !== "undefined" && source instanceof OffscreenCanvas) {
+          return this.loadFromOffscreenCanvas(source);
+        }
+        throw new Error(
+          "Unsupported source type. Expected HTMLImageElement, HTMLCanvasElement, HTMLVideoElement, ImageData, ImageBitmap, or OffscreenCanvas."
+        );
+      }
+      loadFromImage(img) {
+        if (!img.complete) {
+          throw new Error(
+            'Image has not finished loading. Wait for the "load" event before calling getColor/getPalette.'
+          );
+        }
+        if (!img.naturalWidth) {
+          throw new Error(
+            "Image has no dimensions. It may not have loaded successfully."
+          );
+        }
+        const canvas = document.createElement("canvas");
+        const ctx = canvas.getContext("2d");
+        const width = canvas.width = img.naturalWidth;
+        const height = canvas.height = img.naturalHeight;
+        ctx.drawImage(img, 0, 0, width, height);
+        try {
+          const imageData = ctx.getImageData(0, 0, width, height);
+          return { data: imageData.data, width, height };
+        } catch (e) {
+          if (e instanceof DOMException && e.name === "SecurityError") {
+            const err = new Error(
+              'Image is tainted by cross-origin data. Add crossorigin="anonymous" to the <img> tag and ensure the server sends appropriate CORS headers.'
+            );
+            err.cause = e;
+            throw err;
+          }
+          throw e;
+        }
+      }
+      loadFromCanvas(canvas) {
+        const ctx = canvas.getContext("2d");
+        const { width, height } = canvas;
+        const imageData = ctx.getImageData(0, 0, width, height);
+        return { data: imageData.data, width, height };
+      }
+      loadFromVideo(video) {
+        if (video.readyState < 2) {
+          throw new Error(
+            'Video is not ready. Wait for the "loadeddata" or "canplay" event before calling getColor/getPalette.'
+          );
+        }
+        const width = video.videoWidth;
+        const height = video.videoHeight;
+        if (!width || !height) {
+          throw new Error(
+            "Video has no dimensions. It may not have loaded successfully."
+          );
+        }
+        const canvas = document.createElement("canvas");
+        const ctx = canvas.getContext("2d");
+        canvas.width = width;
+        canvas.height = height;
+        ctx.drawImage(video, 0, 0, width, height);
+        const imageData = ctx.getImageData(0, 0, width, height);
+        return { data: imageData.data, width, height };
+      }
+      loadFromOffscreenCanvas(canvas) {
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+          throw new Error(
+            "Could not get 2D context from OffscreenCanvas."
+          );
+        }
+        const { width, height } = canvas;
+        const imageData = ctx.getImageData(0, 0, width, height);
+        return { data: imageData.data, width, height };
+      }
+      loadFromImageBitmap(bitmap) {
+        const canvas = document.createElement("canvas");
+        const ctx = canvas.getContext("2d");
+        canvas.width = bitmap.width;
+        canvas.height = bitmap.height;
+        ctx.drawImage(bitmap, 0, 0);
+        const imageData = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
+        return { data: imageData.data, width: bitmap.width, height: bitmap.height };
+      }
+    };
+  }
+});
+var node_exports = {};
+__export(node_exports, {
+  NodePixelLoader: () => NodePixelLoader,
+  createNodeLoader: () => createNodeLoader
+});
+function createNodeLoader(options) {
+  return new NodePixelLoader(options);
+}
+var NodePixelLoader;
+var WORKER_SOURCE;
+var manager_exports = {};
+__export(manager_exports, {
+  extractInWorker: () => extractInWorker,
+  isWorkerSupported: () => isWorkerSupported,
+  terminateWorker: () => terminateWorker
+});
+function isWorkerSupported() {
+  return typeof Worker !== "undefined";
+}
+function getOrCreateWorker() {
+  if (worker) return worker;
+  if (!isWorkerSupported()) {
+    throw new Error("Web Workers are not supported in this environment.");
+  }
+  blobUrl = URL.createObjectURL(
+    new Blob([WORKER_SOURCE], { type: "application/javascript" })
+  );
+  worker = new Worker(blobUrl);
+  worker.onmessage = (e) => {
+    const { id, palette, error } = e.data;
+    const entry = pending.get(id);
+    if (!entry) return;
+    pending.delete(id);
+    if (error) {
+      entry.reject(new Error(error));
+    } else {
+      const raw = palette;
+      const totalPopulation = raw.reduce((sum, q) => sum + q.population, 0);
+      const colors = raw.map(({ color: [r, g, b], population }) => createColor(r, g, b, population, totalPopulation > 0 ? population / totalPopulation : 0));
+      entry.resolve(colors);
+    }
+  };
+  worker.onerror = (e) => {
+    for (const [, entry] of pending) {
+      entry.reject(new Error(e.message));
+    }
+    pending.clear();
+  };
+  return worker;
+}
+function extractInWorker(pixels, maxColors, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const id = nextId++;
+    pending.set(id, { resolve, reject });
+    const onAbort = () => {
+      pending.delete(id);
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      const w = getOrCreateWorker();
+      w.postMessage({ id, pixels, maxColors });
+    } catch (err) {
+      pending.delete(id);
+      signal?.removeEventListener("abort", onAbort);
+      reject(err);
+    }
+  });
+}
+function terminateWorker() {
+  if (worker) {
+    worker.terminate();
+    worker = null;
+  }
+  if (blobUrl) {
+    URL.revokeObjectURL(blobUrl);
+    blobUrl = null;
+  }
+  for (const [, entry] of pending) {
+    entry.reject(new Error("Worker terminated"));
+  }
+  pending.clear();
+}
+var worker;
+var blobUrl;
+var nextId;
+var pending;
+init_pipeline();
+init_pipeline();
+init_color();
+createColor(255, 255, 255, 0);
+createColor(0, 0, 0, 0);
+var SIGBITS = 5;
+var RSHIFT = 8 - SIGBITS;
+var MAX_ITERATIONS = 1e3;
+var FRACT_BY_POPULATIONS = 0.75;
+var HISTO_SIZE = 1 << 3 * SIGBITS;
+function getColorIndex(r, g, b) {
+  return (r << 2 * SIGBITS) + (g << SIGBITS) + b;
+}
+var VBox = class _VBox {
+  constructor(r1, r2, g1, g2, b1, b2, histo) {
+    this.r1 = r1;
+    this.r2 = r2;
+    this.g1 = g1;
+    this.g2 = g2;
+    this.b1 = b1;
+    this.b2 = b2;
+    this.histo = histo;
+  }
+  volume(force = false) {
+    if (this._volume === void 0 || force) {
+      this._volume = (this.r2 - this.r1 + 1) * (this.g2 - this.g1 + 1) * (this.b2 - this.b1 + 1);
+    }
+    return this._volume;
+  }
+  count(force = false) {
+    if (this._count === void 0 || force) {
+      let npix = 0;
+      for (let i = this.r1; i <= this.r2; i++) {
+        for (let j = this.g1; j <= this.g2; j++) {
+          for (let k = this.b1; k <= this.b2; k++) {
+            npix += this.histo[getColorIndex(i, j, k)] || 0;
+          }
+        }
+      }
+      this._count = npix;
+    }
+    return this._count;
+  }
+  copy() {
+    return new _VBox(this.r1, this.r2, this.g1, this.g2, this.b1, this.b2, this.histo);
+  }
+  avg(force = false) {
+    if (this._avg === void 0 || force) {
+      const mult = 1 << RSHIFT;
+      if (this.r1 === this.r2 && this.g1 === this.g2 && this.b1 === this.b2) {
+        this._avg = [
+          this.r1 << RSHIFT,
+          this.g1 << RSHIFT,
+          this.b1 << RSHIFT
+        ];
+      } else {
+        let ntot = 0;
+        let rsum = 0;
+        let gsum = 0;
+        let bsum = 0;
+        for (let i = this.r1; i <= this.r2; i++) {
+          for (let j = this.g1; j <= this.g2; j++) {
+            for (let k = this.b1; k <= this.b2; k++) {
+              const hval = this.histo[getColorIndex(i, j, k)] || 0;
+              ntot += hval;
+              rsum += hval * (i + 0.5) * mult;
+              gsum += hval * (j + 0.5) * mult;
+              bsum += hval * (k + 0.5) * mult;
+            }
+          }
+        }
+        if (ntot) {
+          this._avg = [
+            ~~(rsum / ntot),
+            ~~(gsum / ntot),
+            ~~(bsum / ntot)
+          ];
+        } else {
+          this._avg = [
+            ~~(mult * (this.r1 + this.r2 + 1) / 2),
+            ~~(mult * (this.g1 + this.g2 + 1) / 2),
+            ~~(mult * (this.b1 + this.b2 + 1) / 2)
+          ];
+        }
+      }
+    }
+    return this._avg;
+  }
+};
+var PQueue = class {
+  constructor(comparator) {
+    this.comparator = comparator;
+    this.contents = [];
+    this.sorted = false;
+  }
+  sort() {
+    this.contents.sort(this.comparator);
+    this.sorted = true;
+  }
+  push(item) {
+    this.contents.push(item);
+    this.sorted = false;
+  }
+  peek(index) {
+    if (!this.sorted) this.sort();
+    return this.contents[index ?? this.contents.length - 1];
+  }
+  pop() {
+    if (!this.sorted) this.sort();
+    return this.contents.pop();
+  }
+  size() {
+    return this.contents.length;
+  }
+  map(fn) {
+    return this.contents.map(fn);
+  }
+};
+function getHisto(pixels) {
+  const histo = new Uint32Array(HISTO_SIZE);
+  for (const pixel of pixels) {
+    const rval = pixel[0] >> RSHIFT;
+    const gval = pixel[1] >> RSHIFT;
+    const bval = pixel[2] >> RSHIFT;
+    histo[getColorIndex(rval, gval, bval)]++;
+  }
+  return histo;
+}
+function vboxFromPixels(pixels, histo) {
+  let rmin = 1e6;
+  let rmax = 0;
+  let gmin = 1e6;
+  let gmax = 0;
+  let bmin = 1e6;
+  let bmax = 0;
+  for (const pixel of pixels) {
+    const rval = pixel[0] >> RSHIFT;
+    const gval = pixel[1] >> RSHIFT;
+    const bval = pixel[2] >> RSHIFT;
+    if (rval < rmin) rmin = rval;
+    else if (rval > rmax) rmax = rval;
+    if (gval < gmin) gmin = gval;
+    else if (gval > gmax) gmax = gval;
+    if (bval < bmin) bmin = bval;
+    else if (bval > bmax) bmax = bval;
+  }
+  return new VBox(rmin, rmax, gmin, gmax, bmin, bmax, histo);
+}
+function medianCutApply(histo, vbox) {
+  if (!vbox.count()) return void 0;
+  if (vbox.count() === 1) return [vbox.copy(), null];
+  const rw = vbox.r2 - vbox.r1 + 1;
+  const gw = vbox.g2 - vbox.g1 + 1;
+  const bw = vbox.b2 - vbox.b1 + 1;
+  const maxw = Math.max(rw, gw, bw);
+  let total = 0;
+  const partialsum = [];
+  const lookaheadsum = [];
+  if (maxw === rw) {
+    for (let i = vbox.r1; i <= vbox.r2; i++) {
+      let sum = 0;
+      for (let j = vbox.g1; j <= vbox.g2; j++) {
+        for (let k = vbox.b1; k <= vbox.b2; k++) {
+          sum += histo[getColorIndex(i, j, k)] || 0;
+        }
+      }
+      total += sum;
+      partialsum[i] = total;
+    }
+  } else if (maxw === gw) {
+    for (let i = vbox.g1; i <= vbox.g2; i++) {
+      let sum = 0;
+      for (let j = vbox.r1; j <= vbox.r2; j++) {
+        for (let k = vbox.b1; k <= vbox.b2; k++) {
+          sum += histo[getColorIndex(j, i, k)] || 0;
+        }
+      }
+      total += sum;
+      partialsum[i] = total;
+    }
+  } else {
+    for (let i = vbox.b1; i <= vbox.b2; i++) {
+      let sum = 0;
+      for (let j = vbox.r1; j <= vbox.r2; j++) {
+        for (let k = vbox.g1; k <= vbox.g2; k++) {
+          sum += histo[getColorIndex(j, k, i)] || 0;
+        }
+      }
+      total += sum;
+      partialsum[i] = total;
+    }
+  }
+  partialsum.forEach((d, i) => {
+    lookaheadsum[i] = total - d;
+  });
+  function doCut(color) {
+    const dim1 = color + "1";
+    const dim2 = color + "2";
+    for (let i = vbox[dim1]; i <= vbox[dim2]; i++) {
+      if (partialsum[i] > total / 2) {
+        const vbox1 = vbox.copy();
+        const vbox2 = vbox.copy();
+        const left = i - vbox[dim1];
+        const right = vbox[dim2] - i;
+        let d2;
+        if (left <= right) {
+          d2 = Math.min(vbox[dim2] - 1, ~~(i + right / 2));
+        } else {
+          d2 = Math.max(vbox[dim1], ~~(i - 1 - left / 2));
+        }
+        while (!partialsum[d2]) d2++;
+        let count2 = lookaheadsum[d2];
+        while (!count2 && partialsum[d2 - 1]) count2 = lookaheadsum[--d2];
+        vbox1[dim2] = d2;
+        vbox2[dim1] = vbox1[dim2] + 1;
+        return [vbox1, vbox2];
+      }
+    }
+    return void 0;
+  }
+  if (maxw === rw) return doCut("r");
+  if (maxw === gw) return doCut("g");
+  return doCut("b");
+}
+function iterate(pq, target, histo) {
+  let ncolors = pq.size();
+  let niters = 0;
+  while (niters < MAX_ITERATIONS) {
+    if (ncolors >= target) return;
+    niters++;
+    const vbox = pq.pop();
+    if (!vbox.count()) {
+      pq.push(vbox);
+      continue;
+    }
+    const result = medianCutApply(histo, vbox);
+    if (!result || !result[0]) return;
+    pq.push(result[0]);
+    if (result[1]) {
+      pq.push(result[1]);
+      ncolors++;
+    }
+  }
+}
+function quantize(pixels, maxColors) {
+  if (!pixels.length || maxColors < 2 || maxColors > 256) return [];
+  const seenColors = /* @__PURE__ */ new Set();
+  const uniqueColors = [];
+  for (const color of pixels) {
+    const key = color.join(",");
+    if (!seenColors.has(key)) {
+      seenColors.add(key);
+      uniqueColors.push(color);
+    }
+  }
+  if (uniqueColors.length <= maxColors) {
+    const countMap = /* @__PURE__ */ new Map();
+    for (const color of pixels) {
+      const key = color.join(",");
+      countMap.set(key, (countMap.get(key) || 0) + 1);
+    }
+    return uniqueColors.map((color) => ({
+      color,
+      population: countMap.get(color.join(","))
+    }));
+  }
+  const histo = getHisto(pixels);
+  const vbox = vboxFromPixels(pixels, histo);
+  const pq = new PQueue((a, b) => a.count() - b.count());
+  pq.push(vbox);
+  iterate(pq, FRACT_BY_POPULATIONS * maxColors, histo);
+  const pq2 = new PQueue((a, b) => a.count() * a.volume() - b.count() * b.volume());
+  while (pq.size()) {
+    pq2.push(pq.pop());
+  }
+  iterate(pq2, maxColors, histo);
+  const results = [];
+  while (pq2.size()) {
+    const box = pq2.pop();
+    results.push({
+      color: box.avg(),
+      population: box.count()
+    });
+  }
+  return results;
+}
+var MmcqQuantizer = class {
+  async init() {
+  }
+  quantize(pixels, maxColors) {
+    return quantize(pixels, maxColors);
+  }
+};
+init_browser();
+init_pipeline();
+new BrowserPixelLoader();
+var defaultQuantizer = new MmcqQuantizer();
+function getColorSync(source, options) {
+  const palette = getPaletteSync(source, { colorCount: 5, ...options });
+  return palette ? palette[0] : null;
+}
+function getPaletteSync(source, options) {
+  const opts = validateOptions(options ?? {});
+  const quantizer = options?.quantizer ?? defaultQuantizer;
+  const pixels = loadPixelsSync(source);
+  return extractPalette(
+    pixels.data,
+    pixels.width,
+    pixels.height,
+    opts,
+    quantizer
+  );
+}
+function loadPixelsSync(source) {
+  if (typeof HTMLImageElement !== "undefined" && source instanceof HTMLImageElement) {
+    return loadFromImage(source);
+  }
+  if (typeof HTMLCanvasElement !== "undefined" && source instanceof HTMLCanvasElement) {
+    return loadFromCanvas(source);
+  }
+  if (typeof ImageData !== "undefined" && source instanceof ImageData) {
+    return { data: source.data, width: source.width, height: source.height };
+  }
+  if (typeof HTMLVideoElement !== "undefined" && source instanceof HTMLVideoElement) {
+    return loadFromVideo(source);
+  }
+  if (typeof ImageBitmap !== "undefined" && source instanceof ImageBitmap) {
+    return loadFromImageBitmap(source);
+  }
+  if (typeof OffscreenCanvas !== "undefined" && source instanceof OffscreenCanvas) {
+    return loadFromOffscreenCanvas(source);
+  }
+  throw new Error(
+    "Unsupported source type. Expected HTMLImageElement, HTMLCanvasElement, HTMLVideoElement, ImageData, ImageBitmap, or OffscreenCanvas."
+  );
+}
+function loadFromImage(img) {
+  if (!img.complete) {
+    throw new Error(
+      'Image has not finished loading. Wait for the "load" event before calling getColorSync/getPaletteSync.'
+    );
+  }
+  if (!img.naturalWidth) {
+    throw new Error(
+      "Image has no dimensions. It may not have loaded successfully."
+    );
+  }
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  const width = canvas.width = img.naturalWidth;
+  const height = canvas.height = img.naturalHeight;
+  ctx.drawImage(img, 0, 0, width, height);
+  try {
+    const imageData = ctx.getImageData(0, 0, width, height);
+    return { data: imageData.data, width, height };
+  } catch (e) {
+    if (e instanceof DOMException && e.name === "SecurityError") {
+      const err = new Error(
+        'Image is tainted by cross-origin data. Add crossorigin="anonymous" to the <img> tag and ensure the server sends appropriate CORS headers.'
+      );
+      err.cause = e;
+      throw err;
+    }
+    throw e;
+  }
+}
+function loadFromCanvas(canvas) {
+  const ctx = canvas.getContext("2d");
+  const { width, height } = canvas;
+  const imageData = ctx.getImageData(0, 0, width, height);
+  return { data: imageData.data, width, height };
+}
+function loadFromVideo(video) {
+  if (video.readyState < 2) {
+    throw new Error(
+      'Video is not ready. Wait for the "loadeddata" or "canplay" event before calling getColorSync/getPaletteSync.'
+    );
+  }
+  const width = video.videoWidth;
+  const height = video.videoHeight;
+  if (!width || !height) {
+    throw new Error(
+      "Video has no dimensions. It may not have loaded successfully."
+    );
+  }
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  canvas.width = width;
+  canvas.height = height;
+  ctx.drawImage(video, 0, 0, width, height);
+  const imageData = ctx.getImageData(0, 0, width, height);
+  return { data: imageData.data, width, height };
+}
+function loadFromOffscreenCanvas(canvas) {
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error(
+      "Could not get 2D context from OffscreenCanvas."
+    );
+  }
+  const { width, height } = canvas;
+  const imageData = ctx.getImageData(0, 0, width, height);
+  return { data: imageData.data, width, height };
+}
+function loadFromImageBitmap(bitmap) {
+  const canvas = document.createElement("canvas");
+  const ctx = canvas.getContext("2d");
+  canvas.width = bitmap.width;
+  canvas.height = bitmap.height;
+  ctx.drawImage(bitmap, 0, 0);
+  const imageData = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
+  return { data: imageData.data, width: bitmap.width, height: bitmap.height };
+}
+init_color();
+
+// src/preferences/helpers/getDominantColor.ts
+var getDominantColor = (img) => {
+  return new Promise((resolve, reject) => {
+    if (!img.complete || img.naturalWidth === 0) {
+      reject(new Error("Image not loaded"));
+      return;
+    }
+    try {
+      const color = getColorSync(img);
+      if (color) {
+        const hex = color.hex();
+        if (!/^#[0-9a-fA-F]{6}$/.test(hex)) {
+          reject(new Error(`Invalid color extracted: ${hex}`));
+        } else {
+          resolve(hex);
+        }
+      } else {
+        reject(new Error("No color extracted"));
+      }
+    } catch (error) {
+      reject(new Error(`Color extraction failed: ${error.message}`));
+    }
+  });
+};
+
+// src/preferences/helpers/themeGeneration.ts
+var hexToHsl = (hex) => {
+  const r = parseInt(hex.slice(1, 3), 16) / 255;
+  const g = parseInt(hex.slice(3, 5), 16) / 255;
+  const b = parseInt(hex.slice(5, 7), 16) / 255;
+  const max = Math.max(r, g, b), min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) return [0, 0, l];
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  const h = max === r ? ((g - b) / d + (g < b ? 6 : 0)) / 6 : max === g ? ((b - r) / d + 2) / 6 : ((r - g) / d + 4) / 6;
+  return [h, s, l];
+};
+var hslToHex = (h, s, l) => {
+  const a = s * Math.min(l, 1 - l);
+  const f = (n) => {
+    const k = (n + h * 12) % 12;
+    const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+    return Math.round(255 * color).toString(16).padStart(2, "0");
+  };
+  return `#${f(0)}${f(8)}${f(4)}`;
+};
+var luminance = (hex) => {
+  const toLinear = (c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  const r = toLinear(parseInt(hex.slice(1, 3), 16) / 255);
+  const g = toLinear(parseInt(hex.slice(3, 5), 16) / 255);
+  const b = toLinear(parseInt(hex.slice(5, 7), 16) / 255);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+};
+var contrastRatio2 = (a, b) => {
+  const l1 = luminance(a), l2 = luminance(b);
+  return (Math.max(l1, l2) + 0.05) / (Math.min(l1, l2) + 0.05);
+};
+var isLightColor = (hexColor) => luminance(hexColor) > 0.179;
+var shadeColor = (hex, isLight) => {
+  const [h, s] = hexToHsl(hex);
+  return isLight ? hslToHex(h, Math.min(s, 0.25), 0.93) : hslToHex(h, Math.min(s, 0.3), 0.13);
+};
+var generateThemeFromColor = (color) => {
+  const [h, s] = hexToHsl(color);
+  const isLight = isLightColor(color);
+  const background = shadeColor(color, isLight);
+  const text = contrastRatio2(background, "#ffffff") >= contrastRatio2(background, "#000000") ? "#ffffff" : "#000000";
+  const subdue = isLight ? hslToHex(h, Math.min(s, 0.15), 0.55) : hslToHex(h, Math.min(s, 0.15), 0.55);
+  const hover = isLight ? hslToHex(h, Math.min(s, 0.2), 0.83) : hslToHex(h, Math.min(s, 0.2), 0.22);
+  const elevate = `0px 0px 2px ${isLight ? hslToHex(h, 0.1, 0.7) : hslToHex(h, 0.1, 0.08)}`;
+  const link = isLight ? hslToHex(h, 0.7, 0.35) : hslToHex(h, 0.8, 0.72);
+  const visited = isLight ? hslToHex(h, 0.5, 0.28) : hslToHex(h, 0.55, 0.6);
+  const select = hslToHex(h, 0.6, isLight ? 0.8 : 0.35);
+  const focus = hslToHex(h, 0.9, isLight ? 0.4 : 0.65);
+  return {
+    background,
+    text,
+    link,
+    visited,
+    subdue,
+    disable: subdue,
+    hover,
+    onHover: text,
+    select,
+    onSelect: "inherit",
+    focus,
+    elevate,
+    immerse: isLight ? "0.6" : "0.4"
+  };
+};
+var extractThemeFromImage = async (imageUrl) => {
+  const img = new Image();
+  img.crossOrigin = "anonymous";
+  await new Promise((resolve, reject) => {
+    img.onload = () => {
+      if (img.naturalWidth === 0) {
+        reject(new Error("Image loaded but has no content (blocked or corrupt)"));
+      } else {
+        resolve();
+      }
+    };
+    img.onerror = () => reject(new Error(`Failed to load image: ${imageUrl}`));
+    img.src = imageUrl;
+  });
+  const dominantColor = await getDominantColor(img);
+  return generateThemeFromColor(dominantColor);
+};
+
+// src/helpers/proxyUrl.ts
+var proxyUrl = (url) => {
+  if (!url) return void 0;
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+      return `/api/proxy?url=${encodeURIComponent(url)}`;
+    }
+  } catch {
+  }
+  return url;
+};
+var initRanges = (prefs) => {
+  const ranges = {};
+  let prev = null;
+  Object.entries(prefs).forEach(([key, value]) => {
+    if (value && !isNaN(value)) {
+      const max = value;
+      const min = prev ? prev + 1 : null;
+      ranges[key] = { min, max };
+      prev = value;
+    } else if (!value && key === "xLarge" /* xLarge */ && prev) {
+      ranges[key] = { min: prev + 1, max: null };
+    }
+  });
+  return ranges;
+};
+var resolveBreakpoint = (width, ranges) => {
+  for (const [key, range] of Object.entries(ranges)) {
+    const { min, max } = range;
+    if (min !== null && width < min) continue;
+    if (max !== null && width > max) continue;
+    return key;
+  }
+  return null;
+};
+var useContainerBreakpoints = (map, onChange) => {
+  const [containerEl, setContainerEl] = useState(null);
+  useEffect(() => {
+    if (!containerEl) return;
+    const ranges = initRanges(map);
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      const width = entry.contentRect.width;
+      const breakpoint = resolveBreakpoint(width, ranges);
+      onChange?.(breakpoint);
+    });
+    observer.observe(containerEl);
+    return () => observer.disconnect();
+  }, [containerEl, map, onChange]);
+  return useCallback((el) => {
+    setContainerEl(el);
+  }, []);
+};
+
+// src/preferences/hooks/useTheming.ts
+var useTheming = ({
+  theme,
+  systemKeys,
+  themeKeys,
+  breakpointsMap,
+  initProps,
+  coverUrl,
+  autoThemeSource,
+  onBreakpointChange,
+  onColorSchemeChange,
+  onContrastChange,
+  onForcedColorsChange,
+  onMonochromeChange,
+  onReducedMotionChange,
+  onReducedTransparencyChange,
+  onCoverThemeGenerated,
+  onContainerBreakpointChange
+}) => {
+  const [coverThemeTokens, setCoverThemeTokens] = useState(null);
+  const [coverThemeFailed, setCoverThemeFailed] = useState(false);
+  const breakpoints = useBreakpoints(breakpointsMap, onBreakpointChange);
+  const setContainerRef = useContainerBreakpoints(breakpointsMap, onContainerBreakpointChange);
+  const colorScheme = useColorScheme(onColorSchemeChange);
+  const colorSchemeRef = useRef(colorScheme);
+  const contrast = useContrast(onContrastChange);
+  const forcedColors = useForcedColors(onForcedColorsChange);
+  const monochrome = useMonochrome(onMonochromeChange);
+  const reducedMotion = useReducedMotion(onReducedMotionChange);
+  const reducedTransparency = useReducedTransparency(onReducedTransparencyChange);
+  useEffect(() => {
+    if (autoThemeSource === "cover" && coverUrl && !coverThemeTokens) {
+      const extractTheme = async () => {
+        try {
+          const themeTokens = await extractThemeFromImage(proxyUrl(coverUrl) ?? coverUrl);
+          setCoverThemeTokens(themeTokens);
+          onCoverThemeGenerated?.(themeTokens);
+        } catch (error) {
+          console.warn("Failed to extract cover theme:", error);
+          setCoverThemeFailed(true);
+        }
+      };
+      extractTheme();
+    }
+  }, [autoThemeSource, coverUrl, coverThemeTokens, onCoverThemeGenerated]);
+  const updateThemeColorMetaTag = useCallback((color) => {
+    if (typeof document === "undefined") return;
+    let metaTag = document.querySelector("meta[name='theme-color']");
+    if (!metaTag) {
+      metaTag = document.createElement("meta");
+      metaTag.setAttribute("name", "theme-color");
+      document.head.appendChild(metaTag);
+    }
+    metaTag.setAttribute("content", color);
+  }, []);
+  const initThemingCustomProps = useCallback(() => {
+    for (let p in initProps) {
+      document.documentElement.style.setProperty(p, initProps[p]);
+    }
+  }, [initProps]);
+  const inferThemeAuto = useCallback(() => {
+    if (autoThemeSource === "cover") {
+      if (coverThemeTokens) return "cover";
+      if (!coverThemeFailed) return void 0;
+    }
+    return colorSchemeRef.current === "dark" /* dark */ ? systemKeys?.dark : systemKeys?.light;
+  }, [systemKeys, autoThemeSource, coverThemeTokens, coverThemeFailed]);
+  const setThemeCustomProps = useCallback((t) => {
+    if (!t) {
+      return;
+    }
+    if (t === "auto") {
+      const autoTheme = inferThemeAuto();
+      if (!autoTheme) {
+        return;
+      }
+      t = autoTheme;
+    }
+    let themeTokens;
+    if (t === "cover" && coverThemeTokens) {
+      themeTokens = coverThemeTokens;
+    } else {
+      themeTokens = themeKeys[t];
+    }
+    if (!themeTokens) {
+      return;
+    }
+    const props = propsToCSSVars(themeTokens, { prefix: prefixString("theme") });
+    for (let p in props) {
+      document.documentElement.style.setProperty(p, props[p]);
+    }
+    updateThemeColorMetaTag(themeTokens.background);
+  }, [inferThemeAuto, updateThemeColorMetaTag, themeKeys, coverThemeTokens]);
+  useEffect(() => {
+    initThemingCustomProps();
+  }, [initThemingCustomProps]);
+  useEffect(() => {
+    colorSchemeRef.current = colorScheme;
+    setThemeCustomProps(theme);
+  }, [setThemeCustomProps, theme, colorScheme]);
+  useEffect(() => {
+    if (!coverThemeTokens || theme !== "auto") return;
+    const props = propsToCSSVars(coverThemeTokens, { prefix: prefixString("theme") });
+    for (let p in props) {
+      document.documentElement.style.setProperty(p, props[p]);
+    }
+    updateThemeColorMetaTag(coverThemeTokens.background);
+  }, [coverThemeTokens, theme, updateThemeColorMetaTag]);
+  const themeResolved = autoThemeSource !== "cover" || !coverUrl || !!coverThemeTokens || coverThemeFailed;
+  return {
+    inferThemeAuto,
+    theme,
+    breakpoints,
+    colorScheme,
+    contrast,
+    forcedColors,
+    monochrome,
+    reducedMotion,
+    reducedTransparency,
+    coverThemeTokens,
+    themeResolved,
+    setContainerRef
+  };
+};
+var useSharedPreferences = () => {
+  const audioCtx = useContext(ThAudioPreferencesContext);
+  const readerCtx = useContext(ThPreferencesContext);
+  const ctx = audioCtx ?? readerCtx;
+  if (!ctx) throw new Error("useSharedPreferences must be used within a ThPreferencesProvider or ThAudioPreferencesProvider");
+  const prefs = ctx.preferences;
+  return {
+    shortcuts: prefs.shortcuts,
+    docking: prefs.docking,
+    theming: {
+      icon: prefs.theming.icon,
+      header: prefs.theming.header ? { backLink: prefs.theming.header.backLink } : void 0,
+      themes: {
+        systemThemes: prefs.theming.themes.systemThemes,
+        keys: prefs.theming.themes.keys,
+        audioOrder: audioCtx?.preferences.theming.themes.audioOrder,
+        reflowOrder: readerCtx?.preferences.theming.themes.reflowOrder,
+        fxlOrder: readerCtx?.preferences.theming.themes.fxlOrder
+      },
+      layout: {
+        defaults: prefs.theming.layout.defaults
+      },
+      breakpoints: prefs.theming.breakpoints
+    }
+  };
+};
+
+export { ThActionsKeys, ThAudioActionKeys, ThAudioAffordance, ThAudioKeys, ThAudioMemoryPreferencesAdapter, ThAudioPreferencesContext, ThAudioPreferencesProvider, ThDockingKeys, ThDockingTypes, ThGlobalMemoryPreferencesAdapter, ThGlobalPreferencesProvider, ThLayoutOptions, ThLineHeightOptions, ThMemoryPreferencesAdapter, ThPreferencesContext, ThPreferencesProvider, ThSettingsContainerKeys, ThSettingsKeys, ThSettingsRangePlaceholder, ThSettingsRangeVariant, ThSettingsTimerVariant, ThSheetHeaderVariant, ThSheetTypes, ThSpacingPresetKeys, ThSpacingSettingsKeys, ThTextAlignOptions, ThTextSettingsKeys, ThThemeKeys, arabicFarsiCollection, buildThemeObject, chineseSimplifiedCollection, chineseTraditionalCollection, contrast1Theme, contrast2Theme, contrast3Theme, createAudioPreferences, createDefinitionFromStaticFonts, createDefinitionsFromBunnyFonts, createDefinitionsFromGoogleFonts, createGlobalPreferences, createPreferences, darkTheme, defaultActionKeysObject, defaultAudioContentProtectionConfig, defaultAudioPlaybackRate, defaultAudioPlaybackRateAction, defaultAudioPreferences, defaultAudioPreferencesContextValue, defaultAudioRemotePlaybackAction, defaultAudioSkipBackwardInterval, defaultAudioSkipForwardInterval, defaultAudioSkipInterval, defaultAudioSleepTimer, defaultAudioSleepTimerAction, defaultAudioSleepTimerPresetList, defaultAudioTocAction, defaultAudioVolume, defaultAudioVolumeAction, defaultContentProtectionConfig, defaultFontCollection, defaultFullscreenAction, defaultJumpToPositionAction, defaultLetterSpacing, defaultLineHeights, defaultParagraphIndent, defaultParagraphSpacing, defaultPreferences, defaultPreferencesContextValue, defaultSettingsAction, defaultSpacingPresets, defaultSpacingPresetsOrder, defaultSpacingSettingsMain, defaultSpacingSettingsSubpanel, defaultTextSettingsMain, defaultTextSettingsSubpanel, defaultTocAction, defaultWordSpacing, defaultZoom, devContentProtectionConfig, hebrewCollection, japaneseCollection, japaneseVerticalCollection, koreanCollection, lightTheme, paperTheme, prefixString, proxyUrl, readiumCSSFontCollection, resolveAudioContentProtectionConfig, resolveContentProtectionConfig, sepiaTheme, tamilCollection, useActionsPreferences, useAudioActionsPreferences, useAudioPreferences, useFilteredPreferenceKeys, usePreferenceKeys, usePreferences, useSharedPreferences, useTheming, validateObjectKeys };
+//# sourceMappingURL=chunk-OD75GC5N.mjs.map
+//# sourceMappingURL=chunk-OD75GC5N.mjs.map