jumpy-lion 0.1.1 → 0.1.3

package/dist/fingerprinting/fingerprint-overrides/cdp-detection-bypass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdp-detection-bypass.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/cdp-detection-bypass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAW,EAAE;IACvD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2uBL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/client-rect-spoofing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Client Rect Spoofing
+ * Adds small variations to DOM measurements to prevent fingerprinting
+ */
+export declare const createClientRectSpoofingScript: () => string;
+//# sourceMappingURL=client-rect-spoofing.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/client-rect-spoofing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-rect-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/client-rect-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,8BAA8B,QAAO,MA6LjD,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/client-rect-spoofing.js

@@ -0,0 +1,195 @@
+/**
+ * Client Rect Spoofing
+ * Adds small variations to DOM measurements to prevent fingerprinting
+ */
+export const createClientRectSpoofingScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // Client Rect Spoofing for 2025
+    const spoofClientRects = () => {
+        // Seeded PRNG (mulberry32) for deterministic variations
+        const createSeededRNG = (seed) => {
+            let s = seed | 0;
+            return () => {
+                s = s + 0x6D2B79F5 | 0;
+                let t = Math.imul(s ^ s >>> 15, 1 | s);
+                t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+                return ((t ^ t >>> 14) >>> 0) / 4294967296;
+            };
+        };
+
+        // Generate a stable seed for an element based on its identity
+        const elementSeeds = new WeakMap();
+        let nextSeed = Date.now();
+        const getElementSeed = (element) => {
+            if (!elementSeeds.has(element)) {
+                elementSeeds.set(element, nextSeed++);
+            }
+            return elementSeeds.get(element);
+        };
+
+        // Add deterministic variation using element-seeded RNG
+        const addVariation = (value, rng) => {
+            return value + (rng() - 0.5) * 0.1;
+        };
+
+        // Override getBoundingClientRect
+        const originalGetBoundingClientRect = Element.prototype.getBoundingClientRect;
+        Element.prototype.getBoundingClientRect = function() {
+            const rect = originalGetBoundingClientRect.apply(this, arguments);
+            const rng = createSeededRNG(getElementSeed(this));
+
+            // Create a new DOMRect with deterministic variations
+            const newRect = {
+                x: addVariation(rect.x, rng),
+                y: addVariation(rect.y, rng),
+                width: addVariation(rect.width, rng),
+                height: addVariation(rect.height, rng),
+                top: addVariation(rect.top, rng),
+                right: addVariation(rect.right, rng),
+                bottom: addVariation(rect.bottom, rng),
+                left: addVariation(rect.left, rng),
+                toJSON: rect.toJSON
+            };
+
+            // Make it look like a real DOMRect
+            Object.setPrototypeOf(newRect, DOMRect.prototype);
+
+            return newRect;
+        };
+
+        // Override getClientRects
+        const originalGetClientRects = Element.prototype.getClientRects;
+        Element.prototype.getClientRects = function() {
+            const rects = originalGetClientRects.apply(this, arguments);
+            const baseSeed = getElementSeed(this);
+            const newRects = [];
+
+            for (let i = 0; i < rects.length; i++) {
+                const rect = rects[i];
+                const rng = createSeededRNG(baseSeed + i);
+                const newRect = {
+                    x: addVariation(rect.x, rng),
+                    y: addVariation(rect.y, rng),
+                    width: addVariation(rect.width, rng),
+                    height: addVariation(rect.height, rng),
+                    top: addVariation(rect.top, rng),
+                    right: addVariation(rect.right, rng),
+                    bottom: addVariation(rect.bottom, rng),
+                    left: addVariation(rect.left, rng)
+                };
+                Object.setPrototypeOf(newRect, DOMRect.prototype);
+                newRects.push(newRect);
+            }
+
+            // Create a DOMRectList-like object
+            const rectList = {
+                length: newRects.length,
+                item: (index) => newRects[index] || null,
+                [Symbol.iterator]: function*() {
+                    for (let i = 0; i < this.length; i++) {
+                        yield this.item(i);
+                    }
+                }
+            };
+
+            // Add indexed properties
+            for (let i = 0; i < newRects.length; i++) {
+                rectList[i] = newRects[i];
+            }
+
+            Object.setPrototypeOf(rectList, DOMRectList.prototype);
+            return rectList;
+        };
+
+        // Override Range methods with the same deterministic approach
+        if (typeof Range !== 'undefined') {
+            // Ranges don't have element identity, so use a WeakMap for Range objects too
+            const rangeSeeds = new WeakMap();
+            const getRangeSeed = (range) => {
+                if (!rangeSeeds.has(range)) {
+                    rangeSeeds.set(range, nextSeed++);
+                }
+                return rangeSeeds.get(range);
+            };
+
+            const originalGetBoundingClientRectRange = Range.prototype.getBoundingClientRect;
+            Range.prototype.getBoundingClientRect = function() {
+                const rect = originalGetBoundingClientRectRange.apply(this, arguments);
+                const rng = createSeededRNG(getRangeSeed(this));
+
+                const newRect = {
+                    x: addVariation(rect.x, rng),
+                    y: addVariation(rect.y, rng),
+                    width: addVariation(rect.width, rng),
+                    height: addVariation(rect.height, rng),
+                    top: addVariation(rect.top, rng),
+                    right: addVariation(rect.right, rng),
+                    bottom: addVariation(rect.bottom, rng),
+                    left: addVariation(rect.left, rng),
+                    toJSON: rect.toJSON
+                };
+
+                Object.setPrototypeOf(newRect, DOMRect.prototype);
+                return newRect;
+            };
+
+            const originalGetClientRectsRange = Range.prototype.getClientRects;
+            Range.prototype.getClientRects = function() {
+                const rects = originalGetClientRectsRange.apply(this, arguments);
+                const baseSeed = getRangeSeed(this);
+                const newRects = [];
+
+                for (let i = 0; i < rects.length; i++) {
+                    const rect = rects[i];
+                    const rng = createSeededRNG(baseSeed + i);
+                    const newRect = {
+                        x: addVariation(rect.x, rng),
+                        y: addVariation(rect.y, rng),
+                        width: addVariation(rect.width, rng),
+                        height: addVariation(rect.height, rng),
+                        top: addVariation(rect.top, rng),
+                        right: addVariation(rect.right, rng),
+                        bottom: addVariation(rect.bottom, rng),
+                        left: addVariation(rect.left, rng)
+                    };
+                    Object.setPrototypeOf(newRect, DOMRect.prototype);
+                    newRects.push(newRect);
+                }
+
+                const rectList = {
+                    length: newRects.length,
+                    item: (index) => newRects[index] || null,
+                    [Symbol.iterator]: function*() {
+                        for (let i = 0; i < this.length; i++) {
+                            yield this.item(i);
+                        }
+                    }
+                };
+
+                for (let i = 0; i < newRects.length; i++) {
+                    rectList[i] = newRects[i];
+                }
+
+                Object.setPrototypeOf(rectList, DOMRectList.prototype);
+                return rectList;
+            };
+        }
+    };
+    
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting client rect spoofing...');
+        spoofClientRects();
+        console.log(DEBUG_PREFIX, '✓ Client rect spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply client rect spoofing:', e);
+        throw e;
+    }
+})();`;
+};
+//# sourceMappingURL=client-rect-spoofing.js.map

package/dist/fingerprinting/fingerprint-overrides/client-rect-spoofing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-rect-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/client-rect-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAW,EAAE;IACvD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2LL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/coalesced-events-spoofing.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Coalesced Events Spoofing
+ * Makes CDP-dispatched pointer events include realistic coalesced events.
+ *
+ * Real mouse movements produce PointerEvents where getCoalescedEvents() returns
+ * multiple interpolated points. CDP dispatch produces 0 or 1 points, which is
+ * a detection vector used by DataDome and Cloudflare.
+ */
+export declare const createCoalescedEventsSpoofingScript: () => string;
+//# sourceMappingURL=coalesced-events-spoofing.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/coalesced-events-spoofing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coalesced-events-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/coalesced-events-spoofing.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,mCAAmC,QAAO,MAyLtD,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/coalesced-events-spoofing.js

@@ -0,0 +1,195 @@
+/**
+ * Coalesced Events Spoofing
+ * Makes CDP-dispatched pointer events include realistic coalesced events.
+ *
+ * Real mouse movements produce PointerEvents where getCoalescedEvents() returns
+ * multiple interpolated points. CDP dispatch produces 0 or 1 points, which is
+ * a detection vector used by DataDome and Cloudflare.
+ */
+export const createCoalescedEventsSpoofingScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Track last known pointer position for interpolation
+    let lastPointerX = 0;
+    let lastPointerY = 0;
+    let lastPointerTime = 0;
+
+    // Seeded PRNG for deterministic jitter
+    const createSeededRNG = (seed) => {
+        let s = seed | 0;
+        return () => {
+            s = s + 0x6D2B79F5 | 0;
+            let t = Math.imul(s ^ s >>> 15, 1 | s);
+            t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+            return ((t ^ t >>> 14) >>> 0) / 4294967296;
+        };
+    };
+
+    const sessionSeed = Date.now() ^ 0xA5F3C291;
+    let callCount = 0;
+
+    // Store original method
+    const originalGetCoalescedEvents = PointerEvent.prototype.getCoalescedEvents;
+    const originalGetPredictedEvents = PointerEvent.prototype.getPredictedEvents;
+
+    /**
+     * Generate synthetic coalesced events between two points
+     */
+    const generateCoalescedPoints = (event, prevX, prevY, prevTime) => {
+        const dx = event.clientX - prevX;
+        const dy = event.clientY - prevY;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+
+        // Number of coalesced points based on distance (real browsers: ~1 per 2-8px)
+        const rng = createSeededRNG(sessionSeed + (++callCount));
+        const pointsPerPx = 3 + rng() * 5; // 3-8 px per point
+        const numPoints = Math.max(1, Math.min(8, Math.floor(distance / pointsPerPx)));
+
+        if (numPoints <= 1 || distance < 2) {
+            // Very small movement, return just the event itself
+            return [event];
+        }
+
+        const points = [];
+        const timeSpan = event.timeStamp - (prevTime || event.timeStamp - 16);
+
+        for (let i = 0; i < numPoints; i++) {
+            const t = (i + 1) / (numPoints + 1);
+
+            // Interpolate with slight jitter
+            const jitterX = (rng() - 0.5) * 0.5;
+            const jitterY = (rng() - 0.5) * 0.5;
+            const pointX = prevX + dx * t + jitterX;
+            const pointY = prevY + dy * t + jitterY;
+            const pointTime = (prevTime || event.timeStamp - 16) + timeSpan * t;
+
+            // Create a PointerEvent-like object
+            const coalescedEvent = new PointerEvent(event.type, {
+                clientX: pointX,
+                clientY: pointY,
+                screenX: event.screenX - event.clientX + pointX,
+                screenY: event.screenY - event.clientY + pointY,
+                pageX: pointX + (window.scrollX || 0),
+                pageY: pointY + (window.scrollY || 0),
+                pointerId: event.pointerId,
+                pointerType: event.pointerType,
+                isPrimary: event.isPrimary,
+                width: event.width,
+                height: event.height,
+                pressure: event.pressure || 0.5,
+                tiltX: event.tiltX,
+                tiltY: event.tiltY,
+                bubbles: false,
+                cancelable: false,
+            });
+
+            points.push(coalescedEvent);
+        }
+
+        // Always include the original event as the last point
+        points.push(event);
+
+        return points;
+    };
+
+    /**
+     * Generate predicted events (typically 1-2 points ahead)
+     */
+    const generatePredictedPoints = (event) => {
+        const rng = createSeededRNG(sessionSeed + (++callCount) + 1000000);
+        const numPredicted = rng() > 0.3 ? 1 : 2;
+        const points = [];
+
+        // Predict forward based on current velocity
+        const dx = event.clientX - lastPointerX;
+        const dy = event.clientY - lastPointerY;
+
+        for (let i = 1; i <= numPredicted; i++) {
+            const predictedX = event.clientX + dx * i * 0.5 + (rng() - 0.5) * 2;
+            const predictedY = event.clientY + dy * i * 0.5 + (rng() - 0.5) * 2;
+
+            const predictedEvent = new PointerEvent(event.type, {
+                clientX: predictedX,
+                clientY: predictedY,
+                screenX: event.screenX - event.clientX + predictedX,
+                screenY: event.screenY - event.clientY + predictedY,
+                pointerId: event.pointerId,
+                pointerType: event.pointerType,
+                isPrimary: event.isPrimary,
+                pressure: event.pressure || 0.5,
+                bubbles: false,
+                cancelable: false,
+            });
+
+            points.push(predictedEvent);
+        }
+
+        return points;
+    };
+
+    // Override getCoalescedEvents
+    PointerEvent.prototype.getCoalescedEvents = function() {
+        // Only spoof for pointermove events (that's where coalesced events matter)
+        if (this.type !== 'pointermove' && this.type !== 'pointerdown') {
+            return originalGetCoalescedEvents ? originalGetCoalescedEvents.call(this) : [];
+        }
+
+        // Check if original already has coalesced events (real events)
+        if (originalGetCoalescedEvents) {
+            const original = originalGetCoalescedEvents.call(this);
+            if (original && original.length > 1) {
+                // Real events with coalesced data, don't interfere
+                lastPointerX = this.clientX;
+                lastPointerY = this.clientY;
+                lastPointerTime = this.timeStamp;
+                return original;
+            }
+        }
+
+        // Generate synthetic coalesced events
+        const result = generateCoalescedPoints(this, lastPointerX, lastPointerY, lastPointerTime);
+
+        // Update last position
+        lastPointerX = this.clientX;
+        lastPointerY = this.clientY;
+        lastPointerTime = this.timeStamp;
+
+        return result;
+    };
+
+    // Override getPredictedEvents
+    if (originalGetPredictedEvents) {
+        PointerEvent.prototype.getPredictedEvents = function() {
+            if (this.type !== 'pointermove') {
+                return originalGetPredictedEvents.call(this);
+            }
+
+            const original = originalGetPredictedEvents.call(this);
+            if (original && original.length > 0) {
+                return original;
+            }
+
+            return generatePredictedPoints(this);
+        };
+    }
+
+    // Track pointer position via listener
+    window.addEventListener('pointermove', (e) => {
+        lastPointerX = e.clientX;
+        lastPointerY = e.clientY;
+        lastPointerTime = e.timeStamp;
+    }, { capture: true, passive: true });
+
+    // Register overrides with stealth utils if available
+    const _s = typeof __stealth !== 'undefined' ? __stealth : null;
+    if (_s && _s.utils) {
+        _s.utils.registerNativeFunction(PointerEvent.prototype.getCoalescedEvents, 'getCoalescedEvents');
+        if (originalGetPredictedEvents) {
+            _s.utils.registerNativeFunction(PointerEvent.prototype.getPredictedEvents, 'getPredictedEvents');
+        }
+    }
+})();`;
+};
+//# sourceMappingURL=coalesced-events-spoofing.js.map

package/dist/fingerprinting/fingerprint-overrides/coalesced-events-spoofing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coalesced-events-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/coalesced-events-spoofing.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,CAAC,MAAM,mCAAmC,GAAG,GAAW,EAAE;IAC5D,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuLL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/datadome-bypass.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DataDome-Specific Bypass Module - MAXIMUM AGGRESSION Edition 2025-2026
+ *
+ * Based on comprehensive analysis of DataDome fingerprinting from:
+ * - analysis-a8005bea5af559c5.json (36 fingerprinting methods, 1080+ property accesses)
+ * - fingerprint-traps-d1764644c7101d16.json (799 method calls traced)
+ *
+ * This module overrides EVERYTHING DataDome checks.
+ *
+ * CRITICAL DETECTION VECTORS (All Addressed):
+ * - Error.constructor (100+ stack trace checks)
+ * - navigator.userAgentData.getHighEntropyValues() (architecture, bitness, platform)
+ * - Date.constructor (timing analysis)
+ * - Function.prototype.toString (native code checks)
+ * - performance.memory (iframe checks via geo.captcha-delivery.com)
+ * - screen.* (all properties)
+ * - window.* (dimensions, parent, top, self)
+ * - navigator.* (40+ properties)
+ * - localStorage/sessionStorage
+ * - history API
+ * - Permissions API
+ * - MediaDevices API
+ * - Keyboard API
+ * - Battery API
+ * - WebGL/Canvas
+ */
+export declare const createDataDomeBypassScript: () => string;
+//# sourceMappingURL=datadome-bypass.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/datadome-bypass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datadome-bypass.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/datadome-bypass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,eAAO,MAAM,0BAA0B,QAAO,MAioC7C,CAAC"}