@readium/navigator 2.2.9 → 2.3.1

package/types/src/Navigator.d.ts

@@ -1,5 +1,9 @@
 import { Link, Locator, Publication, ReadingProgression } from "@readium/shared";
+import { ContentProtectionConfig, PrintProtectionConfig, KeyboardPeripheral } from "@readium/navigator-html-injectables";
 type cbb = (ok: boolean) => void;
+export type IKeyboardPeripheralsConfig = Array<Omit<KeyboardPeripheral, 'type'> & {
+    type: Exclude<string, 'developer_tools' | 'select_all' | 'print' | 'save'>;
+}>;
 export interface ProgressionRange {
     start: number;
     end: number;
@@ -9,6 +13,11 @@ export interface VisualNavigatorViewport {
     progressions: Map<string, ProgressionRange>;
     positions: number[] | null;
 }
+export interface IContentProtectionConfig extends ContentProtectionConfig {
+    protectPrinting?: PrintProtectionConfig;
+    checkAutomation?: boolean;
+    checkIFrameEmbedding?: boolean;
+}
 export declare abstract class Navigator {
     abstract get publication(): Publication;
     abstract get currentLocator(): Locator;
@@ -32,6 +41,11 @@ export declare abstract class Navigator {
      * Destroy all resources associated with this navigator. Synonymous with "unmount"
      */
     abstract destroy(): void;
+    /**
+     * Merges keyboard peripherals from content protection config with user-provided peripherals
+     * Content protection peripherals are added first for priority, then user peripherals are added only if they don't conflict
+     */
+    protected mergeKeyboardPeripherals(config: IContentProtectionConfig, keyboardPeripherals?: IKeyboardPeripheralsConfig): IKeyboardPeripheralsConfig;
 }
 export declare abstract class VisualNavigator extends Navigator {
     /**

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

@@ -2,8 +2,8 @@ import { Layout, Link, Locator, Publication, ReadingProgression } from "@readium
 import { Configurable, ConfigurablePreferences, ConfigurableSettings, VisualNavigator, VisualNavigatorViewport } from "../";
 import { FramePoolManager } from "./frame/FramePoolManager";
 import { FXLFramePoolManager } from "./fxl/FXLFramePoolManager";
-import { CommsEventKey } from "@readium/navigator-html-injectables";
-import { BasicTextSelection, FrameClickEvent } from "@readium/navigator-html-injectables";
+import { CommsEventKey, ContextMenuEvent, KeyboardEventData } from "@readium/navigator-html-injectables";
+import { BasicTextSelection, FrameClickEvent, SuspiciousActivityEvent } from "@readium/navigator-html-injectables";
 import { FXLFrameManager } from "./fxl/FXLFrameManager";
 import { FrameManager } from "./frame/FrameManager";
 import { IEpubPreferences, EpubPreferences } from "./preferences/EpubPreferences";
@@ -11,11 +11,14 @@ import { IEpubDefaults } from "./preferences/EpubDefaults";
 import { EpubSettings } from "./preferences";
 import { EpubPreferencesEditor } from "./preferences/EpubPreferencesEditor";
 import { IInjectablesConfig } from "../injection/Injectable";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
 export type ManagerEventKey = "zoom";
 export interface EpubNavigatorConfiguration {
     preferences: IEpubPreferences;
     defaults: IEpubDefaults;
     injectables?: IInjectablesConfig;
+    contentProtection?: IContentProtectionConfig;
+    keyboardPeripherals?: IKeyboardPeripheralsConfig;
 }
 export interface EpubNavigatorListeners {
     frameLoaded: (wnd: Window) => void;
@@ -28,6 +31,9 @@ export interface EpubNavigatorListeners {
     customEvent: (key: string, data: unknown) => void;
     handleLocator: (locator: Locator) => boolean;
     textSelected: (selection: BasicTextSelection) => void;
+    contentProtection: (type: string, data: SuspiciousActivityEvent) => void;
+    contextMenu: (data: ContextMenuEvent) => void;
+    peripheral: (data: KeyboardEventData) => void;
 }
 export declare class EpubNavigator extends VisualNavigator implements Configurable<ConfigurableSettings, ConfigurablePreferences> {
     private readonly pub;
@@ -45,6 +51,12 @@ export declare class EpubNavigator extends VisualNavigator implements Configurab
     private _css;
     private _preferencesEditor;
     private readonly _injector;
+    private readonly _contentProtection;
+    private readonly _keyboardPeripherals;
+    private readonly _navigatorProtector;
+    private readonly _keyboardPeripheralsManager;
+    private readonly _suspiciousActivityListener;
+    private readonly _keyboardPeripheralListener;
     private resizeObserver;
     private reflowViewport;
     constructor(container: HTMLElement, pub: Publication, listeners: EpubNavigatorListeners, positions?: Locator[], initialPosition?: Locator | undefined, configuration?: EpubNavigatorConfiguration);

package/types/src/epub/css/Properties.d.ts

@@ -104,6 +104,8 @@ export interface IRSProperties {
     sansSerifJaV?: string | null;
     sansTf?: string | null;
     scrollPaddingBottom?: number | null;
+    scrollPaddingLeft?: number | null;
+    scrollPaddingRight?: number | null;
     scrollPaddingTop?: number | null;
     secondaryColor?: string | null;
     selectionBackgroundColor?: string | null;
@@ -146,6 +148,8 @@ export declare class RSProperties extends Properties {
     sansSerifJaV: string | null;
     sansTf: string | null;
     scrollPaddingBottom: number | null;
+    scrollPaddingLeft: number | null;
+    scrollPaddingRight: number | null;
     scrollPaddingTop: number | null;
     secondaryColor: string | null;
     selectionBackgroundColor: string | null;

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

@@ -1,5 +1,6 @@
 import { Loader, ModuleName } from "@readium/navigator-html-injectables";
 import { FrameComms } from "./FrameComms";
+import type { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../../Navigator";
 export declare class FrameManager {
     private frame;
     private loader;
@@ -7,9 +8,12 @@ export declare class FrameManager {
     private comms;
     private hidden;
     private destroyed;
+    private readonly contentProtectionConfig;
+    private readonly keyboardPeripheralsConfig;
     private currModules;
-    constructor(source: string);
+    constructor(source: string, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig);
     load(modules: ModuleName[]): Promise<Window>;
+    private applyContentProtection;
     destroy(): Promise<void>;
     hide(): Promise<void>;
     show(atProgress?: number): Promise<void>;

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

@@ -2,6 +2,7 @@ import { ModuleName } from "@readium/navigator-html-injectables";
 import { Locator, Publication } from "@readium/shared";
 import { FrameManager } from "./FrameManager";
 import { Injector } from "../../injection/Injector";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../../Navigator";
 export declare class FramePoolManager {
     private readonly container;
     private readonly positions;
@@ -13,9 +14,11 @@ export declare class FramePoolManager {
     private pendingUpdates;
     private currentBaseURL;
     private readonly injector;
+    private readonly contentProtectionConfig;
+    private readonly keyboardPeripheralsConfig;
     constructor(container: HTMLElement, positions: Locator[], cssProperties?: {
         [key: string]: string;
-    }, injector?: Injector | null);
+    }, injector?: Injector | null, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig);
     destroy(): Promise<void>;
     update(pub: Publication, locator: Locator, modules: ModuleName[], force?: boolean): Promise<void>;
     setCSSProperties(properties: {

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

@@ -2,18 +2,21 @@ import { Loader, ModuleName } from "@readium/navigator-html-injectables";
 import { Page, ReadingProgression } from "@readium/shared";
 import { FrameComms } from "../frame/FrameComms";
 import { FXLPeripherals } from "./FXLPeripherals";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../../Navigator";
 export declare class FXLFrameManager {
     private frame;
     private loader;
     source: string;
     private comms;
     private readonly peripherals;
+    private readonly contentProtectionConfig;
+    private readonly keyboardPeripheralsConfig;
     private currModules;
     wrapper: HTMLDivElement;
     debugHref: string;
     private loadPromise;
     private showPromise;
-    constructor(peripherals: FXLPeripherals, direction: ReadingProgression, debugHref: string);
+    constructor(peripherals: FXLPeripherals, direction: ReadingProgression, debugHref: string, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig);
     load(modules: ModuleName[], source: string): Promise<Window>;
     loadPageSize(): {
         width: number;
@@ -24,6 +27,7 @@ export declare class FXLFrameManager {
     unload(): Promise<void>;
     deselect(): void;
     unfocus(): Promise<void>;
+    private applyContentProtection;
     private cachedPage;
     show(page: Page): Promise<void>;
     activate(): Promise<void>;

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

@@ -3,7 +3,7 @@ import { Locator, Publication, Page, Link } from "@readium/shared";
 import { FrameCommsListener } from "../frame";
 import { FXLFrameManager } from "./FXLFrameManager";
 import { FXLPeripherals } from "./FXLPeripherals";
-import { VisualNavigatorViewport } from "../../Navigator";
+import { VisualNavigatorViewport, IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../../Navigator";
 import { Injector } from "../../injection/Injector";
 export declare class FXLFramePoolManager {
     private readonly container;
@@ -16,6 +16,8 @@ export declare class FXLFramePoolManager {
     private currentBaseURL;
     private previousFrames;
     private readonly injector;
+    private readonly contentProtectionConfig;
+    private readonly keyboardPeripheralsConfig;
     private readonly bookElement;
     readonly spineElement: HTMLDivElement;
     private readonly pub;
@@ -30,7 +32,7 @@ export declare class FXLFramePoolManager {
     private containerHeightCached;
     private resizeTimeout;
     readonly peripherals: FXLPeripherals;
-    constructor(container: HTMLElement, positions: Locator[], pub: Publication, injector?: Injector | null);
+    constructor(container: HTMLElement, positions: Locator[], pub: Publication, injector?: Injector | null, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig);
     private _listener;
     set listener(listener: FrameCommsListener);
     get listener(): FrameCommsListener;

package/types/src/epub/preferences/EpubDefaults.d.ts

@@ -31,6 +31,8 @@ export interface IEpubDefaults {
     scroll?: boolean | null;
     scrollPaddingTop?: number | null;
     scrollPaddingBottom?: number | null;
+    scrollPaddingLeft?: number | null;
+    scrollPaddingRight?: number | null;
     selectionBackgroundColor?: string | null;
     selectionTextColor?: string | null;
     textAlign?: TextAlignment | null;
@@ -72,6 +74,8 @@ export declare class EpubDefaults {
     scroll: boolean | null;
     scrollPaddingTop: number | null;
     scrollPaddingBottom: number | null;
+    scrollPaddingLeft: number | null;
+    scrollPaddingRight: number | null;
     selectionBackgroundColor: string | null;
     selectionTextColor: string | null;
     textAlign: TextAlignment | null;

package/types/src/epub/preferences/EpubPreferences.d.ts

@@ -32,6 +32,8 @@ export interface IEpubPreferences {
     scroll?: boolean | null;
     scrollPaddingTop?: number | null;
     scrollPaddingBottom?: number | null;
+    scrollPaddingLeft?: number | null;
+    scrollPaddingRight?: number | null;
     selectionBackgroundColor?: string | null;
     selectionTextColor?: string | null;
     textAlign?: TextAlignment | null;
@@ -72,6 +74,8 @@ export declare class EpubPreferences implements ConfigurablePreferences {
     scroll?: boolean | null;
     scrollPaddingTop?: number | null;
     scrollPaddingBottom?: number | null;
+    scrollPaddingLeft?: number | null;
+    scrollPaddingRight?: number | null;
     selectionBackgroundColor?: string | null;
     selectionTextColor?: string | null;
     textAlign?: TextAlignment | null;

package/types/src/epub/preferences/EpubPreferencesEditor.d.ts

@@ -43,6 +43,8 @@ export declare class EpubPreferencesEditor implements IPreferencesEditor {
     get scroll(): BooleanPreference;
     get scrollPaddingTop(): Preference<number>;
     get scrollPaddingBottom(): Preference<number>;
+    get scrollPaddingLeft(): Preference<number>;
+    get scrollPaddingRight(): Preference<number>;
     get selectionBackgroundColor(): Preference<string>;
     get selectionTextColor(): Preference<string>;
     get textAlign(): EnumPreference<TextAlignment>;

package/types/src/epub/preferences/EpubSettings.d.ts

@@ -34,6 +34,8 @@ export interface IEpubSettings {
     scroll?: boolean | null;
     scrollPaddingTop?: number | null;
     scrollPaddingBottom?: number | null;
+    scrollPaddingLeft?: number | null;
+    scrollPaddingRight?: number | null;
     selectionBackgroundColor?: string | null;
     selectionTextColor?: string | null;
     textAlign?: TextAlignment | null;
@@ -75,6 +77,8 @@ export declare class EpubSettings implements ConfigurableSettings {
     scroll: boolean | null;
     scrollPaddingTop: number | null;
     scrollPaddingBottom: number | null;
+    scrollPaddingLeft: number | null;
+    scrollPaddingRight: number | null;
     selectionBackgroundColor: string | null;
     selectionTextColor: string | null;
     textAlign: TextAlignment | null;

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

@@ -8,7 +8,7 @@ export interface ILineLengthsConfig {
     maxChars?: number | null;
     baseFontSize?: number | null;
     sample?: string | null;
-    pageGutter?: number | null;
+    padding?: number | null;
     fontFace?: string | ICustomFontFace | null;
     letterSpacing?: number | null;
     wordSpacing?: number | null;
@@ -29,12 +29,11 @@ export declare class LineLengths {
     private _baseFontSize;
     private _fontFace;
     private _sample;
-    private _pageGutter;
+    private _padding;
     private _letterSpacing;
     private _wordSpacing;
     private _isCJK;
     private _getRelative;
-    private _padding;
     private _minDivider;
     private _maxMultiplier;
     private _approximatedWordSpaces;

package/types/src/injection/epubInjectables.d.ts

@@ -1,6 +1,6 @@
 import { IInjectableRule } from "../injection/Injectable";
-import { Metadata } from "@readium/shared";
+import { Metadata, Link } from "@readium/shared";
 /**
  * Creates injectable rules for EPUB content documents
  */
-export declare function createReadiumEpubRules(metadata: Metadata): IInjectableRule[];
+export declare function createReadiumEpubRules(metadata: Metadata, readingOrderItems: Link[]): IInjectableRule[];

package/types/src/injection/webpubInjectables.d.ts

@@ -1,5 +1,6 @@
 import { IInjectableRule } from "../injection/Injectable";
+import { Link } from "@readium/shared";
 /**
  * Creates injectable rules for WebPub content documents
  */
-export declare function createReadiumWebPubRules(): IInjectableRule[];
+export declare function createReadiumWebPubRules(readingOrderItems: Link[]): IInjectableRule[];

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

@@ -0,0 +1,13 @@
+import { KeyboardPeripheral } from "@readium/navigator-html-injectables";
+export declare const NAVIGATOR_KEYBOARD_PERIPHERAL_EVENT = "readium:navigator:keyboardPeripheral";
+export interface KeyboardPeripheralOptions {
+    /** Array of keyboard peripherals to configure */
+    keyboardPeripherals?: KeyboardPeripheral[];
+}
+export declare class KeyboardPeripherals {
+    private keydownHandler?;
+    private keyManager;
+    constructor(options?: KeyboardPeripheralOptions);
+    private setupKeyboardPeripherals;
+    destroy(): void;
+}

package/types/src/protection/AutomationDetector.d.ts

@@ -0,0 +1,14 @@
+export interface AutomationDetectorOptions {
+    /** Callback when an automation tool is detected */
+    onDetected?: (tool: string) => void;
+}
+export declare class AutomationDetector {
+    private options;
+    private detectedTools;
+    private observer?;
+    constructor(options: AutomationDetectorOptions);
+    private isAutomationToolPresent;
+    private setupDetection;
+    private handleDetected;
+    destroy(): void;
+}

package/types/src/protection/ContextMenuProtector.d.ts

@@ -0,0 +1,11 @@
+import { ContextMenuEvent } from "@readium/navigator-html-injectables";
+export interface ContextMenuProtectionOptions {
+    onContextMenuBlocked?: (event: ContextMenuEvent) => void;
+}
+export declare class ContextMenuProtector {
+    private contextMenuHandler?;
+    private onContextMenuBlocked?;
+    constructor(options?: ContextMenuProtectionOptions);
+    private handleContextMenu;
+    destroy(): void;
+}

package/types/src/protection/DevToolsDetector.d.ts

@@ -0,0 +1,75 @@
+export interface DevToolsDetectorOptions {
+    /** Callback when Developer Tools are detected as open */
+    onDetected?: () => void;
+    /** Callback when Developer Tools are detected as closed */
+    onClosed?: () => void;
+    /** Detection interval in milliseconds (default: 1000) */
+    interval?: number;
+    /** Enable debugger-based detection (fallback, impacts UX) */
+    enableDebuggerDetection?: boolean;
+}
+export declare class DevToolsDetector {
+    private options;
+    private isOpen;
+    private intervalId?;
+    private checkCount;
+    private maxChecks;
+    private maxPrintTime;
+    private largeObjectArray;
+    private workerConsole?;
+    constructor(options?: DevToolsDetectorOptions);
+    /**
+     * Create large object array for performance testing
+     */
+    private createLargeObjectArray;
+    /**
+     * Get cached large object array
+     */
+    private getLargeObjectArray;
+    /**
+     * Performance-based detection using console.table timing
+     */
+    private calcTablePrintTime;
+    /**
+     * Performance-based detection using console.log timing
+     */
+    private calcLogPrintTime;
+    /**
+     * Check if performance-based detection is enabled for current browser
+     */
+    private isPerformanceDetectionEnabled;
+    /**
+     * Check if debugger detection is enabled for current browser
+     */
+    private isDebuggerDetectionEnabled;
+    /**
+     * Performance-based detection using large object timing differences
+     */
+    private checkPerformanceBased;
+    /**
+     * Debugger-based detection (fallback method)
+     * WARNING: This method impacts user experience
+     */
+    private checkDebuggerBased;
+    /**
+     * Main detection method combining multiple approaches
+     * Prioritizes performance-based detection
+     */
+    private detectDevTools;
+    /**
+     * Start continuous detection monitoring
+     */
+    private startDetection;
+    /**
+     * Get current DevTools state
+     */
+    isDevToolsOpen(): boolean;
+    /**
+     * Force an immediate check
+     */
+    checkNow(): Promise<boolean>;
+    /**
+     * Stop detection and cleanup resources
+     */
+    destroy(): void;
+}

package/types/src/protection/IframeEmbeddingDetector.d.ts

@@ -0,0 +1,14 @@
+export interface IframeEmbeddingDetectorOptions {
+    /** Callback when iframe embedding is detected */
+    onDetected?: (isCrossOrigin: boolean) => void;
+}
+export declare class IframeEmbeddingDetector {
+    private options;
+    private observer?;
+    private detected;
+    constructor(options: IframeEmbeddingDetectorOptions);
+    private isIframed;
+    private setupDetection;
+    private handleDetected;
+    destroy(): void;
+}

package/types/src/protection/NavigatorProtector.d.ts

@@ -0,0 +1,12 @@
+import { IContentProtectionConfig } from "../Navigator";
+export declare const NAVIGATOR_SUSPICIOUS_ACTIVITY_EVENT = "readium:navigator:suspiciousActivity";
+export declare class NavigatorProtector {
+    private automationDetector?;
+    private devToolsDetector?;
+    private iframeEmbeddingDetector?;
+    private printProtector?;
+    private contextMenuProtector?;
+    private dispatchSuspiciousActivity;
+    constructor(config?: IContentProtectionConfig);
+    destroy(): void;
+}

package/types/src/protection/PrintProtector.d.ts

@@ -0,0 +1,13 @@
+export interface NavigatorPrintProtectionConfig {
+    disable?: boolean;
+    watermark?: string;
+    onPrintAttempt?: () => void;
+}
+export declare class PrintProtector {
+    private styleElement;
+    private beforePrintHandler;
+    private onPrintAttempt?;
+    constructor(config?: NavigatorPrintProtectionConfig);
+    private setupPrintProtection;
+    destroy(): void;
+}

package/types/src/protection/utils/WorkerConsole.d.ts

@@ -0,0 +1,15 @@
+export type WorkerConsoleMethod<Args extends any[]> = (...args: Args) => Promise<{
+    time: number;
+}>;
+export declare class WorkerConsole {
+    static workerScript: string;
+    private readonly worker;
+    private readonly blobUrl;
+    private callbacks;
+    readonly log: WorkerConsoleMethod<Parameters<Console['log']>>;
+    readonly table: WorkerConsoleMethod<Parameters<Console['table']>>;
+    readonly clear: WorkerConsoleMethod<Parameters<Console['clear']>>;
+    constructor(worker: Worker, blobUrl: string);
+    private send;
+    destroy(): void;
+}

package/types/src/protection/utils/console.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cache console methods to prevent third-party code from hooking them
+ */
+export declare const log: (...data: any[]) => void;
+export declare const table: (tabularData?: any, properties?: string[]) => void;
+export declare const clear: () => void;

package/types/src/protection/utils/match.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Match utilities for browser compatibility checking
+ */
+export interface MatchOptions {
+    includes: (() => boolean)[];
+    excludes: (() => boolean)[];
+}
+export declare function match(options: MatchOptions): boolean;

package/types/src/protection/utils/platform.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Platform detection utilities
+ */
+export declare function isBrave(): Promise<boolean>;

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

@@ -1,5 +1,6 @@
 import { Loader, ModuleName } from "@readium/navigator-html-injectables";
 import { FrameComms } from "../epub/frame/FrameComms";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
 export declare class WebPubFrameManager {
     private frame;
     private loader;
@@ -7,9 +8,12 @@ export declare class WebPubFrameManager {
     private comms;
     private hidden;
     private destroyed;
+    private readonly contentProtectionConfig;
+    private readonly keyboardPeripheralsConfig;
     private currModules;
-    constructor(source: string);
+    constructor(source: string, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig);
     load(modules?: ModuleName[]): Promise<Window>;
+    private applyContentProtection;
     destroy(): Promise<void>;
     hide(): Promise<void>;
     show(atProgress?: number): Promise<void>;

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

@@ -2,6 +2,7 @@ import { ModuleName } from "@readium/navigator-html-injectables";
 import { Locator, Publication } from "@readium/shared";
 import { WebPubFrameManager } from "./WebPubFrameManager";
 import { Injector } from "../injection/Injector";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
 export declare class WebPubFramePoolManager {
     private readonly container;
     private _currentFrame;
@@ -12,9 +13,11 @@ export declare class WebPubFramePoolManager {
     private pendingUpdates;
     private currentBaseURL;
     private readonly injector?;
+    private readonly contentProtectionConfig;
+    private readonly keyboardPeripheralsConfig;
     constructor(container: HTMLElement, cssProperties?: {
         [key: string]: string;
-    }, injector?: Injector | null);
+    }, injector?: Injector | null, contentProtectionConfig?: IContentProtectionConfig, keyboardPeripheralsConfig?: IKeyboardPeripheralsConfig);
     destroy(): Promise<void>;
     update(pub: Publication, locator: Locator, modules: ModuleName[]): Promise<void>;
     setCSSProperties(properties: {

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

@@ -1,7 +1,7 @@
 import { Link, Locator, Publication, ReadingProgression } from "@readium/shared";
 import { VisualNavigator, VisualNavigatorViewport } from "../Navigator";
 import { Configurable } from "../preferences/Configurable";
-import { BasicTextSelection, CommsEventKey, FrameClickEvent } from "@readium/navigator-html-injectables";
+import { BasicTextSelection, CommsEventKey, ContextMenuEvent, FrameClickEvent, KeyboardEventData, SuspiciousActivityEvent } from "@readium/navigator-html-injectables";
 import { WebPubFrameManager } from "./WebPubFrameManager";
 import { ManagerEventKey } from "../epub/EpubNavigator";
 import { IWebPubPreferences, WebPubPreferences } from "./preferences/WebPubPreferences";
@@ -9,10 +9,13 @@ import { IWebPubDefaults } from "./preferences/WebPubDefaults";
 import { WebPubSettings } from "./preferences/WebPubSettings";
 import { IPreferencesEditor } from "../preferences/PreferencesEditor";
 import { IInjectablesConfig } from "../injection/Injectable";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
 export interface WebPubNavigatorConfiguration {
     preferences: IWebPubPreferences;
     defaults: IWebPubDefaults;
     injectables?: IInjectablesConfig;
+    contentProtection?: IContentProtectionConfig;
+    keyboardPeripherals?: IKeyboardPeripheralsConfig;
 }
 export interface WebPubNavigatorListeners {
     frameLoaded: (wnd: Window) => void;
@@ -24,6 +27,9 @@ export interface WebPubNavigatorListeners {
     customEvent: (key: string, data: unknown) => void;
     handleLocator: (locator: Locator) => boolean;
     textSelected: (selection: BasicTextSelection) => void;
+    contentProtection: (type: string, data: SuspiciousActivityEvent) => void;
+    contextMenu: (data: ContextMenuEvent) => void;
+    peripheral: (data: KeyboardEventData) => void;
 }
 export declare class WebPubNavigator extends VisualNavigator implements Configurable<WebPubSettings, WebPubPreferences> {
     private readonly pub;
@@ -38,6 +44,12 @@ export declare class WebPubNavigator extends VisualNavigator implements Configur
     private _css;
     private _preferencesEditor;
     private readonly _injector;
+    private readonly _contentProtection;
+    private readonly _keyboardPeripherals;
+    private readonly _navigatorProtector;
+    private readonly _keyboardPeripheralsManager;
+    private readonly _suspiciousActivityListener;
+    private readonly _keyboardPeripheralListener;
     private webViewport;
     constructor(container: HTMLElement, pub: Publication, listeners: WebPubNavigatorListeners, initialPosition?: Locator | undefined, configuration?: WebPubNavigatorConfiguration);
     load(): Promise<void>;