@edrlab/thorium-web 1.1.7 → 1.2.0

package/dist/chunk-34MVY33F.mjs

@@ -0,0 +1,913 @@
+import { ThPluginRegistry, createDefaultPlugin, ThPluginProvider, useSpacingPresets, useFonts, useSettingsComponentStatus, usePositionStorage, useLineHeight, Peripherals, NavigatorProvider, thorium_web_reader_app_default, StatefulDockingWrapper, getReaderClassNames, StatefulReaderHeader, StatefulReaderFooter, useReaderTransitions, thorium_web_button_default } from './chunk-H4J2VY7Z.mjs';
+import { makeBreakpointsMap, isActiveElement } from './chunk-47AIIJFO.mjs';
+import { useFullscreen, useEpubNavigator, useTimeline, useDocumentTitle, useEpubSettingsCache } from './chunk-4VHEHMJN.mjs';
+import { useAppSelector, useAppDispatch, setImmersive, setFullscreen, setTimeline, setHovering, toggleImmersive, setPublicationStart, setPublicationEnd, useAppStore, toggleActionOpen, setScrollAffordance, debounce, setDirection, setPlatformModifier, setUserNavigated, setTheme, setHasArrows, setLoading } from './chunk-K3K7TUWM.mjs';
+import { usePreferenceKeys, usePreferences, resolveContentProtectionConfig, buildThemeObject } from './chunk-7NEQAW7J.mjs';
+import { ThArrowVariant } from './chunk-XVSFXHYB.mjs';
+import { getPlatformModifier } from './chunk-5LUMM7FW.mjs';
+import { ThNavigationButton } from './chunk-NYZBHYW2.mjs';
+import { usePrevious } from './chunk-YZ73DHRU.mjs';
+import { useI18n } from './chunk-IYAFKTPL.mjs';
+import { useState, useLayoutEffect, useRef, useEffect, useCallback, useMemo } from 'react';
+import { I18nProvider } from 'react-aria';
+import { Layout, Locator } from '@readium/shared';
+import classNames2 from 'classnames';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+
+// src/components/assets/styles/thorium-web.reader.paginatedArrow.module.css
+var thorium_web_reader_paginatedArrow_default = {
+  container: "thorium_web_reader_paginatedArrow_container",
+  leftContainer: "thorium_web_reader_paginatedArrow_leftContainer",
+  rightContainer: "thorium_web_reader_paginatedArrow_rightContainer",
+  occupiesSpace: "thorium_web_reader_paginatedArrow_occupiesSpace",
+  visuallyHidden: "thorium_web_reader_paginatedArrow_visuallyHidden"
+};
+var usePaginatedArrows = () => {
+  const { preferences } = usePreferences();
+  const hasArrows = useAppSelector((state) => state.reader.hasArrows);
+  const isFXL = useAppSelector((state) => state.publication.isFXL);
+  const breakpoint = useAppSelector((state) => state.theming.breakpoint);
+  const {
+    isScroll,
+    fromImmersive,
+    toImmersive,
+    fromFullscreen,
+    toFullscreen,
+    fromScroll,
+    toUserNavigation
+  } = useReaderTransitions();
+  const dispatch = useAppDispatch();
+  const prefs = useMemo(
+    () => isFXL ? preferences.affordances.paginated.fxl : preferences.affordances.paginated.reflow,
+    [isFXL, preferences.affordances.paginated.fxl, preferences.affordances.paginated.reflow]
+  );
+  const prefsMap = useMemo(
+    () => makeBreakpointsMap({
+      defaultValue: prefs.default,
+      fromEnum: ThArrowVariant,
+      pref: prefs.breakpoints,
+      validateKey: "variant"
+    }),
+    [prefs.default, prefs.breakpoints]
+  );
+  const { variant, discard, hint } = useMemo(() => {
+    const result = prefsMap[breakpoint] || prefs.default;
+    if (isFXL) {
+      return {
+        ...result,
+        variant: "layered" /* layered */
+      };
+    }
+    return result;
+  }, [breakpoint, prefsMap, isFXL, prefs.default]);
+  const prevVariant = usePrevious(variant);
+  const prevDiscard = usePrevious(discard);
+  useEffect(() => {
+    if (!prevDiscard?.includes("navigation") && discard?.includes("navigation")) {
+      dispatch(setUserNavigated(false));
+      return;
+    }
+    if (discard === "none" && prevDiscard !== "none") {
+      dispatch(setHasArrows(true));
+      dispatch(setUserNavigated(false));
+      return;
+    }
+    if (prevVariant === "none" /* none */ && variant !== "none" /* none */) {
+      dispatch(setHasArrows(true));
+      dispatch(setUserNavigated(false));
+      return;
+    }
+    const shouldHide = discard?.includes("immersive") && toImmersive || discard?.includes("fullscreen") && toFullscreen || discard?.includes("navigation") && toUserNavigation;
+    const shouldShow = hint?.includes("immersiveChange") && fromImmersive || hint?.includes("fullscreenChange") && fromFullscreen || hint?.includes("layoutChange") && fromScroll;
+    if (shouldHide) {
+      dispatch(setHasArrows(false));
+      if (discard?.includes("navigation") && toUserNavigation) {
+        dispatch(setUserNavigated(false));
+      }
+    } else if (shouldShow) {
+      dispatch(setHasArrows(true));
+    }
+  }, [toImmersive, toFullscreen, toUserNavigation, fromImmersive, fromFullscreen, fromScroll, discard, hint, prevVariant, variant, prevDiscard, dispatch]);
+  if (variant === "none" /* none */ || isScroll) {
+    return {
+      isVisible: false,
+      occupySpace: false,
+      shouldTrackNavigation: false,
+      supportsVariant: !isFXL
+    };
+  }
+  return {
+    isVisible: hasArrows,
+    occupySpace: variant === "stacked" /* stacked */,
+    shouldTrackNavigation: Array.isArray(discard) && discard.includes("navigation"),
+    supportsVariant: !isFXL
+  };
+};
+var StatefulReaderArrowButton = ({
+  direction,
+  className,
+  isDisabled,
+  onPress,
+  ...props
+}) => {
+  const { preferences } = usePreferences();
+  const { t } = useI18n();
+  const buttonRef = useRef(null);
+  const isRTL = useAppSelector((state) => state.publication.isRTL);
+  const hasArrows = useAppSelector((state) => state.reader.hasArrows);
+  const {
+    isVisible,
+    occupySpace
+  } = usePaginatedArrows();
+  const [isHovering, setIsHovering] = useState(false);
+  const label = direction === "right" && !isRTL || direction === "left" && isRTL ? t("reader.actions.goForward") : t("reader.actions.goBackward");
+  const handleClassNameFromState = () => {
+    let className2 = "";
+    if (!isVisible) {
+      className2 = thorium_web_reader_paginatedArrow_default.visuallyHidden;
+    }
+    return className2;
+  };
+  const handleClassNameFromSpaceProp = () => {
+    let className2 = "";
+    if (occupySpace) {
+      className2 = thorium_web_reader_paginatedArrow_default.occupiesSpace;
+    }
+    return className2;
+  };
+  useEffect(() => {
+    if ((isDisabled || !hasArrows && !isHovering) && isActiveElement(buttonRef.current)) {
+      buttonRef.current.blur();
+    }
+  });
+  const blurOnEsc = (event) => {
+    if (isActiveElement(buttonRef.current) && event.code === "Escape") {
+      buttonRef.current.blur();
+    }
+  };
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(
+    ThNavigationButton,
+    {
+      direction,
+      ref: buttonRef,
+      "aria-label": label,
+      onPress,
+      onHoverChange: (isHovering2) => setIsHovering(isHovering2),
+      onKeyDown: blurOnEsc,
+      className: classNames2(className, handleClassNameFromSpaceProp(), handleClassNameFromState()),
+      isDisabled,
+      preventFocusOnPress: true,
+      ...props,
+      compounds: {
+        tooltipTrigger: {
+          delay: preferences.theming.arrow.tooltipDelay,
+          closeDelay: preferences.theming.arrow.tooltipDelay
+        },
+        tooltip: {
+          placement: direction === "left" ? "right" : "left",
+          className: thorium_web_button_default.tooltip
+        },
+        label
+      }
+    }
+  ) });
+};
+var useEpubStatelessCache = (textAlign, columnCount, fontFamily, fontSize, fontWeight, hyphens, letterSpacing, lineLength, lineHeight, paragraphIndent, paragraphSpacing, publisherStyles, scroll, textNormalization, wordSpacing, theme, positionsList, colorScheme, reducedMotion, layoutUI, isImmersive, isHovering, arrowsOccupySpace) => {
+  const settingsCache = useEpubSettingsCache(
+    textAlign,
+    columnCount,
+    fontFamily,
+    fontSize,
+    fontWeight,
+    hyphens,
+    letterSpacing,
+    lineLength,
+    lineHeight,
+    paragraphIndent,
+    paragraphSpacing,
+    publisherStyles,
+    scroll,
+    textNormalization,
+    wordSpacing,
+    theme
+  );
+  const cache = useRef({
+    layoutUI,
+    isImmersive,
+    isHovering,
+    arrowsOccupySpace: arrowsOccupySpace || false,
+    settings: settingsCache.current.settings,
+    positionsList,
+    colorScheme,
+    reducedMotion
+  });
+  const memoizedCache = useMemo(() => ({
+    layoutUI,
+    isImmersive,
+    isHovering,
+    arrowsOccupySpace: arrowsOccupySpace || false,
+    settings: settingsCache.current.settings,
+    positionsList,
+    colorScheme,
+    reducedMotion
+  }), [
+    layoutUI,
+    isImmersive,
+    isHovering,
+    arrowsOccupySpace,
+    settingsCache,
+    positionsList,
+    colorScheme,
+    reducedMotion
+  ]);
+  cache.current = memoizedCache;
+  return cache;
+};
+var useEpubPreferencesConfig = ({
+  isFXL,
+  settings,
+  colorScheme,
+  fontLanguage,
+  arrowsOccupySpace,
+  arrowsWidth,
+  preferences,
+  getFontMetadata,
+  lineHeightOptions,
+  fxlThemeKeys,
+  reflowThemeKeys
+}) => {
+  const epubPreferences = useMemo(() => {
+    if (isFXL) return {};
+    const initialConstraint = arrowsOccupySpace ? arrowsWidth.current : 0;
+    const themeKeys = isFXL ? fxlThemeKeys : reflowThemeKeys;
+    const theme = settings.theme && themeKeys.includes(settings.theme) ? settings.theme : "auto";
+    const themeProps = buildThemeObject({
+      theme,
+      themeKeys: preferences.theming.themes.keys,
+      systemThemes: preferences.theming.themes.systemThemes,
+      colorScheme
+    });
+    return {
+      columnCount: settings.columnCount === "auto" ? null : Number(settings.columnCount),
+      constraint: initialConstraint,
+      fontFamily: getFontMetadata(settings.fontFamily[fontLanguage] ?? "")?.fontStack || null,
+      fontSize: settings.fontSize,
+      fontWeight: settings.fontWeight,
+      hyphens: settings.hyphens,
+      letterSpacing: settings.publisherStyles ? void 0 : settings.letterSpacing,
+      lineHeight: settings.publisherStyles ? void 0 : settings.lineHeight === null ? null : lineHeightOptions[settings.lineHeight],
+      optimalLineLength: settings.lineLength?.optimal != null ? settings.lineLength.optimal : void 0,
+      maximalLineLength: settings.lineLength?.max?.isDisabled ? null : settings.lineLength?.max?.chars != null ? settings.lineLength.max.chars : void 0,
+      minimalLineLength: settings.lineLength?.min?.isDisabled ? null : settings.lineLength?.min?.chars != null ? settings.lineLength.min.chars : void 0,
+      paragraphIndent: settings.publisherStyles ? void 0 : settings.paragraphIndent,
+      paragraphSpacing: settings.publisherStyles ? void 0 : settings.paragraphSpacing,
+      scroll: settings.scroll,
+      textAlign: settings.textAlign,
+      textNormalization: settings.textNormalization,
+      wordSpacing: settings.publisherStyles ? void 0 : settings.wordSpacing,
+      ...themeProps
+    };
+  }, [
+    isFXL,
+    arrowsOccupySpace,
+    arrowsWidth,
+    settings,
+    colorScheme,
+    fontLanguage,
+    preferences.theming.themes.keys,
+    preferences.theming.themes.systemThemes,
+    getFontMetadata,
+    lineHeightOptions,
+    fxlThemeKeys,
+    reflowThemeKeys
+  ]);
+  const epubDefaults = useMemo(() => {
+    if (isFXL) return {};
+    return {
+      maximalLineLength: preferences.typography.maximalLineLength,
+      minimalLineLength: preferences.typography.minimalLineLength,
+      optimalLineLength: preferences.typography.optimalLineLength,
+      pageGutter: preferences.typography.pageGutter,
+      scrollPaddingTop: preferences.theming.layout.ui?.reflow === "layered-ui" /* layered */ ? (preferences.theming.icon.size || 24) * 3 : preferences.theming.icon.size || 24,
+      scrollPaddingBottom: preferences.theming.layout.ui?.reflow === "layered-ui" /* layered */ ? (preferences.theming.icon.size || 24) * 5 : preferences.theming.icon.size || 24,
+      scrollPaddingLeft: preferences.typography.pageGutter,
+      scrollPaddingRight: preferences.typography.pageGutter,
+      experiments: preferences.experiments?.reflow || null
+    };
+  }, [isFXL, preferences]);
+  return { epubPreferences, epubDefaults };
+};
+var useEpubInjectablesConfig = ({
+  isFXL,
+  isFontFamilyUsed,
+  fontLanguage,
+  getFontInjectables,
+  getAndroidFXLPatch
+}) => {
+  const injectables = useMemo(() => {
+    let injectablesConfig;
+    if (isFXL) {
+      const androidPatch = getAndroidFXLPatch();
+      if (androidPatch) {
+        injectablesConfig = {
+          allowedDomains: [window.location.origin],
+          rules: [{
+            resources: [/\.xhtml$/, /\.html$/],
+            prepend: [androidPatch]
+          }]
+        };
+      }
+    }
+    if (!isFXL && isFontFamilyUsed) {
+      const fontResources = getFontInjectables({ language: fontLanguage });
+      if (fontResources) {
+        injectablesConfig = {
+          allowedDomains: fontResources.allowedDomains,
+          rules: [{
+            resources: [/\.xhtml$/, /\.html$/],
+            prepend: fontResources.prepend,
+            append: fontResources.append
+          }]
+        };
+      }
+    }
+    return injectablesConfig;
+  }, [isFXL, isFontFamilyUsed, fontLanguage, getFontInjectables, getAndroidFXLPatch]);
+  return { injectables };
+};
+
+// src/components/Epub/Hooks/useReaderInit.ts
+var useEpubReaderInit = ({
+  container,
+  publication,
+  positionsList,
+  initialPosition,
+  listeners,
+  preferences,
+  cache,
+  isFontFamilyUsed,
+  fontLanguage,
+  getFontMetadata,
+  injectFontResources,
+  removeFontResources,
+  getAndroidFXLPatch,
+  getFontInjectables,
+  fxlThemeKeys,
+  reflowThemeKeys,
+  lineHeightOptions,
+  arrowsOccupySpace,
+  arrowsWidth,
+  colorScheme,
+  isFXL,
+  contentProtectionConfig,
+  onNavigatorReady,
+  onNavigatorLoaded,
+  onCleanup,
+  fxlProgressionCallback
+}) => {
+  const [navigatorReady, setNavigatorReady] = useState(false);
+  const { epubPreferences, epubDefaults } = useEpubPreferencesConfig({
+    isFXL,
+    settings: cache.current.settings,
+    colorScheme,
+    fontLanguage,
+    arrowsOccupySpace,
+    arrowsWidth,
+    preferences,
+    getFontMetadata,
+    lineHeightOptions,
+    fxlThemeKeys,
+    reflowThemeKeys
+  });
+  const { injectables } = useEpubInjectablesConfig({
+    isFXL,
+    isFontFamilyUsed,
+    fontLanguage,
+    getFontInjectables,
+    getAndroidFXLPatch
+  });
+  const handleCleanup = useCallback(() => {
+    if (!isFXL) removeFontResources();
+    onCleanup?.();
+  }, [isFXL, removeFontResources, onCleanup]);
+  const { EpubNavigatorLoad, EpubNavigatorDestroy } = useEpubNavigator();
+  const isNavigatorLoadedEpub = useRef(false);
+  useEffect(() => {
+    if (!publication || isNavigatorLoadedEpub.current) return;
+    if (!container.current) {
+      console.error("Container ref is not available for navigator initialization");
+      return;
+    }
+    const config = {
+      container: container.current,
+      publication,
+      listeners,
+      positionsList: positionsList?.map((loc) => new Locator(loc)) || [],
+      initialPosition: initialPosition ? new Locator(initialPosition) : void 0,
+      preferences: epubPreferences,
+      defaults: epubDefaults,
+      injectables: injectables || void 0,
+      contentProtection: contentProtectionConfig
+    };
+    isNavigatorLoadedEpub.current = true;
+    onNavigatorReady?.();
+    EpubNavigatorLoad(config, () => {
+      setNavigatorReady(true);
+      onNavigatorLoaded?.();
+    }, fxlProgressionCallback);
+    return () => {
+      if (isNavigatorLoadedEpub.current) {
+        setNavigatorReady(false);
+        EpubNavigatorDestroy(() => {
+          isNavigatorLoadedEpub.current = false;
+          handleCleanup();
+        });
+      }
+    };
+  }, []);
+  useEffect(() => {
+    if (!isFXL && isFontFamilyUsed) {
+      const fontResources = getFontInjectables({ language: fontLanguage });
+      if (fontResources) {
+        injectFontResources(fontResources);
+      }
+    }
+  }, [isFXL, isFontFamilyUsed, fontLanguage, injectFontResources, getFontInjectables]);
+  return {
+    navigatorReady,
+    isFXL
+  };
+};
+var StatefulReader = ({
+  publication,
+  localDataKey,
+  plugins,
+  positionStorage
+}) => {
+  const [pluginsRegistered, setPluginsRegistered] = useState(false);
+  useLayoutEffect(() => {
+    if (plugins && plugins.length > 0) {
+      plugins.forEach((plugin) => {
+        ThPluginRegistry.register(plugin);
+      });
+    } else {
+      ThPluginRegistry.register(createDefaultPlugin());
+    }
+    setPluginsRegistered(true);
+  }, [plugins]);
+  if (!pluginsRegistered) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(ThPluginProvider, { children: /* @__PURE__ */ jsx(StatefulReaderInner, { publication, localDataKey, positionStorage }) }) });
+};
+var StatefulReaderInner = ({ publication, localDataKey, positionStorage }) => {
+  const { fxlActionKeys, fxlThemeKeys, reflowActionKeys, reflowThemeKeys } = usePreferenceKeys();
+  const { preferences, getFontMetadata, getFontInjectables } = usePreferences();
+  const { t } = useI18n();
+  const { getEffectiveSpacingValue } = useSpacingPresets();
+  const { occupySpace: arrowsOccupySpace } = usePaginatedArrows();
+  const { injectFontResources, removeFontResources, getAndroidFXLPatch } = useFonts();
+  const container = useRef(null);
+  const arrowsWidth = useRef(2 * ((preferences.theming.arrow.size || 40) + (preferences.theming.arrow.offset || 0)));
+  const isFXL = useAppSelector((state) => state.publication.isFXL);
+  const positionsList = useAppSelector((state) => state.publication.positionsList);
+  const fontLanguage = useAppSelector((state) => state.publication.fontLanguage);
+  const { isComponentUsed: isFontFamilyUsed } = useSettingsComponentStatus({
+    settingsKey: "fontFamily" /* fontFamily */,
+    publicationType: isFXL ? "fxl" : "reflow",
+    componentType: "text"
+  });
+  const textAlign = useAppSelector((state) => state.settings.textAlign);
+  const columnCount = useAppSelector((state) => state.settings.columnCount);
+  const fontFamily = useAppSelector((state) => state.settings.fontFamily);
+  const fontSize = useAppSelector((state) => state.settings.fontSize);
+  const fontWeight = useAppSelector((state) => state.settings.fontWeight);
+  const hyphens = useAppSelector((state) => state.settings.hyphens);
+  const letterSpacing = getEffectiveSpacingValue("letterSpacing" /* letterSpacing */);
+  const lineLength = useAppSelector((state) => state.settings.lineLength);
+  const lineHeight = getEffectiveSpacingValue("lineHeight" /* lineHeight */);
+  const paragraphIndent = getEffectiveSpacingValue("paragraphIndent" /* paragraphIndent */);
+  const paragraphSpacing = getEffectiveSpacingValue("paragraphSpacing" /* paragraphSpacing */);
+  const publisherStyles = useAppSelector((state) => state.settings.publisherStyles);
+  const scroll = useAppSelector((state) => state.settings.scroll);
+  const isScroll = scroll && !isFXL;
+  const textNormalization = useAppSelector((state) => state.settings.textNormalization);
+  const wordSpacing = getEffectiveSpacingValue("wordSpacing" /* wordSpacing */);
+  const themeObject = useAppSelector((state) => state.theming.theme);
+  const theme = isFXL ? themeObject.fxl : themeObject.reflow;
+  const previousTheme = usePrevious(theme);
+  const colorScheme = useAppSelector((state) => state.theming.colorScheme);
+  const reducedMotion = useAppSelector((state) => state.theming.prefersReducedMotion);
+  const breakpoint = useAppSelector((state) => state.theming.breakpoint);
+  const isImmersive = useAppSelector((state) => state.reader.isImmersive);
+  const isHovering = useAppSelector((state) => state.reader.isHovering);
+  const layoutUI = isFXL ? preferences.theming.layout.ui?.fxl || "layered-ui" /* layered */ : isScroll ? preferences.theming.layout.ui?.reflow || "layered-ui" /* layered */ : "stacked-ui" /* stacked */;
+  const cache = useEpubStatelessCache(
+    textAlign,
+    columnCount,
+    fontFamily,
+    fontSize,
+    fontWeight,
+    hyphens,
+    letterSpacing,
+    lineLength,
+    lineHeight,
+    paragraphIndent,
+    paragraphSpacing,
+    publisherStyles,
+    isScroll,
+    textNormalization,
+    wordSpacing,
+    theme,
+    positionsList,
+    colorScheme,
+    reducedMotion,
+    layoutUI,
+    isImmersive,
+    isHovering,
+    arrowsOccupySpace
+  );
+  const atPublicationStart = useAppSelector((state) => state.publication.atPublicationStart);
+  const atPublicationEnd = useAppSelector((state) => state.publication.atPublicationEnd);
+  const dispatch = useAppDispatch();
+  useEffect(() => {
+    dispatch(setImmersive(false));
+  }, [isScroll, dispatch]);
+  const onFsChange = useCallback((isFullscreen) => {
+    dispatch(setFullscreen(isFullscreen));
+  }, [dispatch]);
+  const fs = useFullscreen(onFsChange);
+  const epubNavigator = useEpubNavigator();
+  const {
+    goLeft,
+    goRight,
+    goBackward,
+    goForward,
+    navLayout,
+    currentLocator,
+    currentPositions,
+    canGoBackward,
+    canGoForward,
+    isScrollStart,
+    isScrollEnd,
+    getCframes,
+    submitPreferences
+  } = epubNavigator;
+  const { setLocalData, getLocalData, localData } = usePositionStorage(localDataKey, positionStorage);
+  const timeline = useTimeline({
+    publication,
+    currentLocation: localData,
+    currentPositions: currentPositions() || [],
+    positionsList,
+    onChange: (timeline2) => {
+      dispatch(setTimeline(timeline2));
+    }
+  });
+  const lineHeightOptions = useLineHeight();
+  const documentTitleFormat = preferences.metadata?.documentTitle?.format;
+  let documentTitle;
+  if (documentTitleFormat) {
+    if (typeof documentTitleFormat === "object" && "key" in documentTitleFormat) {
+      const translatedTitle = t(documentTitleFormat.key);
+      documentTitle = translatedTitle !== documentTitleFormat.key ? translatedTitle : documentTitleFormat.fallback;
+    } else {
+      switch (documentTitleFormat) {
+        case "title" /* title */:
+          documentTitle = timeline?.title;
+          break;
+        case "chapter" /* chapter */:
+          documentTitle = timeline?.progression?.currentChapter;
+          break;
+        case "titleAndChapter" /* titleAndChapter */:
+          if (timeline?.title && timeline?.progression?.currentChapter) {
+            documentTitle = `${timeline.title} \u2013 ${timeline.progression.currentChapter}`;
+          }
+          break;
+        case "none" /* none */:
+          documentTitle = void 0;
+          break;
+        default:
+          documentTitle = documentTitleFormat;
+          break;
+      }
+    }
+  }
+  useDocumentTitle(documentTitle);
+  const activateImmersiveOnAction = useCallback(() => {
+    if (!cache.current.isImmersive) dispatch(setImmersive(true));
+  }, [cache, dispatch]);
+  const toggleIsImmersive = useCallback(() => {
+    dispatch(setHovering(false));
+    dispatch(toggleImmersive());
+  }, [dispatch]);
+  const handleTap = useCallback((event) => {
+    const _cframes = getCframes();
+    if (_cframes) {
+      if (!cache.current.settings.scroll) {
+        const oneQuarter = (_cframes.length === 2 ? _cframes[0].window.innerWidth + _cframes[1].window.innerWidth : _cframes[0].window.innerWidth) * window.devicePixelRatio / 4;
+        const navigationCallback = () => {
+          dispatch(setUserNavigated(true));
+          activateImmersiveOnAction();
+        };
+        if (event.x < oneQuarter) {
+          goLeft(!cache.current.reducedMotion, navigationCallback);
+        } else if (event.x > oneQuarter * 3) {
+          goRight(!cache.current.reducedMotion, navigationCallback);
+        } else if (oneQuarter <= event.x && event.x <= oneQuarter * 3) {
+          toggleIsImmersive();
+        }
+      } else {
+        if (preferences.affordances.scroll.toggleOnMiddlePointer.includes("tap")) {
+          toggleIsImmersive();
+        }
+      }
+    }
+  }, [getCframes, cache, preferences.affordances.scroll, goLeft, goRight, dispatch, activateImmersiveOnAction, toggleIsImmersive]);
+  const handleClick = useCallback((event) => {
+    if (cache.current.layoutUI === "layered-ui" /* layered */ && (!cache.current.settings.scroll || preferences.affordances.scroll.toggleOnMiddlePointer.includes("click"))) {
+      toggleIsImmersive();
+    }
+  }, [cache, preferences.affordances.scroll, toggleIsImmersive]);
+  const updatePublicationNavigationState = useCallback(() => {
+    if (canGoBackward()) {
+      dispatch(setPublicationStart(false));
+    } else {
+      dispatch(setPublicationStart(true));
+    }
+    if (canGoForward()) {
+      dispatch(setPublicationEnd(false));
+    } else {
+      dispatch(setPublicationEnd(true));
+    }
+  }, [canGoBackward, canGoForward, dispatch]);
+  const handleFXLProgression = useCallback((locator) => {
+    setLocalData(locator);
+    updatePublicationNavigationState();
+  }, [setLocalData, updatePublicationNavigationState]);
+  const initReadingEnv = useCallback(async () => {
+    if (navLayout() === Layout.fixed) {
+      const cLoc = currentLocator();
+      if (cLoc) {
+        handleFXLProgression(cLoc);
+      }
+    }
+  }, [navLayout, currentLocator, handleFXLProgression]);
+  const appStore = useAppStore();
+  const p = useMemo(() => new Peripherals(appStore, preferences.actions, {
+    moveTo: (direction) => {
+      const navigationCallback = () => {
+        dispatch(setUserNavigated(true));
+        activateImmersiveOnAction();
+      };
+      switch (direction) {
+        case "right":
+          if (!cache.current.settings.scroll) {
+            goRight(!cache.current.reducedMotion, navigationCallback);
+          }
+          break;
+        case "left":
+          if (!cache.current.settings.scroll) {
+            goLeft(!cache.current.reducedMotion, navigationCallback);
+          }
+          break;
+      }
+    },
+    goProgression: (shiftKey) => {
+      if (!cache.current.settings?.scroll) {
+        const callback = () => {
+          dispatch(setUserNavigated(true));
+          activateImmersiveOnAction();
+        };
+        shiftKey ? goBackward(!cache.current.reducedMotion, callback) : goForward(!cache.current.reducedMotion, callback);
+      }
+    },
+    toggleAction: (actionKey) => {
+      switch (actionKey) {
+        case "fullscreen" /* fullscreen */:
+          fs.handleFullscreen();
+          break;
+        case "settings" /* settings */:
+        case "toc" /* toc */:
+          dispatch(toggleActionOpen({
+            key: actionKey
+          }));
+          break;
+      }
+    }
+  }), [appStore, preferences.actions, dispatch, activateImmersiveOnAction, cache, goRight, goLeft, goBackward, goForward, fs]);
+  const listeners = useMemo(() => ({
+    frameLoaded: async function(_wnd) {
+      await initReadingEnv();
+      const _cframes = getCframes();
+      _cframes?.forEach(
+        (frameManager) => {
+          if (frameManager) p.observe(frameManager.window);
+        }
+      );
+      p.observe(window);
+    },
+    positionChanged: async function(locator) {
+      if (navLayout() !== Layout.fixed) {
+        const debouncedHandleProgression = debounce(
+          async () => {
+            setLocalData(locator);
+            updatePublicationNavigationState();
+          },
+          250
+        );
+        debouncedHandleProgression();
+      }
+    },
+    tap: function(_e) {
+      handleTap(_e);
+      return true;
+    },
+    click: function(_e) {
+      handleClick(_e);
+      return true;
+    },
+    zoom: function(_scale) {
+    },
+    miscPointer: function(_amount) {
+    },
+    scroll: function(_delta) {
+      if (cache.current.settings.scroll && navLayout() !== Layout.fixed) {
+        if (isScrollStart() || isScrollEnd()) {
+          if (
+            // Keep consistent with pagination behavior
+            cache.current.layoutUI === "layered-ui" /* layered */
+          ) {
+            dispatch(setScrollAffordance(true));
+          }
+        } else if (!cache.current.isImmersive && _delta > 20) {
+          if (preferences.affordances.scroll.hideOnForwardScroll) {
+            dispatch(setImmersive(true));
+          }
+        } else if (cache.current.isImmersive && _delta < -20) {
+          if (
+            // Keep consistent with pagination behavior
+            cache.current.layoutUI === "layered-ui" /* layered */ && preferences.affordances.scroll.showOnBackwardScroll
+          ) {
+            dispatch(setImmersive(false));
+          }
+        }
+      }
+    },
+    customEvent: function(_key, _data) {
+    },
+    handleLocator: function(locator) {
+      const href = locator.href;
+      if (href.startsWith("http://") || href.startsWith("https://") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+        if (confirm(`Open "${href}" ?`)) window.open(href, "_blank");
+      } else {
+        console.warn("Unhandled locator", locator);
+      }
+      return false;
+    },
+    textSelected: function(_selection) {
+    },
+    contentProtection: function(_type, _data) {
+    },
+    contextMenu: function(_data) {
+    },
+    peripheral: function(_data) {
+    }
+  }), [p, initReadingEnv, getCframes, navLayout, setLocalData, dispatch, handleTap, handleClick, cache, preferences.affordances.scroll, isScrollStart, isScrollEnd, updatePublicationNavigationState]);
+  const initialPosition = useMemo(() => getLocalData(), [getLocalData]);
+  const { navigatorReady } = useEpubReaderInit({
+    container,
+    publication,
+    positionsList,
+    initialPosition,
+    listeners,
+    preferences,
+    cache,
+    isFontFamilyUsed,
+    fontLanguage,
+    getFontMetadata,
+    injectFontResources,
+    removeFontResources,
+    getAndroidFXLPatch,
+    getFontInjectables,
+    fxlThemeKeys,
+    reflowThemeKeys,
+    lineHeightOptions,
+    arrowsOccupySpace,
+    arrowsWidth,
+    colorScheme,
+    isFXL,
+    contentProtectionConfig: resolveContentProtectionConfig(preferences.contentProtection, t),
+    onNavigatorReady: () => {
+      dispatch(setLoading(false));
+    },
+    onNavigatorLoaded: () => {
+      p.observe(window);
+    },
+    onCleanup: () => {
+      p.destroy();
+    },
+    fxlProgressionCallback: handleFXLProgression
+  });
+  const applyConstraint = useCallback(async (value) => {
+    await submitPreferences({
+      constraint: value
+    });
+  }, [submitPreferences]);
+  useLayoutEffect(() => {
+    if (!navigatorReady) return;
+    applyConstraint(arrowsOccupySpace ? arrowsWidth.current : 0).catch(console.error);
+  }, [arrowsOccupySpace, applyConstraint, navigatorReady]);
+  useLayoutEffect(() => {
+    if (!navigatorReady) return;
+    if (cache.current.colorScheme !== colorScheme) {
+      cache.current.colorScheme = colorScheme;
+    }
+    const theme2 = isFXL ? themeObject.fxl : themeObject.reflow;
+    if (theme2 !== "auto" && previousTheme !== theme2) return;
+    const applyCurrentTheme = async () => {
+      const themeKeys = isFXL ? fxlThemeKeys : reflowThemeKeys;
+      const themeKey = themeKeys.includes(theme2) ? theme2 : "auto";
+      const themeProps = buildThemeObject({
+        theme: themeKey,
+        themeKeys: preferences.theming.themes.keys,
+        systemThemes: preferences.theming.themes.systemThemes,
+        colorScheme
+      });
+      await submitPreferences(themeProps);
+      dispatch(setTheme({
+        key: isFXL ? "fxl" : "reflow",
+        value: themeKey
+      }));
+    };
+    applyCurrentTheme().catch(console.error);
+  }, [cache, themeObject, previousTheme, preferences.theming.themes, fxlThemeKeys, reflowThemeKeys, colorScheme, isFXL, submitPreferences, dispatch, navigatorReady]);
+  useLayoutEffect(() => {
+    preferences.direction && dispatch(setDirection(preferences.direction));
+    dispatch(setPlatformModifier(getPlatformModifier()));
+  }, [preferences.direction, dispatch]);
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(I18nProvider, { locale: preferences.locale, children: /* @__PURE__ */ jsx(NavigatorProvider, { navigator: epubNavigator, children: /* @__PURE__ */ jsx("main", { className: thorium_web_reader_app_default.main, children: /* @__PURE__ */ jsx(StatefulDockingWrapper, { children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: getReaderClassNames({
+        isScroll,
+        isImmersive,
+        isHovering,
+        isFXL,
+        layoutUI,
+        breakpoint
+      }),
+      children: [
+        /* @__PURE__ */ jsx(
+          StatefulReaderHeader,
+          {
+            actionKeys: isFXL ? fxlActionKeys : reflowActionKeys,
+            actionsOrder: isFXL ? preferences.actions.fxlOrder : preferences.actions.reflowOrder,
+            layout: layoutUI,
+            runningHeadFormatPref: isFXL ? preferences.theming.header?.runningHead?.format?.fxl : preferences.theming.header?.runningHead?.format?.reflow
+          }
+        ),
+        !isScroll ? /* @__PURE__ */ jsx("nav", { className: classNames2(thorium_web_reader_paginatedArrow_default.container, thorium_web_reader_paginatedArrow_default.leftContainer), children: /* @__PURE__ */ jsx(
+          StatefulReaderArrowButton,
+          {
+            direction: "left",
+            isDisabled: atPublicationStart,
+            onPress: () => {
+              const navigationCallback = () => {
+                dispatch(setUserNavigated(true));
+                activateImmersiveOnAction();
+              };
+              goLeft(!reducedMotion, navigationCallback);
+            }
+          }
+        ) }) : /* @__PURE__ */ jsx(Fragment, {}),
+        /* @__PURE__ */ jsx("article", { className: thorium_web_reader_app_default.wrapper, "aria-label": t("reader.app.publicationWrapper"), children: /* @__PURE__ */ jsx("div", { id: "thorium-web-container", className: thorium_web_reader_app_default.iframeContainer, ref: container }) }),
+        !isScroll ? /* @__PURE__ */ jsx("nav", { className: classNames2(thorium_web_reader_paginatedArrow_default.container, thorium_web_reader_paginatedArrow_default.rightContainer), children: /* @__PURE__ */ jsx(
+          StatefulReaderArrowButton,
+          {
+            direction: "right",
+            isDisabled: atPublicationEnd,
+            onPress: () => {
+              const navigationCallback = () => {
+                dispatch(setUserNavigated(true));
+                activateImmersiveOnAction();
+              };
+              goRight(!reducedMotion, navigationCallback);
+            }
+          }
+        ) }) : /* @__PURE__ */ jsx(Fragment, {}),
+        /* @__PURE__ */ jsx(
+          StatefulReaderFooter,
+          {
+            layout: layoutUI,
+            progressionFormatPref: isFXL ? preferences.theming.progression?.format?.fxl : preferences.theming.progression?.format?.reflow,
+            progressionFormatFallback: isFXL ? "readingOrderIndex" /* readingOrderIndex */ : "resourceProgression" /* resourceProgression */
+          }
+        )
+      ]
+    }
+  ) }) }) }) }) });
+};
+
+export { StatefulReader };
+//# sourceMappingURL=chunk-34MVY33F.mjs.map
+//# sourceMappingURL=chunk-34MVY33F.mjs.map