@edrlab/thorium-web 1.2.1 → 1.3.0

package/dist/{chunk-7NEQAW7J.mjs → chunk-C236BQQB.mjs}

@@ -1,11 +1,7 @@
-import { propsToCSSVars } from './chunk-XVSFXHYB.mjs';
-import { useBreakpoints, useForcedColors, useMonochrome, useReducedMotion, useReducedTransparency } from './chunk-GFSLVQIG.mjs';
-import { useColorScheme, useContrast } from './chunk-NQ2ZSGCX.mjs';
 import { isSupportedLocale, supportedLocales } from './chunk-B3WDMWCT.mjs';
 import fontStacks from '@readium/css/css/vars/fontStacks.json';
 import ReadiumCSSColors from '@readium/css/css/vars/colors.json';
-import { createContext, useMemo, useState, useCallback, useEffect, useContext, useRef } from 'react';
-import { jsx } from 'react/jsx-runtime';
+import { createContext, useContext } from 'react';
 
 // src/preferences/models/actions.ts
 var ThActionsKeys = /* @__PURE__ */ ((ThActionsKeys3) => {
@@ -30,6 +26,8 @@ var ThDockingTypes = /* @__PURE__ */ ((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";
@@ -108,123 +106,307 @@ var defaultJumpToPositionAction = {
   }
 };
 
-// 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
-    };
+// 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["lineHeight"] = "lineHeight";
+  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["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__ */ ((ThSpacingPresetKeys3) => {
+  ThSpacingPresetKeys3["publisher"] = "publisher";
+  ThSpacingPresetKeys3["tight"] = "tight";
+  ThSpacingPresetKeys3["balanced"] = "balanced";
+  ThSpacingPresetKeys3["loose"] = "loose";
+  ThSpacingPresetKeys3["accessible"] = "accessible";
+  ThSpacingPresetKeys3["custom"] = "custom";
+  return ThSpacingPresetKeys3;
+})(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 */
+];
+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
   }
-  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}`);
+// 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 */
     }
-    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");
-        }
-      });
+  },
+  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 */
     }
-    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;
+  },
+  docked: {
+    dockable: "both" /* both */,
+    dragIndicator: false,
+    width: 360,
+    minWidth: 320,
+    maxWidth: 450
   }
-  return result;
 };
 
 // src/preferences/helpers/fontPref/googleFonts.ts
-var DEFAULT_FALLBACK2 = "sans-serif";
+var DEFAULT_FALLBACK = "sans-serif";
 var DEFAULT_WIDTH_STEP = 20;
 var DEFAULT_WEIGHT_STEP = 20;
 var createDefinitionsFromGoogleFonts = (params) => {
@@ -322,7 +504,7 @@ var createDefinitionsFromGoogleFonts = (params) => {
         source: { type: "custom", provider: "google" },
         spec: {
           family: family.name,
-          fallbacks: fallbacks?.[fontId] || [DEFAULT_FALLBACK2],
+          fallbacks: fallbacks?.[fontId] || [DEFAULT_FALLBACK],
           weights: family.weights,
           styles: family.styles,
           ...family.widths && { widths: family.widths },
@@ -384,7 +566,31 @@ var createDefinitionFromStaticFonts = (params) => {
   };
 };
 
-// src/preferences/models/fonts.ts
+// 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)}` : ""}`
+      );
+    }
+  });
+};
 var readiumCSSFontCollection = {
   oldStyle: {
     id: "oldStyle",
@@ -532,16 +738,44 @@ var resolveContentProtectionConfig = (contentProtection, t) => {
     protectCopy: contentProtection.protectCopy,
     disableContextMenu: contentProtection.disableContextMenu,
     disableDragAndDrop: contentProtection.disableDragAndDrop,
-    protectPrinting: contentProtection.protectPrinting ? {
-      disable: contentProtection.protectPrinting.disable,
+    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,
@@ -554,187 +788,30 @@ var defaultContentProtectionConfig = {
   disableSave: false,
   monitorDevTools: false
 };
-var devContentProtectionConfig = {
+var defaultAudioContentProtectionConfig = {
   protectCopy: false,
   disableContextMenu: false,
   disableDragAndDrop: false,
   protectPrinting: {
-    disable: false
+    disable: false,
+    watermark: "reader.app.printingDisabled"
   },
   disableSelectAll: false,
   disableSave: false,
-  monitorDevTools: false
-};
-
-// 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["lineHeight"] = "lineHeight";
-  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["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";
-  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 */
-];
-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
+  monitorDevTools: false,
+  disableRemotePlayback: false
 };
-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.3,
-  ["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,
-    ["paragraphIndent" /* paragraphIndent */]: 1
-  },
-  ["balanced" /* balanced */]: {
-    ["lineHeight" /* lineHeight */]: "medium" /* medium */,
-    ["paragraphSpacing" /* paragraphSpacing */]: 0.75,
-    ["paragraphIndent" /* paragraphIndent */]: 0
-  },
-  ["loose" /* loose */]: {
-    ["lineHeight" /* lineHeight */]: "large" /* large */,
-    ["paragraphSpacing" /* paragraphSpacing */]: 1.75,
-    ["paragraphIndent" /* paragraphIndent */]: 0
-  },
-  ["accessible" /* accessible */]: {
-    ["lineHeight" /* lineHeight */]: "large" /* large */,
-    ["paragraphSpacing" /* paragraphSpacing */]: 2.5,
-    ["paragraphIndent" /* paragraphIndent */]: 0,
-    ["letterSpacing" /* letterSpacing */]: 0.1,
-    ["wordSpacing" /* wordSpacing */]: 0.3
-  }
+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";
@@ -865,6 +942,239 @@ var contrast3Theme = {
   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
+    dock: {},
+    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/preferences.ts
 var createPreferences = (params) => {
   if (params.locale) {
@@ -874,29 +1184,13 @@ var createPreferences = (params) => {
       params.locale = void 0;
     }
   }
-  const 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)) {
-        console.warn(`Key "${key}" in ${context} order arrays not found in ${context}.keys.${""}`);
-      }
-    });
-  };
   if (params.actions) {
     validateObjectKeys(
-      [params.actions.reflowOrder, params.actions.fxlOrder, params.actions.webPubOrder],
+      [
+        params.actions.reflowOrder,
+        params.actions.fxlOrder,
+        params.actions.webPubOrder
+      ],
       params.actions.keys,
       "actions"
     );
@@ -1004,6 +1298,25 @@ var createPreferences = (params) => {
       }
     });
   }
+  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;
 };
 
@@ -1165,8 +1478,12 @@ var defaultPreferences = createPreferences({
         // Max-width of all bottom sheets
         ["popover" /* popover */]: 600,
         // Max-width of all popover sheets
-        pagination: 1024
+        ["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: {
@@ -1367,8 +1684,6 @@ var defaultPreferences = createPreferences({
     }
   }
 });
-
-// src/preferences/ThPreferencesContext.ts
 var ThPreferencesContext = createContext(null);
 var defaultPreferencesContextValue = {
   preferences: defaultPreferences,
@@ -1376,611 +1691,35 @@ var defaultPreferencesContextValue = {
     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 }));
-  }
-};
-var ThDirectionSetter = ({
-  direction,
-  children
-}) => {
-  useEffect(() => {
-    if (direction) document.documentElement.dir = direction;
-  }, [direction]);
-  return children;
-};
-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: /* @__PURE__ */ jsx(ThDirectionSetter, { direction: preferences.direction, children }) });
-}
-
-// 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, direction = "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 (direction === "rtl" && 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, direction) => {
-      return fontService.resolveFontLanguage(bcp47Tag, direction);
-    }
-  };
-}
-
-// 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;
+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 {
-    reflowActionKeys,
-    fxlActionKeys,
-    webPubActionKeys,
-    reflowThemeKeys,
-    fxlThemeKeys,
-    reflowSettingsKeys,
-    fxlSettingsKeys,
-    webPubSettingsKeys,
-    mainTextSettingsKeys,
-    subPanelTextSettingsKeys,
-    mainSpacingSettingsKeys,
-    subPanelSpacingSettingsKeys,
-    reflowSpacingPresetKeys,
-    fxlSpacingPresetKeys,
-    webPubSpacingPresetKeys
-  };
-};
-
-// src/core/Helpers/prefixString.ts
-var PREFIXES = {
-  short: "th",
-  full: "thorium_web"
-};
-var prefixString = (str, variant = "short") => {
-  return `${PREFIXES[variant]}-${str}`;
-};
-
-// src/preferences/hooks/useTheming.ts
-var useTheming = ({
-  theme,
-  systemKeys,
-  themeKeys,
-  breakpointsMap,
-  initProps,
-  onBreakpointChange,
-  onColorSchemeChange,
-  onContrastChange,
-  onForcedColorsChange,
-  onMonochromeChange,
-  onReducedMotionChange,
-  onReducedTransparencyChange
-}) => {
-  const breakpoints = useBreakpoints(breakpointsMap, onBreakpointChange);
-  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);
-  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 inferThemeAuto = useCallback(() => {
-    return colorSchemeRef.current === "dark" /* dark */ ? systemKeys?.dark : systemKeys?.light;
-  }, [systemKeys]);
-  const initThemingCustomProps = useCallback(() => {
-    for (let p in initProps) {
-      document.documentElement.style.setProperty(p, initProps[p]);
-    }
-  }, [initProps]);
-  const setThemeCustomProps = useCallback((t) => {
-    if (!t) {
-      return;
-    }
-    if (t === "auto") {
-      const autoTheme = inferThemeAuto();
-      if (!autoTheme) {
-        return;
-      }
-      t = autoTheme;
-    }
-    const 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]);
+    direction: prefs.direction,
+    locale: prefs.locale,
+    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
     }
-    updateThemeColorMetaTag(themeTokens.background);
-  }, [inferThemeAuto, updateThemeColorMetaTag, themeKeys]);
-  useEffect(() => {
-    initThemingCustomProps();
-  }, [initThemingCustomProps]);
-  useEffect(() => {
-    colorSchemeRef.current = colorScheme;
-    setThemeCustomProps(theme);
-  }, [setThemeCustomProps, theme, colorScheme]);
-  return {
-    inferThemeAuto,
-    theme,
-    breakpoints,
-    colorScheme,
-    contrast,
-    forcedColors,
-    monochrome,
-    reducedMotion,
-    reducedTransparency
   };
 };
 
-export { ThActionsKeys, ThDockingKeys, ThDockingTypes, ThLayoutOptions, ThLineHeightOptions, ThMemoryPreferencesAdapter, ThPreferencesContext, ThPreferencesProvider, ThSettingsContainerKeys, ThSettingsKeys, ThSettingsRangePlaceholder, ThSettingsRangeVariant, ThSheetHeaderVariant, ThSheetTypes, ThSpacingPresetKeys, ThSpacingSettingsKeys, ThTextAlignOptions, ThTextSettingsKeys, ThThemeKeys, buildThemeObject, contrast1Theme, contrast2Theme, contrast3Theme, createDefinitionFromStaticFonts, createDefinitionsFromBunnyFonts, createDefinitionsFromGoogleFonts, createPreferences, darkTheme, defaultActionKeysObject, defaultContentProtectionConfig, defaultFontCollection, defaultFullscreenAction, defaultJumpToPositionAction, defaultLetterSpacing, defaultLineHeights, defaultParagraphIndent, defaultParagraphSpacing, defaultPreferences, defaultPreferencesContextValue, defaultSettingsAction, defaultSpacingPresets, defaultSpacingPresetsOrder, defaultSpacingSettingsMain, defaultSpacingSettingsSubpanel, defaultTextSettingsMain, defaultTextSettingsSubpanel, defaultTocAction, defaultWordSpacing, defaultZoom, devContentProtectionConfig, lightTheme, paperTheme, prefixString, readiumCSSFontCollection, resolveContentProtectionConfig, sepiaTheme, tamilCollection, usePreferenceKeys, usePreferences, useTheming };
-//# sourceMappingURL=chunk-7NEQAW7J.mjs.map
-//# sourceMappingURL=chunk-7NEQAW7J.mjs.map
+export { ThActionsKeys, ThAudioActionKeys, ThAudioAffordance, ThAudioKeys, ThAudioPreferencesContext, ThDockingKeys, ThDockingTypes, ThLayoutOptions, ThLineHeightOptions, ThPreferencesContext, ThSettingsContainerKeys, ThSettingsKeys, ThSettingsRangePlaceholder, ThSettingsRangeVariant, ThSettingsTimerVariant, ThSheetHeaderVariant, ThSheetTypes, ThSpacingPresetKeys, ThSpacingSettingsKeys, ThTextAlignOptions, ThTextSettingsKeys, ThThemeKeys, contrast1Theme, contrast2Theme, contrast3Theme, createAudioPreferences, createDefinitionFromStaticFonts, createDefinitionsFromGoogleFonts, 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, lightTheme, paperTheme, readiumCSSFontCollection, resolveAudioContentProtectionConfig, resolveContentProtectionConfig, sepiaTheme, tamilCollection, useSharedPreferences, validateObjectKeys };
+//# sourceMappingURL=chunk-C236BQQB.mjs.map
+//# sourceMappingURL=chunk-C236BQQB.mjs.map