@readium/navigator-html-injectables 2.2.4 → 2.3.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;
 }

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

@@ -0,0 +1,20 @@
+import { ReadiumWindow } from "../helpers/dom";
+export interface BulkCopyProtectionOptions {
+    enabled: boolean;
+    maxSelectionPercent: number;
+    absoluteMaxChars: number;
+    minThreshold: number;
+    historySize: number;
+}
+export declare class BulkCopyProtector {
+    private readonly window;
+    private options;
+    private copyHistory;
+    private lastSelectionLength;
+    private lastSelectionTime;
+    constructor(window: ReadiumWindow, options: BulkCopyProtectionOptions);
+    private cleanupOldHistory;
+    private isSuspiciousPattern;
+    shouldAllowCopy(event: ClipboardEvent): boolean;
+    destroy(): void;
+}

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

@@ -0,0 +1,33 @@
+import { KeyCombo, KeyboardPeripheral } from "./KeyboardCombinations";
+import { BaseKeyboardPeripheralEvent, KeyboardEventData } from "../modules/Peripherals";
+import { ReadiumWindow } from "../helpers/dom";
+export type KeyHandler = (event: KeyboardEvent) => void;
+export type ActivityEventDispatcher = (event: KeyboardPeripheralEvent) => void;
+export interface KeyboardPeripheralEvent extends BaseKeyboardPeripheralEvent, KeyboardEventData {
+    type: string;
+}
+export interface KeyComboWithHandler extends KeyCombo {
+    handler?: (event: KeyboardEvent) => void;
+}
+export declare class KeyCombinationManager {
+    /**
+     * Checks if the given keyboard event matches any of the provided key combinations
+     */
+    match(event: KeyboardEvent, combos: KeyCombo[]): boolean;
+    /**
+     * Creates an event handler that will call the provided handler when any of the key combinations match
+     */
+    createKeyHandler(combos: KeyCombo[], handler: KeyHandler): (event: KeyboardEvent) => void;
+    /**
+     * Creates a standardized activity event for keyboard shortcuts
+     */
+    private createActivityEvent;
+    /**
+     * Creates handlers for keyboard shortcuts with centralized activity event dispatch
+     */
+    createKeyboardHandlers(targetFrameSrc: string, shortcuts: KeyboardPeripheral[], dispatcher: ActivityEventDispatcher, wnd?: ReadiumWindow): KeyComboWithHandler[];
+    /**
+     * Creates a unified keyboard event handler that processes all shortcuts
+     */
+    createUnifiedHandler(targetFrameSrc: string, shortcuts: KeyboardPeripheral[], dispatcher: ActivityEventDispatcher, wnd?: ReadiumWindow): (event: KeyboardEvent) => void;
+}

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

@@ -0,0 +1,15 @@
+export interface KeyCombo {
+    keyCode: number;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+}
+export interface KeyboardPeripheral {
+    type: string;
+    keyCombos: KeyCombo[];
+}
+export declare const DEV_TOOLS: KeyboardPeripheral;
+export declare const SELECT_ALL: KeyboardPeripheral;
+export declare const PRINT: KeyboardPeripheral;
+export declare const SAVE: KeyboardPeripheral;

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

@@ -0,0 +1,18 @@
+type Direction = "left" | "right" | "up" | "down";
+export interface PatternAnalyzerOptions {
+    maxVelocity: number;
+    minVariance: number;
+    historySize?: number;
+    minDirectionChanges?: number;
+    maxConsistentScrolls?: number;
+}
+export declare class PatternAnalyzer {
+    private options;
+    private history;
+    private consistentScrollCount;
+    constructor(options?: Partial<PatternAnalyzerOptions>);
+    analyze(direction: Direction, distance: number, timeDelta: number): boolean;
+    private resetAfterDetection;
+    clear(): void;
+}
+export {};

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

@@ -0,0 +1,20 @@
+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 declare class PrintProtector extends Module {
+    static readonly moduleName: ModuleName;
+    private comms;
+    private wnd;
+    private styleElement;
+    private beforePrintHandler;
+    private configApplied;
+    private setupPrintProtection;
+    private registerPrintHandlers;
+    mount(wnd: ReadiumWindow, comms: Comms): boolean;
+    unmount(wnd: ReadiumWindow, _comms: Comms): boolean;
+}

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

@@ -0,0 +1,20 @@
+export interface SelectionAnalyzerOptions {
+    maxSelectionsPerSecond: number;
+    minVariance: number;
+    historySize: number;
+}
+export declare class SelectionAnalyzer {
+    private readonly options;
+    private events;
+    private selectionStartTime;
+    private lastSelectionTime;
+    private lastSelectionPosition;
+    private selectionPatterns;
+    private lastSelectedText;
+    constructor(options?: SelectionAnalyzerOptions);
+    analyze(selection: Selection | null): boolean;
+    private analyzeSelectionPattern;
+    private calculateVariance;
+    private cleanup;
+    clear(): void;
+}

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

@@ -0,0 +1,7 @@
+import { BulkCopyProtectionOptions } from "./BulkCopyProtector";
+import { PatternAnalyzerOptions } from "./PatternAnalyzer";
+import { SelectionAnalyzerOptions } from "./SelectionAnalyzer";
+export declare const DEFAULT_PATTERN_ANALYZER_CONFIG: PatternAnalyzerOptions;
+export declare const SCROLL_PROTECTION_CONFIG: PatternAnalyzerOptions;
+export declare const SELECTION_ANALYZER_CONFIG: SelectionAnalyzerOptions;
+export declare const BULK_COPY_CONFIG: BulkCopyProtectionOptions;

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

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

package/src/types/protection.ts

@@ -1,16 +0,0 @@
-type SuspiciousActivityType = 
-    | "developer_tools_attempt"
-    | "select_all_attempt"
-    | "suspicious_selection"
-    | "suspicious_copy"
-    | "suspicious_scrolling"
-    | "suspicious_snapping"
-    | "drag_detected"
-    | "drop_detected"
-    | "context_menu";
-
-export interface SuspiciousActivityEvent {
-    timestamp: number;
-    type: SuspiciousActivityType;
-    event?: Event;
-}