jumpy-lion 0.0.41 → 0.0.43

package/dist/fingerprinting/fingerprint-overrides/locale-spoofing.js

@@ -39,71 +39,70 @@ export const createLocaleSpoofingScript = () => {
         };
         
         // Override Intl.DateTimeFormat to use Windows-consistent formatting
+        // CRITICAL: Store reference BEFORE override and use recursion guard
         const OriginalDateTimeFormat = Intl.DateTimeFormat;
+        let isCreatingDateTimeFormat = false; // Recursion guard
+        let cachedTimeZone = 'UTC';
+        try {
+            cachedTimeZone = new OriginalDateTimeFormat().resolvedOptions().timeZone;
+        } catch (e) {
+            // Fallback to UTC if timezone detection fails
+        }
+        
         Intl.DateTimeFormat = function(locales, options) {
-            // Ensure Windows-like date formatting regardless of actual locale
-            const windowsOptions = Object.assign({}, windowsLocaleConfig.dateFormat, options);
-            
-            // Force specific Windows locale patterns
-            if (platform === 'Win32' || !platform.includes('Linux')) {
-                if (!options || !options.timeZone) {
-                    // Use common Windows timezone handling
-                    windowsOptions.timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-                }
+            // CRITICAL: Recursion guard - if we're already inside this function, use original directly
+            if (isCreatingDateTimeFormat) {
+                return Reflect.construct(OriginalDateTimeFormat, [locales, options], OriginalDateTimeFormat);
             }
             
-            const formatter = new OriginalDateTimeFormat(locales, windowsOptions);
-            
-            // Override format method to ensure Windows-style output
-            const originalFormat = formatter.format;
-            formatter.format = function(date) {
-                let result = originalFormat.call(this, date);
+            isCreatingDateTimeFormat = true;
+            try {
+                // Ensure Windows-like date formatting regardless of actual locale
+                const windowsOptions = Object.assign({}, windowsLocaleConfig.dateFormat, options);
                 
-                // Apply Windows-specific formatting adjustments
-                if (platform === 'Win32') {
-                    // Windows often uses specific date separators and formats
-                    result = result.replace(/\\b(\\d{1,2})\\/(\\d{1,2})\\/(\\d{4})\\b/, '$1/$2/$3');
-                    result = result.replace(/\\b(\\d{4})-(\\d{2})-(\\d{2})\\b/, '$2/$3/$1');
+                // Force specific Windows locale patterns
+                if (platform === 'Win32' || !platform.includes('Linux')) {
+                    if (!options || !options.timeZone) {
+                        windowsOptions.timeZone = cachedTimeZone;
+                    }
                 }
                 
-                return result;
-            };
-            
-            return formatter;
+                // Use Reflect.construct to properly create instance with original constructor
+                const formatter = Reflect.construct(OriginalDateTimeFormat, [locales, windowsOptions], OriginalDateTimeFormat);
+                
+                return formatter;
+            } finally {
+                isCreatingDateTimeFormat = false;
+            }
         };
         
         // Override Intl.NumberFormat for Windows-consistent number formatting
         const OriginalNumberFormat = Intl.NumberFormat;
+        let isCreatingNumberFormat = false; // Recursion guard
+        
         Intl.NumberFormat = function(locales, options) {
-            const windowsOptions = Object.assign({}, windowsLocaleConfig.numberFormat, options);
-            
-            // Windows-specific number formatting
-            if (platform === 'Win32') {
-                windowsOptions.useGrouping = true;
-                if (options && options.style === 'currency') {
-                    Object.assign(windowsOptions, windowsLocaleConfig.currencyFormat, options);
-                }
+            // CRITICAL: Recursion guard
+            if (isCreatingNumberFormat) {
+                return Reflect.construct(OriginalNumberFormat, [locales, options], OriginalNumberFormat);
             }
             
-            const formatter = new OriginalNumberFormat(locales, windowsOptions);
-            
-            // Override format method for Windows-style numbers
-            const originalFormat = formatter.format;
-            formatter.format = function(number) {
-                let result = originalFormat.call(this, number);
+            isCreatingNumberFormat = true;
+            try {
+                const windowsOptions = Object.assign({}, windowsLocaleConfig.numberFormat, options);
                 
-                // Windows-specific formatting adjustments
+                // Windows-specific number formatting
                 if (platform === 'Win32') {
-                    // Ensure Windows-style thousand separators and decimal points
-                    if (typeof number === 'number' && Math.abs(number) >= 1000) {
-                        result = result.replace(/\\s/g, ','); // Replace spaces with commas for thousands
+                    windowsOptions.useGrouping = true;
+                    if (options && options.style === 'currency') {
+                        Object.assign(windowsOptions, windowsLocaleConfig.currencyFormat, options);
                     }
                 }
                 
-                return result;
-            };
-            
-            return formatter;
+                // Use Reflect.construct to properly create instance with original constructor
+                return Reflect.construct(OriginalNumberFormat, [locales, windowsOptions], OriginalNumberFormat);
+            } finally {
+                isCreatingNumberFormat = false;
+            }
         };
         
         // Override Date.prototype methods for consistent formatting
@@ -127,7 +126,7 @@ export const createLocaleSpoofingScript = () => {
         };
         
         // Override Number.prototype methods for consistent formatting
-        const originalToLocaleString = Number.prototype.toLocaleString;
+        const originalNumberToLocaleString = Number.prototype.toLocaleString;
         Number.prototype.toLocaleString = function(locales, options) {
             let windowsOptions = Object.assign({}, windowsLocaleConfig.numberFormat, options);
             
@@ -135,25 +134,32 @@ export const createLocaleSpoofingScript = () => {
                 windowsOptions = Object.assign({}, windowsLocaleConfig.currencyFormat, options);
             }
             
-            return originalToLocaleString.call(this, locales || 'en-US', windowsOptions);
+            return originalNumberToLocaleString.call(this, locales || 'en-US', windowsOptions);
         };
         
         // Spoof timezone-related methods for consistency
         const originalGetTimezoneOffset = Date.prototype.getTimezoneOffset;
+        // Cache winter/summer offsets at init time to prevent recursion
+        let cachedWinterOffset = null;
+        let cachedSummerOffset = null;
+        try {
+            const now = new Date();
+            cachedWinterOffset = originalGetTimezoneOffset.call(new Date(now.getFullYear(), 0, 1));
+            cachedSummerOffset = originalGetTimezoneOffset.call(new Date(now.getFullYear(), 6, 1));
+        } catch (e) {
+            // Fallback - no DST adjustment
+        }
+        
         Date.prototype.getTimezoneOffset = function() {
             const offset = originalGetTimezoneOffset.call(this);
             
             // Ensure timezone offset is reported consistently
             // Windows tends to handle DST slightly differently
-            if (platform === 'Win32') {
-                const now = new Date();
-                const winterOffset = new Date(now.getFullYear(), 0, 1).getTimezoneOffset();
-                const summerOffset = new Date(now.getFullYear(), 6, 1).getTimezoneOffset();
-                
+            if (platform === 'Win32' && cachedWinterOffset !== null && cachedSummerOffset !== null) {
                 // Apply Windows-style DST calculation if needed
-                if (winterOffset !== summerOffset) {
-                    const isDST = offset === Math.min(winterOffset, summerOffset);
-                    return isDST ? summerOffset : winterOffset;
+                if (cachedWinterOffset !== cachedSummerOffset) {
+                    const isDST = offset === Math.min(cachedWinterOffset, cachedSummerOffset);
+                    return isDST ? cachedSummerOffset : cachedWinterOffset;
                 }
             }
             
@@ -163,35 +169,60 @@ export const createLocaleSpoofingScript = () => {
         // Override Intl.Collator for Windows-consistent string comparison
         if (typeof Intl.Collator !== 'undefined') {
             const OriginalCollator = Intl.Collator;
+            let isCreatingCollator = false;
             Intl.Collator = function(locales, options) {
-                const windowsOptions = Object.assign({
-                    sensitivity: 'base',
-                    usage: 'sort',
-                    caseFirst: 'upper' // Windows typically sorts uppercase first
-                }, options);
-                
-                return new OriginalCollator(locales, windowsOptions);
+                if (isCreatingCollator) {
+                    return Reflect.construct(OriginalCollator, [locales, options], OriginalCollator);
+                }
+                isCreatingCollator = true;
+                try {
+                    const windowsOptions = Object.assign({
+                        sensitivity: 'base',
+                        usage: 'sort',
+                        caseFirst: 'upper'
+                    }, options);
+                    return Reflect.construct(OriginalCollator, [locales, windowsOptions], OriginalCollator);
+                } finally {
+                    isCreatingCollator = false;
+                }
             };
         }
         
         // Override Intl.PluralRules for consistency
         if (typeof Intl.PluralRules !== 'undefined') {
             const OriginalPluralRules = Intl.PluralRules;
+            let isCreatingPluralRules = false;
             Intl.PluralRules = function(locales, options) {
-                return new OriginalPluralRules(locales || 'en-US', options);
+                if (isCreatingPluralRules) {
+                    return Reflect.construct(OriginalPluralRules, [locales, options], OriginalPluralRules);
+                }
+                isCreatingPluralRules = true;
+                try {
+                    return Reflect.construct(OriginalPluralRules, [locales || 'en-US', options], OriginalPluralRules);
+                } finally {
+                    isCreatingPluralRules = false;
+                }
             };
         }
         
         // Override Intl.RelativeTimeFormat if available
         if (typeof Intl.RelativeTimeFormat !== 'undefined') {
             const OriginalRelativeTimeFormat = Intl.RelativeTimeFormat;
+            let isCreatingRelativeTimeFormat = false;
             Intl.RelativeTimeFormat = function(locales, options) {
-                const windowsOptions = Object.assign({
-                    style: 'long',
-                    numeric: 'auto'
-                }, options);
-                
-                return new OriginalRelativeTimeFormat(locales || 'en-US', windowsOptions);
+                if (isCreatingRelativeTimeFormat) {
+                    return Reflect.construct(OriginalRelativeTimeFormat, [locales, options], OriginalRelativeTimeFormat);
+                }
+                isCreatingRelativeTimeFormat = true;
+                try {
+                    const windowsOptions = Object.assign({
+                        style: 'long',
+                        numeric: 'auto'
+                    }, options);
+                    return Reflect.construct(OriginalRelativeTimeFormat, [locales || 'en-US', windowsOptions], OriginalRelativeTimeFormat);
+                } finally {
+                    isCreatingRelativeTimeFormat = false;
+                }
             };
         }
         
@@ -230,32 +261,64 @@ export const createLocaleSpoofingScript = () => {
             };
         }
         
+        // Helper to check if property can be redefined
+        const canRedefineProperty = (obj, prop) => {
+            try {
+                const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+                return !descriptor || descriptor.configurable !== false;
+            } catch (e) {
+                return false;
+            }
+        };
+        
+        // IMPORTANT: Cache original values BEFORE any override to prevent infinite recursion
+        const originalLanguage = navigator.language;
+        const originalLanguages = navigator.languages ? [...navigator.languages] : ['en-US'];
+        
         // Ensure consistent navigator.language reporting
-        if (navigator.language) {
-            Object.defineProperty(navigator, 'language', {
-                get: function() {
-                    // Return Windows-common locale
-                    return platform === 'Win32' ? 'en-US' : navigator.language;
-                },
-                configurable: false
-            });
+        if (canRedefineProperty(navigator, 'language')) {
+            try {
+                Object.defineProperty(navigator, 'language', {
+                    get: function() {
+                        // Use cached value to prevent infinite recursion
+                        return platform === 'Win32' ? 'en-US' : originalLanguage;
+                    },
+                    configurable: true // Allow other scripts to modify if needed
+                });
+            } catch (e) {
+                // Property already defined, skip
+            }
         }
         
-        if (navigator.languages) {
-            Object.defineProperty(navigator, 'languages', {
-                get: function() {
-                    // Return Windows-typical language array
-                    if (platform === 'Win32') {
-                        return ['en-US', 'en'];
-                    }
-                    return navigator.languages;
-                },
-                configurable: false
-            });
+        if (canRedefineProperty(navigator, 'languages')) {
+            try {
+                Object.defineProperty(navigator, 'languages', {
+                    get: function() {
+                        // Use cached value to prevent infinite recursion
+                        if (platform === 'Win32') {
+                            return ['en-US', 'en'];
+                        }
+                        return originalLanguages;
+                    },
+                    configurable: true // Allow other scripts to modify if needed
+                });
+            } catch (e) {
+                // Property already defined, skip
+            }
         }
     };
     
-    spoofLocale();
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting locale spoofing...');
+        spoofLocale();
+        console.log(DEBUG_PREFIX, '✓ Locale spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply locale spoofing:', e);
+        throw e;
+    }
 })();
 `;
 };

package/dist/fingerprinting/fingerprint-overrides/locale-spoofing.js.map

@@ -1 +1 @@
-{"version":3,"file":"locale-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/locale-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAW,EAAE;IACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8PV,CAAC;AACF,CAAC,CAAC"}
+{"version":3,"file":"locale-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/locale-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAW,EAAE;IACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6TV,CAAC;AACF,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/mouse-humanization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mouse-humanization.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/mouse-humanization.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,8BAA8B,WAAkB,GAAG,KAAG,OAAO,CAAC,IAAI,CAgG9E,CAAC"}
+{"version":3,"file":"mouse-humanization.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/mouse-humanization.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,8BAA8B,WAAkB,GAAG,KAAG,OAAO,CAAC,IAAI,CA+F9E,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/mouse-humanization.js

@@ -4,9 +4,9 @@
  * Includes automatic human-like interactions after page load
  */
 export const setupMouseMovementHumanization = async (client) => {
-    // Override CDP Input domain to add human-like variations
-    await client.send('Runtime.evaluate', {
-        expression: `
+    // NOTE: Using addScriptToEvaluateOnNewDocument instead of Runtime.evaluate
+    // Runtime.evaluate is a CDP detection vector - it modifies console bindings and Error stacks
+    await client.Page.addScriptToEvaluateOnNewDocument({ source: `
 (() => {
     'use strict';
     
@@ -97,7 +97,6 @@ export const setupMouseMovementHumanization = async (client) => {
             // Storage might be disabled
         }
     });
-})();`,
-    });
+})();` });
 };
 //# sourceMappingURL=mouse-humanization.js.map

package/dist/fingerprinting/fingerprint-overrides/mouse-humanization.js.map

@@ -1 +1 @@
-{"version":3,"file":"mouse-humanization.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/mouse-humanization.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,KAAK,EAAE,MAAW,EAAiB,EAAE;IAC/E,yDAAyD;IACzD,MAAM,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE;QAClC,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2Fd;KACD,CAAC,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"mouse-humanization.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/mouse-humanization.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,KAAK,EAAE,MAAW,EAAiB,EAAE;IAC/E,2EAA2E;IAC3E,6FAA6F;IAC7F,MAAM,MAAM,CAAC,IAAI,CAAC,gCAAgC,CAAC,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2F3D,EAAE,CAAC,CAAC;AACV,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"performance-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/performance-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,+BAA+B,QAAO,MA8NlD,CAAC"}
+{"version":3,"file":"performance-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/performance-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,+BAA+B,QAAO,MAwOlD,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/performance-spoofing.js

@@ -221,7 +221,17 @@ export const createPerformanceSpoofingScript = () => {
         }
     };
     
-    spoofPerformance();
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting performance spoofing...');
+        spoofPerformance();
+        console.log(DEBUG_PREFIX, '✓ Performance spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply performance spoofing:', e);
+        throw e;
+    }
 })();
 `;
 };

package/dist/fingerprinting/fingerprint-overrides/performance-spoofing.js.map

@@ -1 +1 @@
-{"version":3,"file":"performance-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/performance-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAAW,EAAE;IACxD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4NV,CAAC;AACF,CAAC,CAAC"}
+{"version":3,"file":"performance-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/performance-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAAW,EAAE;IACxD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsOV,CAAC;AACF,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.d.ts

@@ -1,6 +1,14 @@
 /**
  * Platform Consistency Script
  * Ensures all browser properties match the specified platform (1:1 fingerprinting)
+ *
+ * 2024-2025 Enhancements:
+ * - Screen orientation API consistency
+ * - screen.availLeft/availTop for Windows
+ * - visualViewport properties consistency
+ * - window.outerWidth/outerHeight ratios
+ * - window.screenX/screenY typical values
+ * - matchMedia() platform-appropriate results
  */
 export interface PlatformConfig {
     platform?: string;
@@ -15,6 +23,11 @@ export interface PlatformConfig {
     language?: string;
     languages?: string[];
     oscpu?: string;
+    userAgent?: string;
+    appVersion?: string;
+    appName?: string;
+    appCodeName?: string;
+    product?: string;
 }
 export declare const createPlatformConsistencyScript: (platform: string, fingerprintData?: PlatformConfig) => string;
 //# sourceMappingURL=platform-consistency.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform-consistency.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/platform-consistency.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,+BAA+B,aAAc,MAAM,oBAAoB,cAAc,KAAG,MAgOpG,CAAC"}
+{"version":3,"file":"platform-consistency.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/platform-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,eAAO,MAAM,+BAA+B,aAAc,MAAM,oBAAoB,cAAc,KAAG,MA+iBpG,CAAC"}