@readium/navigator 2.2.8 → 2.3.0

package/src/webpub/WebPubFrameManager.ts

@@ -2,6 +2,7 @@ import { Loader, ModuleName } from "@readium/navigator-html-injectables";
 import { FrameComms } from "../epub/frame/FrameComms";
 import { ReadiumWindow } from "../../../navigator-html-injectables/types/src/helpers/dom";
 import { sML } from "../helpers";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
 
 export class WebPubFrameManager {
     private frame: HTMLIFrameElement;
@@ -10,10 +11,15 @@ export class WebPubFrameManager {
     private comms: FrameComms | undefined;
     private hidden: boolean = true;
     private destroyed: boolean = false;
-
+    private readonly contentProtectionConfig: IContentProtectionConfig;
+    private readonly keyboardPeripheralsConfig: IKeyboardPeripheralsConfig;
     private currModules: ModuleName[] = [];
 
-    constructor(source: string) {
+    constructor(
+        source: string,
+        contentProtectionConfig: IContentProtectionConfig = {},
+        keyboardPeripheralsConfig: IKeyboardPeripheralsConfig = []
+    ) {
         this.frame = document.createElement("iframe");
         this.frame.classList.add("readium-navigator-iframe");
         this.frame.style.visibility = "hidden";
@@ -25,14 +31,17 @@ export class WebPubFrameManager {
         // Protect against background color bleeding
         this.frame.style.backgroundColor = "#FFFFFF";
         this.source = source;
+        
+        // Use the provided content protection config directly without overriding defaults
+        this.contentProtectionConfig = { ...contentProtectionConfig };
+        this.keyboardPeripheralsConfig = [...keyboardPeripheralsConfig];
     }
 
     async load(modules: ModuleName[] = []): Promise<Window> {
         return new Promise((res, rej) => {
-            if(this.loader) {
+            if (this.loader) {
                 const wnd = this.frame.contentWindow!;
-                // Check if currently loaded modules are equal
-                if([...this.currModules].sort().join("|") === [...modules].sort().join("|")) {
+                if ([...this.currModules].sort().join("|") === [...modules].sort().join("|")) {
                     try { res(wnd); } catch (error) {};
                     return;
                 }
@@ -57,6 +66,28 @@ export class WebPubFrameManager {
         });
     }
 
+    private applyContentProtection() {
+        if (!this.comms) this.comms!.resume();
+        
+        // Send content protection config
+        this.comms!.send("peripherals_protection", this.contentProtectionConfig);
+        
+        // Send keyboard peripherals separately
+        if (this.keyboardPeripheralsConfig && this.keyboardPeripheralsConfig.length > 0) {
+            this.comms!.send("keyboard_peripherals", this.keyboardPeripheralsConfig);
+        }
+
+        // Apply scroll protection if enabled
+        if (this.contentProtectionConfig.monitorScrollingExperimental) {
+            this.comms!.send("scroll_protection", {});
+        }
+
+        // Apply print protection if configured
+        if (this.contentProtectionConfig.protectPrinting) {
+            this.comms!.send("print_protection", this.contentProtectionConfig.protectPrinting);
+        }
+    }
+
     async destroy() {
         await this.hide();
         this.loader?.destroy();
@@ -94,6 +125,8 @@ export class WebPubFrameManager {
         return new Promise((res, _) => {
             this.comms?.send("activate", undefined, () => {
                 this.comms?.send("focus", undefined, () => {
+                    // Apply content protection synchronously
+                    this.applyContentProtection();
                     const remove = () => {
                         this.frame.style.removeProperty("visibility");
                         this.frame.style.removeProperty("aria-hidden");

package/src/webpub/WebPubFramePoolManager.ts

@@ -3,6 +3,7 @@ import { Locator, Publication } from "@readium/shared";
 import { WebPubBlobBuilder } from "./WebPubBlobBuilder";
 import { WebPubFrameManager } from "./WebPubFrameManager";
 import { Injector } from "../injection/Injector";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
 
 export class WebPubFramePoolManager {
     private readonly container: HTMLElement;
@@ -14,15 +15,21 @@ export class WebPubFramePoolManager {
     private pendingUpdates: Map<string, { inPool: boolean }> = new Map();
     private currentBaseURL: string | undefined;
     private readonly injector?: Injector | null = null;
+    private readonly contentProtectionConfig: IContentProtectionConfig;
+    private readonly keyboardPeripheralsConfig: IKeyboardPeripheralsConfig;
 
     constructor(
         container: HTMLElement, 
         cssProperties?: { [key: string]: string },
-        injector?: Injector | null
+        injector?: Injector | null,
+        contentProtectionConfig: IContentProtectionConfig = {},
+        keyboardPeripheralsConfig: IKeyboardPeripheralsConfig = []
     ) {
         this.container = container;
         this.currentCssProperties = cssProperties;
         this.injector = injector;
+        this.contentProtectionConfig = contentProtectionConfig;
+        this.keyboardPeripheralsConfig = [...keyboardPeripheralsConfig];
     }
 
     async destroy() {
@@ -147,7 +154,7 @@ export class WebPubFramePoolManager {
                     this.blobs.set(href, blobURL);
                 }
 
-                const fm = new WebPubFrameManager(this.blobs.get(href)!);
+                const fm = new WebPubFrameManager(this.blobs.get(href)!, this.contentProtectionConfig, this.keyboardPeripheralsConfig);
                 if(href !== newHref) await fm.hide();
                 this.container.appendChild(fm.iframe);
                 await fm.load(modules);

package/src/webpub/WebPubNavigator.ts

@@ -2,7 +2,7 @@ import { Feature, Link, Locator, Publication, ReadingProgression, LocatorLocatio
 import { VisualNavigator, VisualNavigatorViewport, ProgressionRange } from "../Navigator";
 import { Configurable } from "../preferences/Configurable";
 import { WebPubFramePoolManager } from "./WebPubFramePoolManager";
-import { BasicTextSelection, CommsEventKey, FrameClickEvent, ModuleLibrary, ModuleName, WebPubModules } from "@readium/navigator-html-injectables";
+import { BasicTextSelection, CommsEventKey, ContextMenuEvent, FrameClickEvent, KeyboardEventData, ModuleLibrary, ModuleName, SuspiciousActivityEvent, WebPubModules } from "@readium/navigator-html-injectables";
 import * as path from "path-browserify";
 import { WebPubFrameManager } from "./WebPubFrameManager";
 
@@ -17,11 +17,16 @@ import { WebPubPreferencesEditor } from "./preferences/WebPubPreferencesEditor";
 import { Injector } from "../injection/Injector";
 import { createReadiumWebPubRules } from "../injection/webpubInjectables";
 import { IInjectablesConfig } from "../injection/Injectable";
+import { IContentProtectionConfig, IKeyboardPeripheralsConfig } from "../Navigator";
+import { NavigatorProtector, NAVIGATOR_SUSPICIOUS_ACTIVITY_EVENT } from "../protection/NavigatorProtector";
+import { KeyboardPeripherals, NAVIGATOR_KEYBOARD_PERIPHERAL_EVENT } from "../peripherals/KeyboardPeripherals";
 
 export interface WebPubNavigatorConfiguration {
     preferences: IWebPubPreferences;
     defaults: IWebPubDefaults;
     injectables?: IInjectablesConfig;
+    contentProtection?: IContentProtectionConfig;
+    keyboardPeripherals?: IKeyboardPeripheralsConfig;
 }
 
 export interface WebPubNavigatorListeners {
@@ -34,6 +39,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;
 }
 
 const defaultListeners = (listeners: WebPubNavigatorListeners): WebPubNavigatorListeners => ({
@@ -45,7 +53,10 @@ const defaultListeners = (listeners: WebPubNavigatorListeners): WebPubNavigatorL
     scroll: listeners.scroll || (() => {}),
     customEvent: listeners.customEvent || (() => {}),
     handleLocator: listeners.handleLocator || (() => false),
-    textSelected: listeners.textSelected || (() => {})
+    textSelected: listeners.textSelected || (() => {}),
+    contentProtection: listeners.contentProtection || (() => {}),
+    contextMenu: listeners.contextMenu || (() => {}),
+    peripheral: listeners.peripheral || (() => {})
 })
 
 export class WebPubNavigator extends VisualNavigator implements Configurable<WebPubSettings, WebPubPreferences> {
@@ -62,6 +73,12 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
     private _css: WebPubCSS;
     private _preferencesEditor: WebPubPreferencesEditor | null = null;
     private readonly _injector: Injector | null = null;
+    private readonly _contentProtection: IContentProtectionConfig;
+    private readonly _keyboardPeripherals: IKeyboardPeripheralsConfig;
+    private readonly _navigatorProtector: NavigatorProtector | null = null;
+    private readonly _keyboardPeripheralsManager: KeyboardPeripherals | null = null;
+    private readonly _suspiciousActivityListener: ((event: Event) => void) | null = null;
+    private readonly _keyboardPeripheralListener: ((event: Event) => void) | null = null;
     
     private webViewport: VisualNavigatorViewport = {
         readingOrder: [],
@@ -85,7 +102,7 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
         });
 
         // Combine WebPub rules with user-provided injectables
-        const webpubRules = createReadiumWebPubRules();
+        const webpubRules = createReadiumWebPubRules(pub.readingOrder.items);
         const userConfig = configuration.injectables || { rules: [], allowedDomains: [] };
         
         this._injector = new Injector({
@@ -93,8 +110,47 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
             allowedDomains: userConfig.allowedDomains
         });
 
+        // Initialize content protection with provided config or default values
+        this._contentProtection = configuration.contentProtection || {};
+        
+        // Merge keyboard peripherals
+        this._keyboardPeripherals = this.mergeKeyboardPeripherals(
+            this._contentProtection,
+            configuration.keyboardPeripherals || []
+        );
+
+        // Initialize navigator protection if any protection is configured
+        if (this._contentProtection.disableContextMenu ||
+            this._contentProtection.checkAutomation ||
+            this._contentProtection.checkIFrameEmbedding ||
+            this._contentProtection.monitorDevTools ||
+            this._contentProtection.protectPrinting?.disable) {
+            this._navigatorProtector = new NavigatorProtector(this._contentProtection);
+            
+            // Listen for custom events from NavigatorProtector
+            this._suspiciousActivityListener = (event: Event) => {
+                const customEvent = event as CustomEvent;
+                this.listeners.contentProtection(customEvent.detail.type, customEvent.detail);
+            };
+            window.addEventListener(NAVIGATOR_SUSPICIOUS_ACTIVITY_EVENT, this._suspiciousActivityListener);
+        }
+        
+        // Initialize keyboard peripherals separately (works independently of protection)
+        if (this._keyboardPeripherals.length > 0) {
+            this._keyboardPeripheralsManager = new KeyboardPeripherals({
+                keyboardPeripherals: this._keyboardPeripherals
+            });
+            
+            // Listen for keyboard peripheral events from main window
+            this._keyboardPeripheralListener = (event: Event) => {
+                const activity = (event as CustomEvent).detail;
+                this.listeners.peripheral(activity);
+            };
+            window.addEventListener(NAVIGATOR_KEYBOARD_PERIPHERAL_EVENT, this._keyboardPeripheralListener);
+        }
+
         // Initialize current location
-        if (initialPosition && typeof initialPosition.copyWithLocations === 'function') {
+        if (initialPosition && typeof initialPosition.copyWithLocations === "function") {
             this.currentLocation = initialPosition;
             // Update currentIndex to match the initial position
             const index = this.pub.readingOrder.findIndexWithHref(initialPosition.href);
@@ -109,7 +165,13 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
     public async load() {
         await this.updateCSS(false);
         const cssProperties = this.compileCSSProperties(this._css);
-        this.framePool = new WebPubFramePoolManager(this.container, cssProperties, this._injector);
+        this.framePool = new WebPubFramePoolManager(
+            this.container, 
+            cssProperties, 
+            this._injector,
+            this._contentProtection,
+            this._keyboardPeripherals
+        );
 
         await this.apply();
     }
@@ -282,6 +344,16 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
             case "progress":
                 this.syncLocation(data as ProgressionRange);
                 break;
+            case "content_protection":
+                const activity = data as SuspiciousActivityEvent;
+                this.listeners.contentProtection(activity.type, activity);
+                break;
+            case "context_menu":
+                this.listeners.contextMenu(data as ContextMenuEvent);
+                break;
+            case "keyboard_peripherals":
+                this.listeners.peripheral(data as KeyboardEventData);
+                break;
             case "log":
                 console.log(this.framePool.currentFrames[0]?.source?.split("/")[3], ...(data as any[]));
                 break;
@@ -317,6 +389,14 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
     }
 
     public async destroy() {
+        if (this._suspiciousActivityListener) {
+            window.removeEventListener(NAVIGATOR_SUSPICIOUS_ACTIVITY_EVENT, this._suspiciousActivityListener);
+        }
+        if (this._keyboardPeripheralListener) {
+            window.removeEventListener(NAVIGATOR_KEYBOARD_PERIPHERAL_EVENT, this._keyboardPeripheralListener);
+        }
+        this._navigatorProtector?.destroy();
+        this._keyboardPeripheralsManager?.destroy();
         await this.framePool?.destroy();
     }
 
@@ -419,7 +499,7 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
 
     private async loadLocator(locator: Locator, cb: (ok: boolean) => void) {
         let done = false;
-        let cssSelector = (typeof locator.locations.getCssSelector === 'function') && locator.locations.getCssSelector();
+        let cssSelector = (typeof locator.locations.getCssSelector === "function") && locator.locations.getCssSelector();
         if(locator.text?.highlight) {
             done = await new Promise<boolean>((res, _) => {
                 // Attempt to go to a highlighted piece of text in the resource
@@ -451,7 +531,7 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
         // This sanity check has to be performed because we're still passing non-locator class
         // locator objects to this function. This is not good and should eventually be forbidden
         // or the locator should be deserialized sometime before this function.
-        const hid = (typeof locator.locations.htmlId === 'function') && locator.locations.htmlId();
+        const hid = (typeof locator.locations.htmlId === "function") && locator.locations.htmlId();
         if(hid)
             done = await new Promise<boolean>((res, _) => {
                 // Attempt to go to an HTML ID in the resource

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;
+}