@readium/navigator-html-injectables 2.2.5 → 2.3.0

package/src/protection/KeyboardCombinations.ts

@@ -0,0 +1,60 @@
+export interface KeyCombo {
+    keyCode: number;  // Use stable keyCode that doesn't change across layouts
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+}
+
+export interface KeyboardPeripheral {
+    type: string;
+    keyCombos: KeyCombo[];
+}
+
+// Developer tools shortcuts as KeyboardPeripheral
+export const DEV_TOOLS: KeyboardPeripheral = {
+    type: "developer_tools",
+    keyCombos: [
+        { keyCode: 73, meta: true, alt: true },    // I key
+        { keyCode: 74, meta: true, alt: true },    // J key
+        { keyCode: 85, meta: true, alt: true },    // U key
+        { keyCode: 67, meta: true, alt: true },    // C key
+        { keyCode: 67, meta: true, shift: true },  // C key (Cmd+Shift+C)
+        { keyCode: 67, ctrl: true, shift: true },  // C key (Ctrl+Shift+C)
+        { keyCode: 123 },                          // F12
+        { keyCode: 123, shift: true },             // F12+Shift
+        { keyCode: 123, ctrl: true, shift: true }, // F12+Ctrl+Shift
+        { keyCode: 123, meta: true, alt: true },   // F12+Meta+Alt
+    ]
+};
+
+// Select all shortcuts as KeyboardPeripheral
+export const SELECT_ALL: KeyboardPeripheral = {
+    type: "select_all",
+    keyCombos: [
+        { keyCode: 65, meta: true },    // A key (Cmd+A)
+        { keyCode: 65, ctrl: true }     // A key (Ctrl+A)
+    ]
+};
+
+// Print shortcuts as KeyboardPeripheral
+export const PRINT: KeyboardPeripheral = {
+    type: "print",
+    keyCombos: [
+        { keyCode: 80, meta: true },                    // P key (Cmd+P)
+        { keyCode: 80, ctrl: true },                    // P key (Ctrl+P)
+        { keyCode: 80, meta: true, shift: true },       // P key (Cmd+Shift+P)
+        { keyCode: 80, ctrl: true, shift: true },       // P key (Ctrl+Shift+P)
+        { keyCode: 80, meta: true, alt: true },         // P key (Cmd+Alt+P)
+        { keyCode: 80, ctrl: true, alt: true }          // P key (Ctrl+Alt+P)
+    ]
+};
+
+// Save shortcuts as KeyboardPeripheral
+export const SAVE: KeyboardPeripheral = {
+    type: "save",
+    keyCombos: [
+        { keyCode: 83, meta: true },    // S key (Cmd+S)
+        { keyCode: 83, ctrl: true }     // S key (Ctrl+S)
+    ]
+};

package/src/protection/PatternAnalyzer.ts

@@ -0,0 +1,117 @@
+import { DEFAULT_PATTERN_ANALYZER_CONFIG } from "./config";
+
+type Direction = "left" | "right" | "up" | "down";
+
+export interface PatternAnalyzerOptions {
+    maxVelocity: number;          // pixels/ms
+    minVariance: number;          // 0-1
+    historySize?: number;         // Number of scroll events to keep in history
+    minDirectionChanges?: number; // Minimum ratio of direction changes to total events (0-1)
+    maxConsistentScrolls?: number; // Maximum number of consistent scrolls before flagging
+}
+
+// TODO: Improve for scroll protection, 
+// currently disabled because of false positives
+export class PatternAnalyzer {
+    private options: PatternAnalyzerOptions;
+    private history: Array<{
+        timestamp: number;
+        direction: Direction;
+        velocity: number;
+        distance: number;
+    }> = [];
+    
+    private consistentScrollCount = 0;
+    
+    constructor(
+        options: Partial<PatternAnalyzerOptions> = {}
+    ) {
+        // Merge provided options with default config
+        this.options = { ...DEFAULT_PATTERN_ANALYZER_CONFIG, ...options };
+    }
+
+    analyze(direction: Direction, distance: number, timeDelta: number): boolean {
+        if (timeDelta <= 0) return false;
+        
+        const velocity = Math.abs(distance) / timeDelta;
+        const now = Date.now();
+        
+        // Add new event
+        this.history.push({ 
+            timestamp: now, 
+            direction, 
+            velocity,
+            distance: Math.abs(distance)
+        });
+        
+        // Clean up old events (keep last 2 seconds of data or historySize, whichever is smaller)
+        this.history = this.history
+            .filter(h => now - h.timestamp < 2000)
+            .slice(-(this.options.historySize || 20));
+
+        // Need at least 3 events to start detecting patterns
+        if (this.history.length < 3) return false;
+
+        // 1. Check for excessive speed (unrealistically fast scrolling)
+        if (velocity > this.options.maxVelocity) {
+            this.resetAfterDetection();
+            return true;
+        }
+
+        // 2. Check for consistent scrolling patterns
+        const velocities = this.history.map(h => h.velocity);
+        const distances = this.history.map(h => h.distance);
+        
+        // Calculate mean and variance of velocities and distances
+        const meanVelocity = velocities.reduce((a, b) => a + b, 0) / velocities.length;
+        const meanDistance = distances.reduce((a, b) => a + b, 0) / distances.length;
+        
+        const velocityVariance = velocities.reduce((a, b) => a + Math.pow(b - meanVelocity, 2), 0) / velocities.length;
+        const distanceVariance = distances.reduce((a, b) => a + Math.pow(b - meanDistance, 2), 0) / distances.length;
+
+        // Check for suspiciously consistent scrolling (low variance in speed and distance)
+        if (velocityVariance < this.options.minVariance && 
+            distanceVariance < (meanDistance * 0.1)) { // Allow 10% variance in distance
+            this.consistentScrollCount++;
+            
+            // Only trigger if we've seen consistent scrolling for a while
+            if (this.consistentScrollCount >= (this.options.maxConsistentScrolls || 10)) {
+                this.resetAfterDetection();
+                return true;
+            }
+        } else {
+            // Reset counter if pattern breaks
+            this.consistentScrollCount = Math.max(0, this.consistentScrollCount - 1);
+        }
+
+        // 3. Check for rapid direction changes (unnatural back-and-forth scrolling)
+        let directionChanges = 0;
+        let lastDirection = this.history[0].direction;
+        
+        for (let i = 1; i < this.history.length; i++) {
+            if (this.history[i].direction !== lastDirection) {
+                directionChanges++;
+                lastDirection = this.history[i].direction;
+            }
+        }
+        
+        const directionChangeRatio = directionChanges / this.history.length;
+        if (directionChangeRatio > (this.options.minDirectionChanges || 0.3)) {
+            this.resetAfterDetection();
+            return true;
+        }
+
+        return false;
+    }
+
+    private resetAfterDetection(): void {
+        // Keep some history to prevent immediate re-triggering
+        this.history = this.history.slice(-3);
+        this.consistentScrollCount = 0;
+    }
+    
+    clear(): void {
+        this.history = [];
+        this.consistentScrollCount = 0;
+    }
+}

package/src/protection/PrintProtector.ts

@@ -0,0 +1,87 @@
+import { Comms } from "../comms";
+import { ReadiumWindow } from "../helpers/dom";
+import { Module } from "../modules/Module";
+import { ModuleName } from "../modules/ModuleLibrary";
+
+export interface PrintProtectionConfig {
+    disable?: boolean;
+    watermark?: string;
+}
+
+export class PrintProtector extends Module {
+    static readonly moduleName: ModuleName = "print_protection";
+    
+    private comms!: Comms;
+    private wnd!: ReadiumWindow;
+    private styleElement: HTMLStyleElement | null = null;
+    private beforePrintHandler: ((e: Event) => void) | null = null;
+    private configApplied = false;
+
+    private setupPrintProtection(wnd: Window, config: PrintProtectionConfig) {
+        if (!config.disable) return;
+
+        const style = wnd.document.createElement("style");
+        style.textContent = `
+            @media print {
+                body * {
+                    display: none !important;
+                }
+                body::after {
+                    content: "${config.watermark || 'Printing has been disabled'}";
+                    font-size: 200%;
+                    display: block;
+                    text-align: center;
+                    margin-top: 50vh;
+                    transform: translateY(-50%);
+                }
+            }
+        `;
+        wnd.document.head.appendChild(style);
+        this.styleElement = style;
+
+        this.beforePrintHandler = (e: Event) => {
+            e.preventDefault();
+            return false;
+        };
+        wnd.addEventListener("beforeprint", this.beforePrintHandler);
+    }
+
+    private registerPrintHandlers() {        
+        this.comms?.register("print_protection", PrintProtector.moduleName, (data: unknown) => {
+            const config = data as PrintProtectionConfig;
+            
+            if (!this.configApplied) {
+                this.configApplied = true;
+                this.setupPrintProtection(this.wnd, config);
+                this.comms?.log("Print protection configuration applied");
+            }
+            
+            return true;
+        });
+    }
+
+    mount(wnd: ReadiumWindow, comms: Comms): boolean {
+        this.wnd = wnd;
+        this.comms = comms;
+        this.registerPrintHandlers();
+        return true;
+    }
+
+    unmount(wnd: ReadiumWindow, _comms: Comms): boolean {
+        if (this.beforePrintHandler) {
+            wnd.removeEventListener("beforeprint", this.beforePrintHandler);
+            this.beforePrintHandler = null;
+        }
+        
+        if (this.styleElement?.parentNode) {
+            this.styleElement.parentNode.removeChild(this.styleElement);
+            this.styleElement = null;
+        }
+        
+        // Unregister all print protection handlers
+        this.comms?.unregisterAll(PrintProtector.moduleName);
+        
+        this.configApplied = false;
+        return true;
+    }
+}

package/src/protection/SelectionAnalyzer.ts

@@ -0,0 +1,133 @@
+interface SelectionEvent {
+    timestamp: number;
+    position: number;
+    length: number;
+}
+
+export interface SelectionAnalyzerOptions {
+    maxSelectionsPerSecond: number;
+    minVariance: number;
+    historySize: number;
+}
+
+import { SELECTION_ANALYZER_CONFIG } from './config';
+
+export class SelectionAnalyzer {
+    private events: SelectionEvent[] = [];
+    private selectionStartTime = 0;
+    private lastSelectionTime = 0;
+    private lastSelectionPosition = 0;
+    private selectionPatterns: number[] = [];
+    private lastSelectedText = "";
+
+    constructor(
+        private readonly options: SelectionAnalyzerOptions = SELECTION_ANALYZER_CONFIG
+    ) {}
+
+    public analyze(selection: Selection | null): boolean {
+        if (!selection) {
+            this.clear();
+            return false;
+        }
+
+        const selectedText = selection.toString();
+        if (selectedText.length === 0) {
+            this.clear();
+            return false;
+        }
+
+        if (selection.type !== "Range" || !selection.rangeCount) {
+            return false;
+        }
+
+        const now = Date.now();
+
+        // Only analyze meaningful selections (not too short, not duplicates)
+        if (selectedText.length <= 50 || selectedText === this.lastSelectedText) {
+            return false;
+        }
+
+        // Start timing if this is a new selection
+        if (this.selectionStartTime === 0) {
+            this.selectionStartTime = now;
+            this.lastSelectedText = selectedText;
+            return false; // Don't analyze first selection, just track it
+        }
+
+        // Check if enough time has passed for selection to be complete
+        const timeSinceStart = now - this.selectionStartTime;
+        if (timeSinceStart < 500) {
+            return false; // Still selecting, wait longer
+        }
+
+        // Track selection frequency
+        if (now - this.lastSelectionTime > 1000) {
+            this.lastSelectionTime = now;
+        }
+
+        if (this.selectionStartTime === 0) {
+            this.selectionStartTime = now;
+        }
+
+        // Store current selection for comparison
+        this.lastSelectedText = selectedText;
+
+        // Analyze selection pattern
+        const isSuspicious = this.analyzeSelectionPattern(selection, now);
+
+        // Clean up old events
+        this.cleanup(now);
+
+        return isSuspicious;
+    }
+
+    private analyzeSelectionPattern(selection: Selection, now: number): boolean {
+        if (!selection.rangeCount) return false;
+        
+        const range = selection.getRangeAt(0);
+        const text = range.toString();
+        
+        // Calculate selection speed (characters per second)
+        const duration = (now - this.selectionStartTime) / 1000; // Convert to seconds
+        const speed = text.length / Math.max(1, duration); // Characters per second
+        
+        // Check for unnaturally fast selection
+        if (speed > this.options.maxSelectionsPerSecond) return true;
+        
+        // Analyze selection pattern (human selections have more variance)
+        const currentPosition = range.startOffset;
+        const distance = Math.abs(currentPosition - this.lastSelectionPosition);
+        this.selectionPatterns.push(distance);
+        
+        if (this.selectionPatterns.length > this.options.historySize) {
+            this.selectionPatterns.shift();
+            const variance = this.calculateVariance(this.selectionPatterns);
+            if (variance < this.options.minVariance) { // Very consistent patterns suggest automation
+                return true;
+            }
+        }
+        
+        this.lastSelectionPosition = currentPosition;
+        return false;
+    }
+
+    private calculateVariance(numbers: number[]): number {
+        if (numbers.length === 0) return 0;
+        const mean = numbers.reduce((a, b) => a + b, 0) / numbers.length;
+        return numbers.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / numbers.length;
+    }
+
+    private cleanup(now: number): void {
+        // Keep events from the last second
+        this.events = this.events.filter(e => now - e.timestamp <= 1000);
+    }
+
+    public clear(): void {
+        this.events = [];
+        this.selectionStartTime = 0;
+        this.lastSelectionTime = 0;
+        this.lastSelectionPosition = 0;
+        this.selectionPatterns = [];
+        this.lastSelectedText = "";
+    }
+}

package/src/protection/config.ts

@@ -0,0 +1,33 @@
+import { BulkCopyProtectionOptions } from "./BulkCopyProtector";
+import { PatternAnalyzerOptions } from "./PatternAnalyzer";
+import { SelectionAnalyzerOptions } from "./SelectionAnalyzer";
+
+export const DEFAULT_PATTERN_ANALYZER_CONFIG: PatternAnalyzerOptions = {
+    maxVelocity: 200,         // Reasonable default for human-like scrolling (pixels/ms)
+    minVariance: 0.01,        // Default variance threshold
+    historySize: 20,          // Balanced history size for performance
+    minDirectionChanges: 0.2, // Reasonable default for detecting patterns
+    maxConsistentScrolls: 15  // Balanced threshold for flagging
+};
+
+export const SCROLL_PROTECTION_CONFIG: PatternAnalyzerOptions = {
+    maxVelocity: 200,         // Extremely fast scrolling (pixels/ms)
+    minVariance: 0.00001,     // Near-perfect consistency
+    historySize: 100,         // Large history window
+    minDirectionChanges: 0.1, // Only trigger on near-perfect patterns
+    maxConsistentScrolls: 20  // Need many consistent scrolls
+};
+
+export const SELECTION_ANALYZER_CONFIG: SelectionAnalyzerOptions = {
+    maxSelectionsPerSecond: 500,
+    minVariance: 50,
+    historySize: 20
+};
+
+export const BULK_COPY_CONFIG: BulkCopyProtectionOptions = {
+    enabled: true,
+    maxSelectionPercent: 0.1,
+    minThreshold: 100,
+    absoluteMaxChars: 5000,
+    historySize: 20
+}

package/src/protection/index.ts

@@ -0,0 +1,6 @@
+export * from "./BulkCopyProtector";
+export * from "./KeyCombinationManager";
+export * from "./KeyboardCombinations";
+export * from "./PatternAnalyzer";
+export * from "./SelectionAnalyzer";
+export * from "./PrintProtector";

package/types/src/comms/keys.d.ts

@@ -1,2 +1,3 @@
-export type CommsEventKey = "_pong" | "_unhandled" | "_ack" | "log" | "error" | "click" | "tap" | "tap_more" | "no_more" | "no_less" | "swipe" | "scroll" | "progress" | "first_visible_locator" | "text_selected" | "media_play" | "media_pause";
-export type CommsCommandKey = "_ping" | "go_prev" | "go_next" | "go_id" | "go_text" | "go_end" | "go_start" | "go_progression" | "get_properties" | "update_properties" | "set_property" | "remove_property" | "first_visible_locator" | "decorate" | "protect" | "unprotect" | "unfocus" | "focus" | "activate" | "shake" | "force_webkit_recalc";
+export type CommsEventKey = "_pong" | "_unhandled" | "_ack" | "log" | "error" | "click" | "tap" | "tap_more" | "no_more" | "no_less" | "swipe" | "scroll" | "progress" | "first_visible_locator" | "text_selected" | "context_menu" | "media_play" | "media_pause" | "content_protection" | "keyboard_peripherals";
+export type CommsCommandKey = "_ping" | "go_prev" | "go_next" | "go_id" | "go_text" | "go_end" | "go_start" | "go_progression" | "get_properties" | "update_properties" | "set_property" | "remove_property" | "first_visible_locator" | "decorate" | "protect" | "unprotect" | "unfocus" | "focus" | "activate" | "shake" | "force_webkit_recalc" | "peripherals_protection" | "keyboard_peripherals" | "scroll_protection" | "print_protection";
+export type SuspiciousActivityType = "developer_tools" | "select_all" | "save" | "suspicious_selection" | "bulk_copy" | "suspicious_scrolling" | "suspicious_snapping" | "drag_detected" | "drop_detected" | "print";

package/types/src/index.d.ts

@@ -1,3 +1,4 @@
 export * from './comms';
 export * from './modules';
 export * from './Loader';
+export * from './protection';

package/types/src/modules/ModuleLibrary.d.ts

@@ -1,5 +1,5 @@
 import { ModuleDerived } from "./Module";
-export type ModuleName = "setup" | "snapper" | "column_snapper" | "scroll_snapper" | "webpub_snapper" | "fixed_setup" | "decorator" | "reflowable_setup" | "peripherals" | "webpub_setup";
+export type ModuleName = "setup" | "snapper" | "column_snapper" | "scroll_snapper" | "webpub_snapper" | "fixed_setup" | "decorator" | "reflowable_setup" | "peripherals" | "webpub_setup" | "print_protection";
 export declare const FXLModules: ModuleName[];
 export declare const ReflowableModules: ModuleName[];
 export declare const WebPubModules: ModuleName[];

package/types/src/modules/Peripherals.d.ts

@@ -1,6 +1,12 @@
 import { Comms } from "../comms/comms";
 import { Module } from "./Module";
 import { ReadiumWindow } from "../helpers/dom";
+import { BulkCopyProtectionOptions } from "../protection/BulkCopyProtector";
+import { SelectionAnalyzerOptions } from "../protection/SelectionAnalyzer";
+import { SuspiciousActivityType } from "../comms";
+import { KeyboardPeripheralEvent } from "../protection/KeyCombinationManager";
+import { SuspiciousScrollingEvent } from "./snapper/ScrollSnapper";
+import { SuspiciousSnappingEvent } from "./snapper/ColumnSnapper";
 export interface FrameClickEvent {
     defaultPrevented: boolean;
     doNotDisturb: boolean;
@@ -19,21 +25,115 @@ export interface BasicTextSelection {
     height: number;
     targetFrameSrc: string;
 }
+export interface BaseSuspiciousActivityEvent {
+    type: SuspiciousActivityType;
+    timestamp: number;
+    targetFrameSrc: string;
+}
+export interface KeyboardEventData {
+    key: string;
+    code: string;
+    keyCode: number;
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    metaKey: boolean;
+}
+export interface BaseKeyboardPeripheralEvent {
+    type: string;
+    timestamp: number;
+    targetFrameSrc: string;
+    selectedText?: Omit<BasicTextSelection, "targetFrameSrc">;
+}
+export interface DeveloperToolsEvent extends BaseSuspiciousActivityEvent, KeyboardEventData {
+    type: "developer_tools";
+}
+export interface SelectAllEvent extends BaseSuspiciousActivityEvent, KeyboardEventData {
+    type: "select_all";
+}
+export interface PrintEvent extends BaseSuspiciousActivityEvent, KeyboardEventData {
+    type: "print";
+}
+export interface SaveEvent extends BaseSuspiciousActivityEvent, KeyboardEventData {
+    type: "save";
+}
+export interface BulkCopyEvent extends BaseSuspiciousActivityEvent {
+    type: "bulk_copy";
+    clipboardTypes: readonly string[];
+    selectedText?: Omit<BasicTextSelection, "targetFrameSrc">;
+    selectionLength?: number;
+}
+export interface SuspiciousSelectionEvent extends BaseSuspiciousActivityEvent {
+    type: "suspicious_selection";
+    selectionLength: number;
+    selectedText: Omit<BasicTextSelection, "targetFrameSrc">;
+    eventType: string;
+}
+export interface DragDetectedEvent extends BaseSuspiciousActivityEvent {
+    type: "drag_detected";
+    dataTransferTypes: readonly string[];
+}
+export interface DropDetectedEvent extends BaseSuspiciousActivityEvent {
+    type: "drop_detected";
+    dataTransferTypes: readonly string[];
+    fileCount: number;
+}
+export interface ContextMenuEvent extends Omit<BaseSuspiciousActivityEvent, "type"> {
+    clientX: number;
+    clientY: number;
+    selectedText?: Omit<BasicTextSelection, "targetFrameSrc">;
+}
+export type SuspiciousActivityEvent = DeveloperToolsEvent | SelectAllEvent | BulkCopyEvent | SuspiciousSelectionEvent | DragDetectedEvent | DropDetectedEvent | PrintEvent | SaveEvent | SuspiciousScrollingEvent | SuspiciousSnappingEvent | KeyboardPeripheralEvent;
+export interface ContentProtectionConfig {
+    monitorSelection?: boolean | SelectionAnalyzerOptions;
+    protectCopy?: boolean | Omit<BulkCopyProtectionOptions, "enabled">;
+    disableContextMenu?: boolean;
+    disableDragAndDrop?: boolean;
+    disableSelectAll?: boolean;
+    disableSave?: boolean;
+    monitorDevTools?: boolean;
+    monitorScrollingExperimental?: boolean;
+}
 export declare class Peripherals extends Module {
     static readonly moduleName = "peripherals";
     private wnd;
     private comms;
+    private configApplied;
+    private cleanupCallbacks;
     private pointerMoved;
+    private isContextMenuEnabled;
+    private isDragAndDropEnabled;
+    private isSelectionMonitoringEnabled;
+    private isBulkCopyProtectionEnabled;
+    private selectionAnalyzer;
+    private currentSelection;
+    private bulkCopyProtector;
+    private keyManager;
+    private addContextMenuPrevention;
+    private removeContextMenuPrevention;
+    private addDragAndDropPrevention;
+    private removeDragAndDropPrevention;
+    private keyDownHandler;
+    private enableKeyboardPeripherals;
+    private disableKeyboardPeripherals;
+    private addBulkCopyProtection;
+    private removeBulkCopyProtection;
+    private preventBulkCopy;
+    private handleSelection;
+    private addSelectionMonitoring;
+    private removeSelectionMonitoring;
+    private onDragStart;
+    private onDrop;
+    private onContext;
     onPointUp(event: PointerEvent): void;
     private readonly onPointerUp;
     onPointMove(event: PointerEvent): void;
     private readonly onPointerMove;
     onPointDown(): void;
     private readonly onPointerDown;
-    onContext(event: MouseEvent): void;
-    private readonly onContextMenu;
     onClick(event: MouseEvent): void;
     private readonly onClicker;
+    private registerProtectionHandlers;
     mount(wnd: ReadiumWindow, comms: Comms): boolean;
     unmount(wnd: ReadiumWindow, comms: Comms): boolean;
 }

package/types/src/modules/snapper/ColumnSnapper.d.ts

@@ -2,13 +2,21 @@ import { Comms } from "../../comms";
 import { Snapper } from "./Snapper";
 import { ModuleName } from "../ModuleLibrary";
 import { ReadiumWindow } from "../../helpers/dom";
+import { BaseSuspiciousActivityEvent } from "../Peripherals";
+export interface SuspiciousSnappingEvent extends BaseSuspiciousActivityEvent {
+    type: "suspicious_snapping";
+    event: null;
+}
 /**
  * A {Snapper} for reflowable resources using a column-based layout
  */
 export declare class ColumnSnapper extends Snapper {
     static readonly moduleName: ModuleName;
+    private isSnapProtectionEnabled;
     private resizeObserver;
     private mutationObserver;
+    private patternAnalyzer;
+    private lastTurnTime;
     private wnd;
     private comms;
     private doc;
@@ -36,6 +44,8 @@ export declare class ColumnSnapper extends Snapper {
     private readonly onWidthChanger;
     onTouchMove(e: TouchEvent): void;
     private readonly onTouchMover;
+    private enableSnapProtection;
+    private checkSuspiciousSnap;
     mount(wnd: ReadiumWindow, comms: Comms): boolean;
     unmount(wnd: ReadiumWindow, comms: Comms): boolean;
 }

package/types/src/modules/snapper/ScrollSnapper.d.ts

@@ -2,11 +2,23 @@ import { Comms } from "../../comms";
 import { ReadiumWindow } from "../../helpers/dom";
 import { ModuleName } from "../ModuleLibrary";
 import { Snapper } from "./Snapper";
+import { BaseSuspiciousActivityEvent } from "../Peripherals";
+export interface SuspiciousScrollingEvent extends BaseSuspiciousActivityEvent {
+    type: "suspicious_scrolling";
+    scrollDelta: number;
+    scrollDirection: "up" | "down";
+    targetElement: {
+        tagName: string;
+    } | null;
+}
 export declare class ScrollSnapper extends Snapper {
     static readonly moduleName: ModuleName;
     private wnd;
     private comms;
     private resizeObserver;
+    private patternAnalyzer;
+    private lastScrollTime;
+    private isScrollProtectionEnabled;
     private initialScrollHandled;
     private isScrolling;
     private lastScrollTop;
@@ -15,6 +27,7 @@ export declare class ScrollSnapper extends Snapper {
     private doc;
     private reportProgress;
     private handleScroll;
+    private enableScrollProtection;
     mount(wnd: ReadiumWindow, comms: Comms): boolean;
     unmount(wnd: ReadiumWindow, comms: Comms): boolean;
 }

package/types/src/modules/snapper/WebPubSnapper.d.ts

@@ -2,11 +2,16 @@ import { Comms } from "../../comms/comms";
 import { ReadiumWindow } from "../../helpers/dom";
 import { ModuleName } from "../ModuleLibrary";
 import { Snapper } from "./Snapper";
+import { SuspiciousScrollingEvent } from "./ScrollSnapper";
+export type { SuspiciousScrollingEvent };
 export declare class WebPubSnapper extends Snapper {
     static readonly moduleName: ModuleName;
     private wnd;
     private comms;
     private resizeObserver;
+    private patternAnalyzer;
+    private lastScrollTime;
+    private isScrollProtectionEnabled;
     private initialScrollHandled;
     private isScrolling;
     private lastScrollTop;
@@ -15,6 +20,7 @@ export declare class WebPubSnapper extends Snapper {
     private doc;
     private reportProgress;
     private handleScroll;
+    private enableScrollProtection;
     mount(wnd: ReadiumWindow, comms: Comms): boolean;
     unmount(wnd: ReadiumWindow, comms: Comms): boolean;
 }