@readium/navigator 2.10.3 → 2.11.1

package/types/src/divina/DivinaScrolledPresenter.d.ts

@@ -0,0 +1,125 @@
+import { VisualNavigatorViewport } from "../Navigator.ts";
+import { DivinaPageManager } from "./DivinaPageManager.ts";
+import { DivinaSpreader } from "./DivinaSpreader.ts";
+export type DivinaScrolledEventKey = "scroll" | "position" | "tap" | "click";
+export type DivinaScrolledListener = (key: DivinaScrolledEventKey, data: unknown) => void;
+/**
+ * Vertical scrolled ("webtoon") presenter for Divina publications: all pages
+ * stacked in a native scroll container with no gaps, constrained to a
+ * configurable strip width, based on xbreader but improved
+ *
+ * Page offsets are cached and looked up with binary search so per-frame
+ * scroll work stays constant regardless of publication size.
+ */
+export declare class DivinaScrolledPresenter {
+    private readonly container;
+    private readonly spreader;
+    private readonly pool;
+    readonly scrollerElement: HTMLDivElement;
+    private stripWidth;
+    private destroyed;
+    private scrollRAF;
+    private restoreRAF;
+    private positionTimer;
+    private lastScrollTop;
+    /** Position within the strip as a fraction of total strip height (resize retention) */
+    private fraction;
+    private pageTops;
+    private pageHeights;
+    private stripHeightCached;
+    private viewportHeightCached;
+    private loadedIndices;
+    private lastWindowIndex;
+    private programmaticScroll;
+    private programmaticTimer;
+    private scrollTarget;
+    private animating;
+    private animRAF;
+    private animLastTime;
+    listener: DivinaScrolledListener;
+    constructor(container: HTMLElement, spreader: DivinaSpreader, pool: Map<number, DivinaPageManager>, stripWidth: number);
+    private readonly bscrollHandler;
+    private readonly bscrollendHandler;
+    private readonly banimStep;
+    private readonly buserTakeoverHandler;
+    private readonly bmousedownHandler;
+    private readonly bclickHandler;
+    private readonly btouchendHandler;
+    private readonly btouchstartHandler;
+    /** Display width of each page in the strip */
+    private get displayWidth();
+    /**
+     * Recomputes the cached page offsets and viewport metrics.
+     * Cheap relative to the per-frame layout reads it replaces, but still a
+     * forced layout: only call after actual layout changes.
+     */
+    private refreshLayoutCache;
+    /** The index of the last page whose top is at or above the given strip offset */
+    private indexAtOffset;
+    applyStripWidth(stripWidth: number): void;
+    private restoreFraction;
+    private updateFraction;
+    /** Top offset in pixels of the given page within the strip */
+    private pageTop;
+    private pageHeight;
+    /**
+     * The reading-order index of the current page: the last page whose top
+     * is above the middle of the viewport.
+     */
+    get currentIndex(): number;
+    /** Progression within the current page (0..1) */
+    get currentPageProgression(): number;
+    /**
+     * Marks the start of a programmatic scroll: "scroll" events are not
+     * reported to the host until the scroll settles (scrollend or timeout),
+     * so navigation doesn't masquerade as user scrolling.
+     */
+    private beginProgrammaticScroll;
+    private scrollendHandler;
+    /** Load the window around wherever the scroll settled */
+    private settleWindow;
+    /** Direct user input takes over any in-flight programmatic scroll */
+    private userTakeoverHandler;
+    private scrollHandler;
+    /** Load nearby pages, unload distant ones */
+    private updateWindow;
+    private touchStartY;
+    private lastTouchEnd;
+    private touchstartHandler;
+    private touchendHandler;
+    private mouseDownPos;
+    private mousedownHandler;
+    private clickHandler;
+    private emitPointer;
+    /**
+     * Scroll forward/backward by a fraction of the viewport.
+     * Repeated calls chain from the pending target, so rapid key presses
+     * (including autorepeat from a held key) extend one animation that keeps
+     * cruising instead of restarting; the target is clamped to stay within
+     * reach of the position so releasing the key stops promptly rather than
+     * replaying the queued distance.
+     * @returns whether scrolling was possible
+     */
+    next(animated?: boolean, stepPx?: number): boolean;
+    prev(animated?: boolean, stepPx?: number): boolean;
+    private scrollToTarget;
+    /**
+     * One frame of the owned scroll animation: exponential approach toward
+     * the (re)targetable scrollTarget, capped at a cruise speed. Under a held
+     * key the cap dominates and the scroll advances at constant speed; once
+     * input stops the exponential term eases it out into the target.
+     */
+    private animStep;
+    private stopAnimation;
+    /**
+     * Go to the top of a page, optionally at a progression within it.
+     * @returns whether the position changed
+     */
+    goToItem(itemIndex: number, animated?: boolean, progression?: number): boolean;
+    update(): Promise<void>;
+    get atStart(): boolean;
+    get atEnd(): boolean;
+    get viewport(): VisualNavigatorViewport;
+    resizeHandler(): void;
+    destroy(): Promise<void>;
+}

package/types/src/divina/DivinaSpreader.d.ts

@@ -0,0 +1,65 @@
+import { Link, Page, Publication } from "@readium/shared";
+/**
+ * A single page of a Divina publication, with its resolved layout properties.
+ * Unlike FXLSpreader, this model never mutates the publication's links.
+ */
+export declare class DivinaPage {
+    readonly link: Link;
+    readonly index: number;
+    page: Page;
+    isLandscape: boolean;
+    addBlank: boolean;
+    constructor(link: Link, index: number);
+    /** 1-based page number */
+    get number(): number;
+    get authoredPage(): Page | undefined;
+    /** Whether this page occupies both slots of a spread in double-page mode */
+    get double(): boolean;
+}
+/**
+ * Computes synthetic spreads for a Divina publication from the `page`
+ * (left/right/center) link properties, falling back to computed alternation.
+ *
+ * Slot model (used by the paged presenter): in double-page mode every spread
+ * occupies exactly two slots — a pair is 1+1, and a lone page (center,
+ * landscape or orphaned/addBlank) takes a double-width slot. This keeps
+ * slide indices (always even) aligned with spread boundaries.
+ */
+export declare class DivinaSpreader {
+    readonly rtl: boolean;
+    shift: boolean;
+    pages: DivinaPage[];
+    spreads: DivinaPage[][];
+    private itemToSlotArr;
+    private slotToItemArr;
+    private spreadOfItemArr;
+    constructor(publication: Publication);
+    private index;
+    private testShift;
+    private buildSpreads;
+    /**
+     * Builds the item <-> slot mappings for double-page mode.
+     * Slots are consumed in spread order; every spread takes exactly two slots.
+     */
+    private buildSlots;
+    /** Total number of slots (spread mode). Always even. */
+    get slotCount(): number;
+    /** Count of pages that take a double-width slot in spread mode */
+    get nDouble(): number;
+    slotOfItem(itemIndex: number): number;
+    itemOfSlot(slot: number): number;
+    spreadIndexOfItem(itemIndex: number): number;
+    spreadOfItem(itemIndex: number): DivinaPage[];
+    /**
+     * Whether the page occupies a full spread on its own in double-page mode
+     * (and therefore takes a double-width slot). This mirrors buildSlots()
+     * exactly: any page alone in its spread is double.
+     */
+    isDouble(itemIndex: number): boolean;
+    findByHref(href: string): DivinaPage | undefined;
+    /**
+     * The position of a page within a spread, viewport-wise:
+     * left/right of the gutter, or centered when displayed alone.
+     */
+    spreadPosition(spread: DivinaPage[], target: DivinaPage, perPage: number): Page;
+}

package/types/src/divina/DivinaVariantSelector.d.ts

@@ -0,0 +1,30 @@
+import { Link } from "@readium/shared";
+/**
+ * User-selectable image quality for publications that provide alternate
+ * resolutions of their pages (RWPM `alternate` links).
+ */
+export declare enum DivinaQuality {
+    auto = "auto",// Match the display resolution
+    low = "low",// Smallest available variant
+    high = "high",// One step above the display resolution
+    max = "max"
+}
+export declare const MOBILE_MAX_HEIGHT = 2560;
+export declare const MOBILE_MAX_WIDTH = 1800;
+/** The link itself and its (bitmap) alternates, if any */
+export declare function gatherVariants(item: Link): Link[];
+export interface VariantSelectionOptions {
+    /** Display size of the page in device pixels (CSS box × devicePixelRatio) */
+    targetWidth: number;
+    targetHeight: number;
+    /** The axis that constrains the display: height in paged mode, width in scrolled mode */
+    axis: "width" | "height";
+    quality: DivinaQuality;
+}
+/**
+ * Selects the most appropriate variant of a page image for the current
+ * display, based purely on the choices the manifest offers: the smallest
+ * variant that covers the display resolution (in device pixels), biased by
+ * the quality preference, and capped on mobile devices.
+ */
+export declare function selectVariant(item: Link, opts: VariantSelectionOptions): Link;

package/types/src/divina/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./DivinaNavigator.ts";
+export * from "./DivinaSpreader.ts";
+export * from "./DivinaPageManager.ts";
+export * from "./DivinaPagedPresenter.ts";
+export * from "./DivinaScrolledPresenter.ts";
+export * from "./DivinaPeripherals.ts";
+export * from "./DivinaVariantSelector.ts";
+export * from "./preferences/index.ts";

package/types/src/divina/preferences/DivinaDefaults.d.ts

@@ -0,0 +1,18 @@
+import { DivinaQuality } from "../DivinaVariantSelector.ts";
+export interface IDivinaDefaults {
+    backgroundColor?: string | null;
+    constraint?: number | null;
+    quality?: DivinaQuality | null;
+    scrolled?: boolean | null;
+    spreads?: boolean | null;
+    stripWidth?: number | null;
+}
+export declare class DivinaDefaults {
+    backgroundColor: string | null;
+    constraint: number;
+    quality: DivinaQuality;
+    scrolled: boolean | null;
+    spreads: boolean;
+    stripWidth: number;
+    constructor(defaults: IDivinaDefaults);
+}

package/types/src/divina/preferences/DivinaPreferences.d.ts

@@ -0,0 +1,33 @@
+import { ConfigurablePreferences } from "../../preferences/Configurable.ts";
+import { RangeConfig } from "../../preferences/Types.ts";
+import { DivinaQuality } from "../DivinaVariantSelector.ts";
+/**
+ * Maximum width in pixels of the vertical strip in scrolled mode.
+ */
+export declare const stripWidthRangeConfig: RangeConfig;
+export interface IDivinaPreferences {
+    /** Background color behind the pages (equivalent of the EPUB page background theme) */
+    backgroundColor?: string | null;
+    /** Number of pixels to constrain the container width by (e.g. for docked panels) */
+    constraint?: number | null;
+    /** Image quality when the publication offers alternate resolutions */
+    quality?: DivinaQuality | null;
+    /** Display the publication as a vertical scroll instead of horizontal pages */
+    scrolled?: boolean | null;
+    /** Display two pages side-by-side on landscape viewports (paged mode only) */
+    spreads?: boolean | null;
+    /** Maximum width in pixels of the vertical strip in scrolled mode */
+    stripWidth?: number | null;
+}
+export declare class DivinaPreferences implements ConfigurablePreferences<DivinaPreferences> {
+    backgroundColor?: string | null;
+    constraint?: number | null;
+    quality?: DivinaQuality | null;
+    scrolled?: boolean | null;
+    spreads?: boolean | null;
+    stripWidth?: number | null;
+    constructor(preferences?: IDivinaPreferences);
+    static serialize(preferences: DivinaPreferences): string;
+    static deserialize(preferences: string): DivinaPreferences | null;
+    merging(other: DivinaPreferences): DivinaPreferences;
+}

package/types/src/divina/preferences/DivinaPreferencesEditor.d.ts

@@ -0,0 +1,20 @@
+import { Metadata } from "@readium/shared";
+import { IPreferencesEditor } from "../../preferences/PreferencesEditor.ts";
+import { BooleanPreference, EnumPreference, Preference, RangePreference } from "../../preferences/Preference.ts";
+import { DivinaQuality } from "../DivinaVariantSelector.ts";
+import { DivinaPreferences } from "./DivinaPreferences.ts";
+import { DivinaSettings } from "./DivinaSettings.ts";
+export declare class DivinaPreferencesEditor implements IPreferencesEditor {
+    preferences: DivinaPreferences;
+    private settings;
+    private metadata;
+    constructor(initialPreferences: DivinaPreferences, settings: DivinaSettings, metadata: Metadata);
+    clear(): void;
+    private updatePreference;
+    private get manifestScrolled();
+    get backgroundColor(): Preference<string>;
+    get quality(): EnumPreference<DivinaQuality>;
+    get scrolled(): BooleanPreference;
+    get spreads(): BooleanPreference;
+    get stripWidth(): RangePreference<number>;
+}

package/types/src/divina/preferences/DivinaSettings.d.ts

@@ -0,0 +1,26 @@
+import { ConfigurableSettings } from "../../preferences/Configurable.ts";
+import { DivinaQuality } from "../DivinaVariantSelector.ts";
+import { DivinaDefaults } from "./DivinaDefaults.ts";
+import { DivinaPreferences } from "./DivinaPreferences.ts";
+export interface IDivinaSettings {
+    backgroundColor?: string | null;
+    constraint?: number | null;
+    quality?: DivinaQuality | null;
+    scrolled?: boolean | null;
+    spreads?: boolean | null;
+    stripWidth?: number | null;
+}
+export declare class DivinaSettings implements ConfigurableSettings {
+    backgroundColor: string | null;
+    constraint: number;
+    quality: DivinaQuality;
+    scrolled: boolean;
+    spreads: boolean;
+    stripWidth: number;
+    /**
+     * @param manifestScrolled Whether the publication itself declares `layout: scrolled`.
+     * A natively scrolled publication (e.g. webtoon) cannot be switched to paged mode,
+     * while a fixed publication can be switched to scrolled by the user.
+     */
+    constructor(preferences: DivinaPreferences, defaults: DivinaDefaults, manifestScrolled: boolean);
+}

package/types/src/divina/preferences/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./DivinaDefaults.ts";
+export * from "./DivinaPreferences.ts";
+export * from "./DivinaPreferencesEditor.ts";
+export * from "./DivinaSettings.ts";

package/types/src/divina/protection/DivinaNavigatorProtector.d.ts

@@ -0,0 +1,14 @@
+import { NavigatorProtector } from "../../protection/NavigatorProtector.ts";
+import { IContentProtectionConfig } from "../../Navigator.ts";
+/**
+ * Content protection for the Divina navigator. Because Divina renders images
+ * directly in the host DOM (no iframes), the in-frame halves of the EPUB
+ * protection (copy and drag-and-drop blocking) must run host-side instead,
+ * like the audio navigator does.
+ */
+export declare class DivinaNavigatorProtector extends NavigatorProtector {
+    private dragAndDropProtector?;
+    private copyProtector?;
+    constructor(config?: IContentProtectionConfig);
+    destroy(): void;
+}

package/types/src/epub/EpubNavigator.d.ts

@@ -12,6 +12,8 @@ import { EpubSettings } from "./preferences/index.ts";
 import { EpubPreferencesEditor } from "./preferences/EpubPreferencesEditor.ts";
 import { IInjectablesConfig } from "../injection/Injectable.ts";
 import { IContentProtectionConfig, IKeyboardPeripheralsConfig, KeyboardPeripheralEventData } from "../Navigator.ts";
+import { UpgradeInsecureRequests } from "./frame/FrameBlobBuilder.ts";
+export type { UpgradeInsecureRequests };
 export type ManagerEventKey = "zoom";
 export interface EpubNavigatorConfiguration {
     preferences: IEpubPreferences;
@@ -20,6 +22,7 @@ export interface EpubNavigatorConfiguration {
     contentProtection?: IContentProtectionConfig;
     keyboardPeripherals?: IKeyboardPeripheralsConfig;
     decoratorConfig?: DecoratorConfig;
+    upgradeInsecureRequests?: UpgradeInsecureRequests;
 }
 export interface EpubNavigatorListeners {
     frameLoaded: (wnd: Window) => void;
@@ -42,6 +45,7 @@ export declare class EpubNavigator extends VisualNavigator implements Configurab
     private readonly container;
     private readonly listeners;
     private framePool;
+    private _destroyed;
     private positions;
     private currentLocation;
     private _currentTimelineItem;
@@ -63,6 +67,7 @@ export declare class EpubNavigator extends VisualNavigator implements Configurab
     private readonly _injectablesConfig;
     private readonly _contentProtection;
     private readonly _keyboardPeripherals;
+    private readonly _upgradeInsecureRequests;
     private readonly _navigatorProtector;
     private readonly _keyboardPeripheralsManager;
     private readonly _suspiciousActivityListener;
@@ -79,7 +84,7 @@ export declare class EpubNavigator extends VisualNavigator implements Configurab
     private reflowViewport;
     constructor(container: HTMLElement, pub: Publication, listeners: EpubNavigatorListeners, positions?: Locator[], initialPosition?: Locator | undefined, configuration?: EpubNavigatorConfiguration);
     static determineLayout(pub: Publication, scroll?: boolean): Layout;
-    load(): Promise<void>;
+    load(): Promise<unknown>;
     get settings(): Readonly<EpubSettings>;
     get preferencesEditor(): EpubPreferencesEditor;
     submitPreferences(preferences: EpubPreferences): Promise<void>;
@@ -143,6 +148,7 @@ export declare class EpubNavigator extends VisualNavigator implements Configurab
     get publication(): Publication;
     get timeline(): Timeline;
     private loadLocator;
+    private completeLocator;
     go(locator: Locator, _: boolean, cb: (ok: boolean) => void): void;
     goLink(link: Link, animated: boolean, cb: (ok: boolean) => void): void;
     private _notifyTimelineChange;

package/types/src/epub/frame/FrameBlobBuilder.d.ts

@@ -1,18 +1,34 @@
 import { Link, Publication } from "@readium/shared";
 import { Injector } from "../../injection/Injector.ts";
-export default class FrameBlobBuider {
-    private readonly item;
-    private readonly burl;
+/**
+ * A flag to control whether `upgrade-insecure-requests` is included in the Content
+ * Security Policy of each spine-item blob frame:
+ *
+ * - `always` will always upgrade insecure requests
+ * - `never` will never upgrade insecure requests
+ * - `auto` will upgrade insecure requests only when the publication root URL is HTTPS
+ */
+export type UpgradeInsecureRequests = 'always' | 'never' | 'auto';
+export default class FrameBlobBuilder {
     private readonly pub;
+    private readonly baseURL;
+    private readonly item;
     private readonly cssProperties?;
     private readonly injector;
+    private readonly upgradeInsecureRequests;
+    private currentUrl?;
+    private currentResource?;
+    private pendingBuild?;
     constructor(pub: Publication, baseURL: string, item: Link, options: {
         cssProperties?: {
             [key: string]: string;
         };
         injector?: Injector | null;
+        upgradeInsecureRequests?: UpgradeInsecureRequests;
     });
+    reset(): void;
     build(fxl?: boolean): Promise<string>;
+    private doBuild;
     private buildHtmlFrame;
     private buildImageFrame;
     private setProperties;

package/types/src/epub/frame/FrameComms.d.ts

@@ -4,15 +4,22 @@ export type FrameCommsListener = (key: CommsEventKey | ManagerEventKey, value: u
 export declare class FrameComms {
     private readonly wnd;
     private readonly registry;
-    private readonly gc;
+    private gc;
     private readonly origin;
     readonly channelId: string;
     private _ready;
     private _listener;
     private listenerBuffer;
+    private visibleTime;
+    private visibleSince;
     set listener(listener: FrameCommsListener);
     clearListener(): void;
     constructor(wnd: Window, origin: string);
+    private startGc;
+    private stopGc;
+    private visibleNow;
+    private handleVisibility;
+    private visibilityHandler;
     halt(): void;
     resume(): void;
     private handle;

package/types/src/epub/frame/FrameManager.d.ts

@@ -15,6 +15,7 @@ export declare class FrameManager {
     private pendingUnwatchSelectors;
     private conditionBridge?;
     private currModules;
+    private readonly serialize;
     constructor(source: string, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig, timelineFragmentIds?: string[], resizeWatchSelectors?: string[]);
     load(modules: ModuleName[]): Promise<Window>;
     private applyContentProtection;
@@ -22,7 +23,9 @@ export declare class FrameManager {
     removeResizeTarget(selector: string): void;
     destroy(): Promise<void>;
     hide(): Promise<void>;
+    private hideNow;
     show(atProgress?: number): Promise<void>;
+    private showNow;
     setCSSProperties(properties: {
         [key: string]: string;
     }): void;

package/types/src/epub/frame/FramePoolManager.d.ts

@@ -1,5 +1,6 @@
 import { ModuleName } from "@readium/navigator-html-injectables";
 import { Locator, Publication } from "@readium/shared";
+import { UpgradeInsecureRequests } from "./FrameBlobBuilder.ts";
 import { FrameManager } from "./FrameManager.ts";
 import { Injector } from "../../injection/Injector.ts";
 import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../../Navigator.ts";
@@ -16,11 +17,14 @@ export declare class FramePoolManager {
     private readonly injector;
     private readonly contentProtectionConfig;
     private readonly keyboardPeripheralsConfig;
+    private updateSequence;
+    private forcedUpdate;
     private resizeWatchSelectors;
     private readonly getFragmentIds;
+    private readonly upgradeInsecureRequests;
     constructor(container: HTMLElement, positions: Locator[], cssProperties?: {
         [key: string]: string;
-    }, injector?: Injector | null, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig, getFragmentIds?: (href: string) => string[], resizeWatchSelectors?: string[]);
+    }, injector?: Injector | null, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig, getFragmentIds?: (href: string) => string[], resizeWatchSelectors?: string[], upgradeInsecureRequests?: UpgradeInsecureRequests);
     addResizeTarget(selector: string): void;
     removeResizeTarget(selector: string): void;
     destroy(): Promise<void>;

package/types/src/epub/fxl/FXLFrameManager.d.ts

@@ -5,6 +5,7 @@ import { FXLPeripherals } from "./FXLPeripherals.ts";
 import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../../Navigator.ts";
 export declare class FXLFrameManager {
     private frame;
+    private frameIsAppended;
     private loader;
     source: string;
     private comms;
@@ -19,8 +20,11 @@ export declare class FXLFrameManager {
     debugHref: string;
     private loadPromise;
     private showPromise;
+    private viewportSize;
+    private readonly serialize;
     constructor(peripherals: FXLPeripherals, direction: ReadingProgression, debugHref: string, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig, resizeWatchSelectors?: string[]);
     load(modules: ModuleName[], source: string): Promise<Window>;
+    private loadNow;
     loadPageSize(): {
         width: number;
         height: number;
@@ -28,13 +32,16 @@ export declare class FXLFrameManager {
     update(page?: Page): void;
     destroy(): Promise<void>;
     unload(): Promise<void>;
+    private unloadNow;
     deselect(): void;
     unfocus(): Promise<void>;
+    private unfocusNow;
     private applyContentProtection;
     addResizeTarget(selector: string): void;
     removeResizeTarget(selector: string): void;
     private cachedPage;
     show(page: Page): Promise<void>;
+    private showNow;
     activate(): Promise<void>;
     get element(): HTMLDivElement;
     get iframe(): HTMLIFrameElement;

package/types/src/epub/fxl/FXLFramePoolManager.d.ts

@@ -1,6 +1,7 @@
 import { ModuleName } from "@readium/navigator-html-injectables";
-import { Locator, Publication, Page, Link } from "@readium/shared";
+import { Locator, Publication, Page, Link, Layout } from "@readium/shared";
 import { FrameCommsListener } from "../frame/index.ts";
+import { UpgradeInsecureRequests } from "../frame/FrameBlobBuilder.ts";
 import { FXLFrameManager } from "./FXLFrameManager.ts";
 import { FXLPeripherals } from "./FXLPeripherals.ts";
 import { VisualNavigatorViewport, IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../../Navigator.ts";
@@ -19,6 +20,7 @@ export declare class FXLFramePoolManager {
     private readonly contentProtectionConfig;
     private readonly keyboardPeripheralsConfig;
     private resizeWatchSelectors;
+    private readonly upgradeInsecureRequests;
     private readonly bookElement;
     readonly spineElement: HTMLDivElement;
     private readonly pub;
@@ -33,7 +35,8 @@ export declare class FXLFramePoolManager {
     private containerHeightCached;
     private resizeTimeout;
     readonly peripherals: FXLPeripherals;
-    constructor(container: HTMLElement, positions: Locator[], pub: Publication, injector?: Injector | null, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig, resizeWatchSelectors?: string[]);
+    constructor(container: HTMLElement, positions: Locator[], pub: Publication, _layout: Layout, // TODO: used by upcoming scrolled-layout support
+    injector?: Injector | null, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig, resizeWatchSelectors?: string[], upgradeInsecureRequests?: UpgradeInsecureRequests);
     private _listener;
     set listener(listener: FrameCommsListener);
     get listener(): FrameCommsListener;
@@ -52,6 +55,9 @@ export declare class FXLFramePoolManager {
     get threshold(): number;
     get portrait(): boolean;
     updateSpineStyle(animate: boolean, fast?: boolean): void;
+    private bookScale;
+    private bookTranslate;
+    private bookTransform;
     updateBookStyle(initial?: boolean): void;
     /**
      * Go to slide with particular index

package/types/src/epub/fxl/FXLPeripherals.d.ts

@@ -26,6 +26,7 @@ export interface Zoomer {
         Y: number;
     };
 }
+export declare const isTypedOMSupported: () => boolean;
 export declare class FXLPeripherals {
     private readonly manager;
     private readonly coordinator;
@@ -68,6 +69,8 @@ export declare class FXLPeripherals {
      */
     touchendHandler(e: TouchEvent): void;
     private moveFrame;
+    private dragTranslate;
+    private dragTransform;
     /**
      * touchmove event handler
      */

package/types/src/helpers/serialize.d.ts

@@ -0,0 +1 @@
+export declare function createSerializer(): <T>(operation: () => Promise<T>) => Promise<T>;

package/types/src/index.d.ts

@@ -2,6 +2,7 @@ export * from './Navigator.ts';
 export * from './decorations/index.ts';
 export * from './webpub/index.ts';
 export * from './epub/index.ts';
+export * from './divina/index.ts';
 export * from './audio/index.ts';
 export * from './helpers/index.ts';
 export * from './preferences/index.ts';

package/types/src/peripherals/KeyboardPeripherals.d.ts

@@ -7,6 +7,7 @@ export interface KeyboardPeripheralOptions {
 export declare class KeyboardPeripherals {
     private keydownHandler?;
     private keyManager;
+    private readonly pagehideHandler;
     constructor(options?: KeyboardPeripheralOptions);
     private setupKeyboardPeripherals;
     destroy(): void;

package/types/src/webpub/WebPubFrameManager.d.ts

@@ -15,6 +15,7 @@ export declare class WebPubFrameManager {
     private pendingUnwatchSelectors;
     private conditionBridge?;
     private currModules;
+    private readonly serialize;
     constructor(source: string, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig, timelineFragmentIds?: string[], resizeWatchSelectors?: string[]);
     load(modules?: ModuleName[]): Promise<Window>;
     private applyContentProtection;
@@ -22,7 +23,9 @@ export declare class WebPubFrameManager {
     removeResizeTarget(selector: string): void;
     destroy(): Promise<void>;
     hide(): Promise<void>;
+    private hideNow;
     show(atProgress?: number): Promise<void>;
+    private showNow;
     setCSSProperties(properties: {
         [key: string]: string;
     }): void;

package/types/src/webpub/WebPubNavigator.d.ts

@@ -41,6 +41,7 @@ export declare class WebPubNavigator extends VisualNavigator implements Configur
     private framePool;
     private currentIndex;
     private currentLocation;
+    private _destroyed;
     private _currentTimelineItem;
     private _visibleFragmentIds;
     private _notifiedVisibleFragmentIds;
@@ -115,6 +116,7 @@ export declare class WebPubNavigator extends VisualNavigator implements Configur
     get publication(): Publication;
     get timeline(): Timeline;
     private loadLocator;
+    private completeLocator;
     go(locator: Locator, _: boolean, cb: (ok: boolean) => void): void;
     goLink(link: Link, animated: boolean, cb: (ok: boolean) => void): void;
     private createCurrentLocator;