@readium/navigator-html-injectables 2.2.4 → 2.3.0

package/src/modules/Peripherals.ts

@@ -1,6 +1,20 @@
 import { Comms } from "../comms/comms";
 import { Module } from "./Module";
 import { ReadiumWindow, nearestInteractiveElement } from "../helpers/dom";
+import { BulkCopyProtector, BulkCopyProtectionOptions } from "../protection/BulkCopyProtector";
+import { SelectionAnalyzer, SelectionAnalyzerOptions } from "../protection/SelectionAnalyzer";
+import { 
+    KeyboardPeripheral 
+} from "../protection";
+import { SuspiciousActivityType } from "../comms";
+import { BULK_COPY_CONFIG, SELECTION_ANALYZER_CONFIG } from "../protection/config";
+import { 
+    KeyCombinationManager, 
+    ActivityEventDispatcher,
+    KeyboardPeripheralEvent
+} from "../protection/KeyCombinationManager";
+import { SuspiciousScrollingEvent } from "./snapper/ScrollSnapper";
+import { SuspiciousSnappingEvent } from "./snapper/ColumnSnapper";
 
 export interface FrameClickEvent {
     defaultPrevented: boolean;
@@ -22,12 +36,363 @@ export interface BasicTextSelection {
     targetFrameSrc: string;
 }
 
+export interface BaseSuspiciousActivityEvent {
+    type: SuspiciousActivityType;
+    timestamp: number;
+    targetFrameSrc: string;
+}
+
+// Common interface for all keyboard-related events
+export interface KeyboardEventData {
+    key: string;
+    code: string;
+    keyCode: number;
+    ctrlKey: boolean;
+    altKey: boolean;
+    shiftKey: boolean;
+    metaKey: boolean;
+}
+
+// Base interface for keyboard peripheral events
+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 class Peripherals extends Module {
     static readonly moduleName = "peripherals";
     private wnd!: ReadiumWindow;
     private comms!: Comms;
+    private configApplied = false; // Track if config has been applied
 
+    // State management
+    private cleanupCallbacks: (() => void)[] = [];
     private pointerMoved = false;
+    
+    // Feature flags
+    private isContextMenuEnabled = false;
+    private isDragAndDropEnabled = false;
+    private isSelectionMonitoringEnabled = false;
+    private isBulkCopyProtectionEnabled = false;
+    
+    // Selection analysis
+    private selectionAnalyzer: SelectionAnalyzer | null = null;
+    private currentSelection: string | null = null;
+    
+    // Bulk copy protection
+    private bulkCopyProtector: BulkCopyProtector | null = null;
+    
+    // Key combination manager
+    private keyManager = new KeyCombinationManager();
+
+    private addContextMenuPrevention(): void {
+        if (this.isContextMenuEnabled || !this.wnd) return;
+        this.wnd.document.addEventListener("contextmenu", this.onContext);
+        this.isContextMenuEnabled = true;
+    }
+
+    private removeContextMenuPrevention(): void {
+        if (!this.isContextMenuEnabled || !this.wnd) return;
+        this.wnd.document.removeEventListener("contextmenu", this.onContext);
+        this.isContextMenuEnabled = false;
+    }
+
+    private addDragAndDropPrevention(): void {
+        if (this.isDragAndDropEnabled || !this.wnd) return;
+        this.wnd.document.addEventListener("dragstart", this.onDragStart);
+        this.wnd.document.addEventListener("drop", this.onDrop);
+        this.isDragAndDropEnabled = true;
+    }
+
+    private removeDragAndDropPrevention(): void {
+        if (!this.isDragAndDropEnabled || !this.wnd) return;
+        this.wnd.document.removeEventListener("dragstart", this.onDragStart);
+        this.wnd.document.removeEventListener("drop", this.onDrop);
+        this.isDragAndDropEnabled = false;
+    }
+
+    private keyDownHandler: ((event: KeyboardEvent) => void) | null = null;
+
+    private enableKeyboardPeripherals(shortcuts: KeyboardPeripheral[] = []): void {
+        // Clear any existing state
+        this.disableKeyboardPeripherals();
+        
+        // Create activity event dispatcher
+        const dispatcher: ActivityEventDispatcher = (activityEvent) => {
+            this.comms?.send("keyboard_peripherals", activityEvent);
+        };
+        
+        // Create unified handler using centralized KeyCombinationManager
+        this.keyDownHandler = this.keyManager.createUnifiedHandler(this.wnd.location.href, shortcuts, dispatcher, this.wnd);
+        
+        // Add the event listener
+        if (this.wnd) {
+            this.wnd.document.addEventListener("keydown", this.keyDownHandler, {
+                capture: true
+            });
+        }
+    }
+    
+    private disableKeyboardPeripherals(): void {
+        if (this.wnd && this.keyDownHandler) {
+            this.wnd.document.removeEventListener("keydown", this.keyDownHandler, {
+                capture: true
+            });
+            this.keyDownHandler = null;
+        }
+    }
+
+    private addBulkCopyProtection(options: Partial<BulkCopyProtectionOptions> = {}): void {
+        if (this.isBulkCopyProtectionEnabled || !this.wnd) return;
+        
+        const defaultOptions = BULK_COPY_CONFIG;
+        
+        const finalOptions = options ? { ...defaultOptions, ...options } : defaultOptions;
+        
+        this.bulkCopyProtector = new BulkCopyProtector(this.wnd, finalOptions);
+        this.wnd.document.addEventListener("copy", this.preventBulkCopy, true);
+        this.wnd.document.addEventListener("cut", this.preventBulkCopy, true);
+        this.isBulkCopyProtectionEnabled = true;
+    }
+
+    private removeBulkCopyProtection(): void {
+        if (!this.isBulkCopyProtectionEnabled || !this.wnd) return;
+        
+        this.wnd.document.removeEventListener("copy", this.preventBulkCopy, true);
+        this.wnd.document.removeEventListener("cut", this.preventBulkCopy, true);
+        this.bulkCopyProtector?.destroy();
+        this.bulkCopyProtector = null;
+        this.isBulkCopyProtectionEnabled = false;
+    }
+
+    private preventBulkCopy = (event: ClipboardEvent) => {
+        if (!this.isBulkCopyProtectionEnabled || !this.bulkCopyProtector) {
+            return true;
+        }
+        
+        if (!this.bulkCopyProtector.shouldAllowCopy(event)) {
+            event.preventDefault();
+            
+            const selection = this.wnd.getSelection();
+            const selectedText = selection?.toString() || '';
+            const domRectList = selectedText ? selection?.getRangeAt(0)?.getClientRects() : null;
+            const rect = domRectList?.[0];
+            
+            const activityEvent: BulkCopyEvent = {
+                type: "bulk_copy",
+                timestamp: Date.now(),
+                clipboardTypes: event.clipboardData?.types ? [...event.clipboardData.types] : [],
+                selectedText: rect ? {
+                    text: selectedText,
+                    x: rect.x,
+                    y: rect.y,
+                    width: rect.width,
+                    height: rect.height
+                } : undefined,
+                selectionLength: selectedText.length,
+                targetFrameSrc: this.wnd.location.href
+
+            };
+            this.comms?.send("content_protection", activityEvent);
+            return false;
+        }
+        return true;
+    };
+
+    private handleSelection = (event?: Event) => {
+        if (!this.isSelectionMonitoringEnabled || !this.wnd || !this.selectionAnalyzer) {
+            return;
+        }
+        
+        const selection = this.wnd.getSelection();
+        if (selection) {
+            this.currentSelection = selection.toString();
+            const isSuspicious = this.selectionAnalyzer.analyze(selection);
+            
+            if (isSuspicious && this.currentSelection) {
+                const selection = this.wnd.getSelection();
+                const selectedText = selection?.toString() || '';
+                const domRectList = (selectedText && selection?.rangeCount) ? selection.getRangeAt(0)?.getClientRects() : null;
+                const rect = domRectList?.[0];
+                
+                const activityEvent: SuspiciousSelectionEvent = {
+                    type: "suspicious_selection",
+                    timestamp: Date.now(),
+                    selectionLength: selectedText.length,
+                        selectedText: {
+                        text: selectedText,
+                        x: rect?.x ?? 0,
+                        y: rect?.y ?? 0,
+                        width: rect?.width ?? 0,
+                        height: rect?.height ?? 0
+                    },
+                    eventType: event?.type || "selectionchange",
+                    targetFrameSrc: this.wnd.location.href
+                };
+                this.comms?.send("content_protection", activityEvent);
+            }
+        } else {
+            this.currentSelection = null;
+        }
+    };
+
+    private addSelectionMonitoring(options?: SelectionAnalyzerOptions): void {
+        if (this.isSelectionMonitoringEnabled || !this.wnd) return;
+        
+        // Use provided options or fall back to default config
+        const analyzerOptions = options || SELECTION_ANALYZER_CONFIG;
+        this.selectionAnalyzer = new SelectionAnalyzer(analyzerOptions);
+        this.wnd.document.addEventListener("selectionchange", this.handleSelection);
+        this.isSelectionMonitoringEnabled = true;
+    }
+    
+    private removeSelectionMonitoring(): void {
+        if (!this.isSelectionMonitoringEnabled || !this.wnd) {
+            return;
+        }
+        
+        this.wnd.document.removeEventListener("selectionchange", this.handleSelection);
+        this.selectionAnalyzer?.clear();
+        this.selectionAnalyzer = null;
+        this.isSelectionMonitoringEnabled = false;
+    }
+
+    private onDragStart = (event: DragEvent) => {
+        if (this.isDragAndDropEnabled) {
+            // Drag and drop protection is enabled - prevent it
+            event.preventDefault();
+            const activityEvent: DragDetectedEvent = {
+                type: "drag_detected",
+                timestamp: Date.now(),
+                dataTransferTypes: event.dataTransfer?.types ? [...event.dataTransfer.types] : [],
+                targetFrameSrc: this.wnd.location.href
+            };
+            this.comms?.send("content_protection", activityEvent);
+            return false;
+        } else {
+            return true;
+        }
+    };
+
+    private onDrop = (event: DragEvent) => {
+        if (this.isDragAndDropEnabled) {
+            // Drag and drop protection is enabled - prevent it
+            event.preventDefault();
+            const dataTransfer = event.dataTransfer;
+            const activityEvent: DropDetectedEvent = {
+                type: "drop_detected",
+                timestamp: Date.now(),
+                dataTransferTypes: dataTransfer?.types ? [...dataTransfer.types] : [],
+                fileCount: dataTransfer?.files?.length || 0,
+                targetFrameSrc: this.wnd.location.href
+            };
+            this.comms?.send("content_protection", activityEvent);
+            return false;
+        } else {
+            return true;
+        }
+    };
+
+    private onContext = (event: MouseEvent) => {
+        if (this.isContextMenuEnabled) {
+            // Context menu protection is enabled - prevent it
+            event.preventDefault();
+            const selection = this.wnd.getSelection();
+            const selectedText = selection?.toString() || '';
+            const domRectList = (selectedText && selection?.rangeCount) ? selection.getRangeAt(0)?.getClientRects() : null;
+            const rect = domRectList?.[0];
+            
+            const activityEvent: ContextMenuEvent = {
+                timestamp: Date.now(),
+                clientX: event.clientX,
+                clientY: event.clientY,
+                ...(rect && {
+                    selectedText: {
+                        text: selectedText,
+                        x: rect.x,
+                        y: rect.y,
+                        width: rect.width,
+                        height: rect.height
+                    }
+                }),
+                targetFrameSrc: this.wnd.location.href
+            };
+            this.comms?.send("context_menu", activityEvent);
+        }
+    };
 
     onPointUp(event: PointerEvent) {
         const selection = this.wnd.getSelection();
@@ -44,7 +409,7 @@ export class Peripherals extends Module {
                 y: rect.y,
                 width: rect.width,
                 height: rect.height,
-                targetFrameSrc: this.wnd?.location?.href,
+                targetFrameSrc: this.wnd?.location?.href
             }
             this.comms.send("text_selected", textSelection as BasicTextSelection);
         }
@@ -95,13 +460,6 @@ export class Peripherals extends Module {
     }
     private readonly onPointerDown = this.onPointDown.bind(this);
 
-    onContext(event: MouseEvent) {
-        // If the context menu is triggered by a long press, we manage the event using the pointup event
-        this.onPointUp(event as PointerEvent);
-        this.pointerMoved = false;
-    }
-    private readonly onContextMenu = this.onContext.bind(this);
-
     onClick(event: MouseEvent) {
         event.preventDefault(); // To prevent certain browser actions. May have side-effects
         if(!event.isTrusted) {
@@ -114,20 +472,90 @@ export class Peripherals extends Module {
                 clientY: event.clientY,
             });
             // Override properties we cannot set in the constructor
-            Object.defineProperty(synthEvent, 'target', {writable: false, value: event.target});
-            Object.defineProperty(synthEvent, 'defaultPrevented', {writable: false, value: event.defaultPrevented });
+            Object.defineProperty(synthEvent, "target", {writable: false, value: event.target});
+            Object.defineProperty(synthEvent, "defaultPrevented", {writable: false, value: event.defaultPrevented });
             // Trigger `pointerup` event
             this.onPointUp(synthEvent);
         }
     }
     private readonly onClicker = this.onClick.bind(this);
 
+    private registerProtectionHandlers() {
+        // Single handler for all content protection features
+        this.comms?.register("peripherals_protection", Peripherals.moduleName, (data: unknown, ack) => {
+            const config = data as ContentProtectionConfig;
+            
+            // Apply config only on first call, then ignore subsequent calls (immutable)
+            if (!this.configApplied) {
+                this.configApplied = true;
+                
+                // Selection monitoring with optional configuration
+                if (config.monitorSelection) {
+                    const options = typeof config.monitorSelection === "boolean" 
+                        ? undefined 
+                        : config.monitorSelection;
+                    this.addSelectionMonitoring(options);
+                    this.comms?.log("Selection monitoring enabled");
+                }
+                
+                // Copy
+                if (typeof config.protectCopy === "object") {
+                    // Limited copying with custom thresholds
+                    this.addBulkCopyProtection({
+                        enabled: true,
+                        ...config.protectCopy
+                    });
+                    this.comms?.log("Copy protection enabled (limited)");
+                } else if (config.protectCopy === true) {
+                    // Block all copying
+                    this.addBulkCopyProtection({ 
+                        enabled: true, 
+                        maxSelectionPercent: 0, 
+                        minThreshold: 0, 
+                        absoluteMaxChars: 0 
+                    });
+                    this.comms?.log("Copy protection enabled");
+                }
+                
+                // Context menu
+                if (config.disableContextMenu) {
+                    this.addContextMenuPrevention();
+                    this.comms?.log("Context menu protection enabled");
+                }
+                
+                // Drag and drop
+                if (config.disableDragAndDrop) {
+                    this.addDragAndDropPrevention();
+                    this.comms?.log("Drag and drop protection enabled");
+                }
+            }
+            
+            ack(true);
+        });
+
+        // Separate handler for keyboard peripherals
+        this.comms?.register("keyboard_peripherals", Peripherals.moduleName, (data: unknown, ack) => {
+            const keyboardPeripherals = data as KeyboardPeripheral[];
+            
+            if (keyboardPeripherals && keyboardPeripherals.length > 0) {
+                this.enableKeyboardPeripherals(keyboardPeripherals);
+                this.comms?.log(`Keyboard peripherals enabled: ${keyboardPeripherals.map(p => p.type).join(", ")}`);
+            }
+            
+            ack(true);
+        });
+    }
+
     mount(wnd: ReadiumWindow, comms: Comms): boolean {
         this.wnd = wnd;
         this.comms = comms;
+        
+        // Register protection handlers
+        this.registerProtectionHandlers();
+        
+        // Core event listeners (always active)
         wnd.document.addEventListener("pointerdown", this.onPointerDown);
         wnd.document.addEventListener("pointerup", this.onPointerUp);
-        wnd.document.addEventListener("contextmenu", this.onContextMenu);
         wnd.document.addEventListener("pointermove", this.onPointerMove);
         wnd.document.addEventListener("click", this.onClicker);
 
@@ -136,12 +564,29 @@ export class Peripherals extends Module {
     }
 
     unmount(wnd: ReadiumWindow, comms: Comms): boolean {
+        // Clean up optional features
+        this.removeBulkCopyProtection();
+        this.removeSelectionMonitoring();
+        this.removeContextMenuPrevention();
+        this.removeDragAndDropPrevention();
+        this.disableKeyboardPeripherals();
+        
+        // Clean up event listeners
+        this.cleanupCallbacks.forEach(cleanup => cleanup());
+        this.cleanupCallbacks = [];
+        
+        // Remove core event listeners
         wnd.document.removeEventListener("pointerdown", this.onPointerDown);
         wnd.document.removeEventListener("pointerup", this.onPointerUp);
-        wnd.document.removeEventListener("contextmenu", this.onContextMenu);
         wnd.document.removeEventListener("pointermove", this.onPointerMove);
         wnd.document.removeEventListener("click", this.onClicker);
-
+        
+        // Unregister all handlers
+        comms.unregisterAll(Peripherals.moduleName);
+        
+        // Reset config applied flag for fresh instances
+        this.configApplied = false;
+        
         comms.log("Peripherals Unmounted");
         return true;
     }

package/src/modules/snapper/ColumnSnapper.ts

@@ -6,8 +6,16 @@ import { ModuleName } from "../ModuleLibrary";
 import { Locator, LocatorLocations, LocatorText } from "@readium/shared";
 import { rangeFromLocator } from "../../helpers/locator";
 import { ReadiumWindow, deselect, findFirstVisibleLocator } from "../../helpers/dom";
+import { PatternAnalyzer } from "../../protection/PatternAnalyzer";
+import { BaseSuspiciousActivityEvent } from "../Peripherals";
 
 const COLUMN_SNAPPER_STYLE_ID = "readium-column-snapper-style";
+
+export interface SuspiciousSnappingEvent extends BaseSuspiciousActivityEvent {
+    type: "suspicious_snapping";
+    event: null;
+}
+
 const SNAP_DURATION = 200; // Milliseconds
 
 enum ScrollTouchState {
@@ -21,8 +29,11 @@ enum ScrollTouchState {
  */
 export class ColumnSnapper extends Snapper {
     static readonly moduleName: ModuleName = "column_snapper";
+    private isSnapProtectionEnabled = false;
     private resizeObserver!: ResizeObserver;
     private mutationObserver!: MutationObserver;
+    private patternAnalyzer: PatternAnalyzer | null = null;
+    private lastTurnTime: number = 0;
     private wnd!: ReadiumWindow;
     private comms!: Comms;
     private doc() { return this.wnd.document.scrollingElement as HTMLElement; }
@@ -72,6 +83,7 @@ export class ColumnSnapper extends Snapper {
     private alreadyScrollLeft = 0;
     private overscroll = 0;
     private cachedScrollWidth = 0; // We have to cache this because during overscroll (transform, or left) the width is incorrect due to browser
+    
     private takeOverSnap() {
         this.snappingCancelled = true;
         this.clearTouches();
@@ -80,7 +92,7 @@ export class ColumnSnapper extends Snapper {
         // translate3d(XXXpx, 0px, 0px) -> slice 12 -> XXXpx, 0px, 0px) -> split "px" [0] -> XXX
         this.overscroll = doc.style.transform?.length > 12 ? parseFloat(doc.style.transform.slice(12).split("px")[0]) : 0;
     }
-
+    
     // Snaps the current offset to the page width.
     snapCurrentOffset(smooth=false, noprogress=false) {
         const startX = this.wnd.scrollX > 0 ? this.wnd.scrollX : this.alreadyScrollLeft;
@@ -96,6 +108,11 @@ export class ColumnSnapper extends Snapper {
             ((factor * cdo) > 0 ? 2 : 1);
 
         const so = this.snapOffset(currentOffset + hurdle);
+        
+        const direction = so > this.scrollOffset() ? "right" : "left";
+
+        this.checkSuspiciousSnap(direction, Math.abs(so - this.scrollOffset()));
+        
         if(smooth && so !== this.scrollOffset()) { // Smooth snapping
             this.snappingCancelled = false;
             const position = (start: number, end: number, elapsed: number, period: number) => {
@@ -232,6 +249,37 @@ export class ColumnSnapper extends Snapper {
     }
     private readonly onTouchMover = this.onTouchMove.bind(this);
 
+    private enableSnapProtection() {
+        if (!this.patternAnalyzer) {
+            this.patternAnalyzer = new PatternAnalyzer({
+                maxVelocity: this.wnd.innerWidth,  // page width
+                minVariance: 0.1,   // Allow for some variation in swipe speed
+                historySize: 5,      // Fewer samples needed for swipe detection
+                maxConsistentScrolls: 3,  // Lower threshold for consistent scrolling
+                minDirectionChanges: 0.3  // Require more direction changes
+            });
+            this.isSnapProtectionEnabled = true;
+            this.comms?.log("Snap protection enabled");
+        }
+    }
+
+    private checkSuspiciousSnap(direction: "left" | "right", distance: number) {
+        if (!this.isSnapProtectionEnabled || !this.patternAnalyzer) return;
+
+        const now = Date.now();
+        const timeDelta = now - (this.lastTurnTime || now);
+        this.lastTurnTime = now;
+
+        const isSuspicious = this.patternAnalyzer.analyze(direction, distance, timeDelta);
+        if (isSuspicious) {
+            this.comms?.send("content_protection", {
+                type: "suspicious_snapping",
+                timestamp: Date.now(),
+                event: null
+            } as SuspiciousSnappingEvent);
+        }
+    }
+
     mount(wnd: ReadiumWindow, comms: Comms): boolean {
         this.wnd = wnd;
         this.comms = comms;
@@ -317,6 +365,11 @@ export class ColumnSnapper extends Snapper {
         // For cases the resizeObserver is not able to detect cos body is not resizing despite colCount,
         // we need to check the syle attribute on the documentElement (ReadiumCSS props)
         this.mutationObserver.observe(wnd.document.documentElement, {attributes: true, attributeFilter: ["style"]});
+        
+        comms.register("scroll_protection", ColumnSnapper.moduleName, (_, ack) => {
+            this.enableSnapProtection();
+            ack(true);
+        });
 
         const scrollToOffset = (offset: number): boolean => {
             const oldScrollLeft = this.doc().scrollLeft;
@@ -427,6 +480,7 @@ export class ColumnSnapper extends Snapper {
                 if(change) {
                     this.reportProgress();
                     deselect(this.wnd);
+                    this.checkSuspiciousSnap("left", this.wnd.innerWidth);
                 }
                 ack(change);
             });
@@ -441,6 +495,7 @@ export class ColumnSnapper extends Snapper {
                 if(change) {
                     this.reportProgress();
                     deselect(this.wnd);
+                    this.checkSuspiciousSnap("right", this.wnd.innerWidth);
                 }
                 ack(change);
             });
@@ -478,7 +533,7 @@ export class ColumnSnapper extends Snapper {
         wnd.addEventListener("touchmove", this.onTouchMover, { passive: true });
 
         // Safari hack, otherwise other events won't register
-        wnd.document.addEventListener('touchstart', () => {});
+        wnd.document.addEventListener("touchstart", () => {});
 
         comms.log("ColumnSnapper Mounted");
         return true;
@@ -490,6 +545,12 @@ export class ColumnSnapper extends Snapper {
         this.resizeObserver.disconnect();
         this.mutationObserver.disconnect();
 
+        if (this.patternAnalyzer) {
+            this.patternAnalyzer.clear();
+            this.patternAnalyzer = null;
+            this.isSnapProtectionEnabled = false;
+        }
+
         wnd.removeEventListener("touchstart", this.onTouchStarter);
         wnd.removeEventListener("touchend", this.onTouchEnder);
         wnd.removeEventListener("touchmove", this.onTouchMover);