jumpy-lion 0.1.6-beta.0 → 0.1.6-beta.3

package/package.json

@@ -2,7 +2,7 @@
     "name": "jumpy-lion",
     "description": "",
     "type": "module",
-    "version": "0.1.6-beta.0",
+    "version": "0.1.6-beta.3",
     "engines": {
         "node": ">=20.0.0"
     },
@@ -31,7 +31,12 @@
         "compile": "tsc -p tsconfig.build.json",
         "copy-extension": "cp -r src/fingerprinting/all-fingerprint-defender dist/fingerprinting/ && cp -r src/fingerprinting/anti-webgpu dist/fingerprinting/",
         "build": "npm run clean && npm run compile && npm run copy-extension",
+        "build:browser": "bash browser/scripts/build.sh",
+        "build:browser:docker": "bash browser/scripts/docker-build.sh",
+        "build:browser:linux": "bash browser/scripts/docker-build.sh --linux-only",
+        "build:browser:windows": "bash browser/scripts/docker-build.sh --windows-only",
         "package:browser": "bash browser/scripts/package-binary.sh",
+        "bundle:browser": "node scripts/bundle-browser.cjs",
         "release:browser": "node scripts/release-browser.cjs",
         "postinstall": "node scripts/postinstall.cjs",
         "ci:build": "turbo run build --cache-dir=\".turbo\"",

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

@@ -1,10 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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,MAwMtD,CAAC"}

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

@@ -1,210 +0,0 @@
-/**
- * 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;
-        };
-    };
-
-    // Stable seed: must NOT use Date.now() because this script re-executes on
-    // every reload via addScriptToEvaluateOnNewDocument.
-    const _stableHash = (salt) => {
-        const _s = typeof __stealth !== 'undefined' ? __stealth : {};
-        const key = _s.seedKey || '';
-        const ua = navigator.userAgent || '';
-        const s = screen;
-        let h = salt | 0;
-        for (let i = 0; i < key.length; i++) h = (h << 5) - h + key.charCodeAt(i) | 0;
-        for (let i = 0; i < ua.length; i++) h = (h << 5) - h + ua.charCodeAt(i) | 0;
-        h = (h << 5) - h + (s.width || 0) | 0;
-        h = (h << 5) - h + (s.height || 0) | 0;
-        h = (h << 5) - h + (s.colorDepth || 0) | 0;
-        return h >>> 0;
-    };
-    const sessionSeed = _stableHash(0xCAFE1007);
-    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

@@ -1 +0,0 @@
-{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsML,CAAC;AACP,CAAC,CAAC"}