@purespectrum1/purescore-client 0.7.0

package/lib/domain/services/device-fingerprint/canvas.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Generates a canvas fingerprint, which is a technique used to identify browsers based on their unique rendering of a canvas element.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Canvas = void 0;
+class Canvas {
+    getCanvasFingerprint() {
+        const canvas = document.createElement('canvas');
+        const ctx = this._isCanvasSupported(canvas);
+        if (ctx) {
+            const txt = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`~!@#$%^&*()_+-={}|[]\\:"<>?/.,;';
+            ctx.textBaseline = 'top';
+            ctx.font = '14px \'Arial\'';
+            ctx.textBaseline = 'alphabetic';
+            ctx.fillStyle = '#f60';
+            ctx.fillRect(125, 1, 62, 20);
+            ctx.fillStyle = '#069';
+            ctx.fillText(txt, 2, 15);
+            ctx.fillStyle = 'rgba(102, 204, 0, 0.7)';
+            ctx.fillText(txt, 4, 17);
+            return canvas.toDataURL();
+        }
+        return '';
+    }
+    /**
+      * Checks if the browser supports the canvas element and successfully returns a 2D context.
+      */
+    _isCanvasSupported(canvas) {
+        return canvas.getContext ? canvas.getContext('2d') : null;
+    }
+}
+exports.Canvas = Canvas;

package/lib/domain/services/device-fingerprint/display.d.ts

@@ -0,0 +1,49 @@
+import { DisplayChecksInput, DisplayChecks } from "../../protocols/services/device-fingerprint/display";
+export declare class Display {
+    /**
+     * Returns an object containing details about the display, including color depth, height, width, available height and width, inner height and width, and outer height and width.
+     *
+     * @returns {Object} An object containing display details or an empty object if an error occurs.
+     * @example
+     * const displayDetails = getDisplayDetails();
+     * console.log(displayDetails);
+     * // Output: { colorDepth: 24, height: 1080, width: 1920, availHeight: 1040, availWidth: 1920, innerHeight: 1040, innerWidth: 1920, outerHeight: 1080, outerWidth: 1920 }
+     */
+    getDisplayDetails(): DisplayChecksInput | {};
+    /**
+     * Returns the screen resolution as an array of two numbers, with the option to account for orientation.
+     *
+     * @param {boolean} [orientation=false] Whether to account for orientation when determining the resolution.
+     * @returns {number[]} An array containing the screen resolution.
+     * @example
+     * const resolution = getScreenResolution(true);
+     * console.log(resolution);
+     * // Output: [1080, 1920]
+     */
+    getScreenResolution(orientation?: boolean): number[];
+    /**
+     * Returns an object containing the screen's color depth and resolution, with the option to include the resolution and account for orientation.
+     *
+     * @param {boolean} [resolution=false] Whether to include the resolution in the output.
+     * @param {boolean} [orientation=false] Whether to account for orientation when determining the resolution.
+     * @returns {Object} An object containing the screen's color depth and resolution.
+     * @example
+     * const screenProperties = getScreenProperties(true, true);
+     * console.log(screenProperties);
+     * // Output: { colorDepth: 24, resolution: [1080, 1920] }
+     */
+    getScreenProperties(resolution?: boolean, orientation?: boolean): {
+        colorDepth: number;
+        resolution: number[] | null;
+    };
+    /**
+     * Returns an object containing various display checks, including resolution, width, height, and aspect ratio.
+     *
+     * @returns {DisplayChecks} An object containing display checks.
+     * @example
+     * const displayChecks = displayChecks();
+     * console.log(displayChecks);
+     * // Output: { resolution: [1920, 1080], width: 1920, width1: 1, width2: 1, height1: 0.9375, height2: 0.9375, isWider: false, isTaller: false, aspectRatio: 1.7777777777777777 }
+     */
+    displayChecks(): DisplayChecks;
+}

package/lib/domain/services/device-fingerprint/display.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Display = void 0;
+class Display {
+    /**
+     * Returns an object containing details about the display, including color depth, height, width, available height and width, inner height and width, and outer height and width.
+     *
+     * @returns {Object} An object containing display details or an empty object if an error occurs.
+     * @example
+     * const displayDetails = getDisplayDetails();
+     * console.log(displayDetails);
+     * // Output: { colorDepth: 24, height: 1080, width: 1920, availHeight: 1040, availWidth: 1920, innerHeight: 1040, innerWidth: 1920, outerHeight: 1080, outerWidth: 1920 }
+     */
+    getDisplayDetails() {
+        try {
+            return {
+                colorDepth: screen.colorDepth,
+                height: screen.height,
+                width: screen.width,
+                availHeight: screen.availHeight,
+                availWidth: screen.availWidth,
+                innerHeight: window.innerHeight,
+                innerWidth: window.innerWidth,
+                outerHeight: window.outerHeight,
+                outerWidth: window.outerWidth
+            };
+        }
+        catch (err) {
+            return {};
+        }
+    }
+    /**
+     * Returns the screen resolution as an array of two numbers, with the option to account for orientation.
+     *
+     * @param {boolean} [orientation=false] Whether to account for orientation when determining the resolution.
+     * @returns {number[]} An array containing the screen resolution.
+     * @example
+     * const resolution = getScreenResolution(true);
+     * console.log(resolution);
+     * // Output: [1080, 1920]
+     */
+    getScreenResolution(orientation) {
+        const resolution = orientation
+            ? (screen.height > screen.width ? [screen.height, screen.width] : [screen.width, screen.height])
+            : [screen.height, screen.width];
+        return resolution;
+    }
+    /**
+     * Returns an object containing the screen's color depth and resolution, with the option to include the resolution and account for orientation.
+     *
+     * @param {boolean} [resolution=false] Whether to include the resolution in the output.
+     * @param {boolean} [orientation=false] Whether to account for orientation when determining the resolution.
+     * @returns {Object} An object containing the screen's color depth and resolution.
+     * @example
+     * const screenProperties = getScreenProperties(true, true);
+     * console.log(screenProperties);
+     * // Output: { colorDepth: 24, resolution: [1080, 1920] }
+     */
+    getScreenProperties(resolution, orientation) {
+        return {
+            colorDepth: screen.colorDepth,
+            resolution: resolution ? this.getScreenResolution(orientation) : null,
+        };
+    }
+    /**
+     * Returns an object containing various display checks, including resolution, width, height, and aspect ratio.
+     *
+     * @returns {DisplayChecks} An object containing display checks.
+     * @example
+     * const displayChecks = displayChecks();
+     * console.log(displayChecks);
+     * // Output: { resolution: [1920, 1080], width: 1920, width1: 1, width2: 1, height1: 0.9375, height2: 0.9375, isWider: false, isTaller: false, aspectRatio: 1.7777777777777777 }
+     */
+    displayChecks() {
+        return {
+            resolution: [window.innerWidth, window.innerHeight],
+            width: window.innerWidth,
+            width1: window.innerWidth / screen.width,
+            width2: window.innerWidth / window.outerWidth,
+            height1: window.innerHeight / screen.height,
+            height2: window.innerHeight / window.outerHeight,
+            isWider: window.innerWidth > screen.width,
+            isTaller: window.innerHeight > screen.height,
+            aspectRatio: screen.width / screen.height
+        };
+    }
+}
+exports.Display = Display;

package/lib/domain/services/device-fingerprint/hash.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Computes the 32-bit MurmurHash3 of a given string.
+ *
+ * @param {string} key - The input string to hash.
+ * @param {number} seed - The seed value for the hash.
+ * @returns {number} The 32-bit hash value.
+ *
+ * @example
+ * const hash = new Hash().murmurhash3_32_gc("Hello, World!", 0);
+ * console.log(hash); // Output: 592631239
+ */
+export declare class Hash {
+    murmurhash3_32_gc(key: string, seed: number): number;
+}

package/lib/domain/services/device-fingerprint/hash.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Computes the 32-bit MurmurHash3 of a given string.
+ *
+ * @param {string} key - The input string to hash.
+ * @param {number} seed - The seed value for the hash.
+ * @returns {number} The 32-bit hash value.
+ *
+ * @example
+ * const hash = new Hash().murmurhash3_32_gc("Hello, World!", 0);
+ * console.log(hash); // Output: 592631239
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hash = void 0;
+class Hash {
+    murmurhash3_32_gc(key, seed) {
+        const len = key.length;
+        const bytes = len - (len & 3); // largest multiple of 4 <= len
+        let h1 = seed | 0;
+        const c1 = 0xcc9e2d51;
+        const c2 = 0x1b873593;
+        let i = 0;
+        let k1;
+        for (; i < bytes; i += 4) {
+            k1 = (key.charCodeAt(i) & 0xff) |
+                ((key.charCodeAt(i + 1) & 0xff) << 8) |
+                ((key.charCodeAt(i + 2) & 0xff) << 16) |
+                ((key.charCodeAt(i + 3) & 0xff) << 24);
+            k1 = Math.imul(k1, c1);
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = Math.imul(k1, c2);
+            h1 ^= k1;
+            h1 = (h1 << 13) | (h1 >>> 19);
+            h1 = (Math.imul(h1, 5) + 0xe6546b64) | 0;
+        }
+        k1 = 0;
+        switch (len & 3) {
+            case 3:
+                k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+            // eslint-disable-next-line no-fallthrough
+            case 2:
+                k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+            // eslint-disable-next-line no-fallthrough
+            case 1:
+                k1 ^= (key.charCodeAt(i) & 0xff);
+                k1 = Math.imul(k1, c1);
+                k1 = (k1 << 15) | (k1 >>> 17);
+                k1 = Math.imul(k1, c2);
+                h1 ^= k1;
+        }
+        h1 ^= len;
+        h1 ^= h1 >>> 16;
+        h1 = Math.imul(h1, 0x85ebca6b);
+        h1 ^= h1 >>> 13;
+        h1 = Math.imul(h1, 0xc2b2ae35);
+        h1 ^= h1 >>> 16;
+        return h1 >>> 0;
+    }
+}
+exports.Hash = Hash;

package/lib/domain/services/device-fingerprint/index.d.ts

@@ -0,0 +1,8 @@
+export * from './audio';
+export * from './canvas';
+export * from './display';
+export * from './hash';
+export * from './navigator';
+export * from './pointer-capability';
+export * from './storage';
+export * from './utils';

package/lib/domain/services/device-fingerprint/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./audio"), exports);
+__exportStar(require("./canvas"), exports);
+__exportStar(require("./display"), exports);
+__exportStar(require("./hash"), exports);
+__exportStar(require("./navigator"), exports);
+__exportStar(require("./pointer-capability"), exports);
+__exportStar(require("./storage"), exports);
+__exportStar(require("./utils"), exports);

package/lib/domain/services/device-fingerprint/navigator.d.ts

@@ -0,0 +1,110 @@
+import { Language, UADataValues, UAParserDeviceType } from "../../protocols/services/device-fingerprint/navigator";
+export declare class Navigatior {
+    /**
+     * Returns the user agent string of the browser.
+     * @returns {string} The user agent string.
+     * @example
+     * const userAgent = getUserAgent();
+     * console.log(userAgent); // Output: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.3"
+     */
+    getUserAgent(): string;
+    /**
+     * Retrieves high entropy User-Agent Client Hints values.
+     *
+     * This method provides access to detailed browser and platform information through the
+     * User-Agent Client Hints API. It returns a promise that resolves with the requested hints.
+     *
+     * @param {string[]} hints - Array of hint names to retrieve. Common hints include:
+     *   - 'architecture': CPU architecture (e.g., 'x86', 'arm')
+     *   - 'bitness': Platform bitness (e.g., '64', '32')
+     *   - 'model': Device model (usually empty on desktop, populated on mobile)
+     *   - 'platform': Operating system name (e.g., 'Windows', 'macOS', 'Android')
+     *   - 'platformVersion': Operating system version
+     *   - 'uaFullVersion': Full browser version
+     *   - 'fullVersionList': Array of browser brands with full version numbers
+     * @returns {Promise<any>} Promise that resolves with an object containing the requested hint values,
+     *   or undefined if the API is not supported in the current browser.
+     * @example
+     * const hints = await getHighEntropyClientHints(['model', 'platform', 'platformVersion']);
+     * console.log(hints); // Output: { model: '', platform: 'macOS', platformVersion: '13.0.0' }
+     *
+     * @note This API is only supported in Chromium-based browsers (Chrome, Edge, Opera).
+     *   Firefox and Safari do not currently support User-Agent Client Hints.
+     */
+    getHighEntropyClientHints(hints?: string[]): Promise<UADataValues | undefined>;
+    /**
+     * Returns detailed information about the current device using UAParser.
+     *
+     * This function parses the user agent string and returns an object containing:
+     * - Full UAParser result data.
+     * - A `device` object describing the device type (e.g., mobile, tablet).
+     * - Boolean flags `isMobile` and `isTablet` to quickly identify device category.
+     *
+     * @returns {Object} An object with parsed user agent data, device info, and device type booleans.
+     */
+    getDeviceType(): UAParserDeviceType;
+    /**
+     * Returns whether Java is enabled in the browser.
+     * @returns {boolean|string} True if Java is enabled, false if not, or "Error" if an error occurs.
+     * @example
+     * const isJavaEnabled = isJavaEnabled();
+     * console.log(isJavaEnabled); // Output: true
+     */
+    isJavaEnabled(): boolean | string;
+    /**
+     * Returns an object with language information.
+     * @returns {{language: string, systemLanguage: string, userLanguage: string}} An object with language information.
+     * @example
+     * const languages = getLanguages();
+     * console.log(languages); // Output: { language: "en-US", systemLanguage: "en-US", userLanguage: "en-US" }
+     */
+    getLanguages(): Language;
+    /**
+     * Checks if cookies are enabled in the browser.
+     * @returns {boolean|string} True if cookies are enabled, false if not, or "Error" if an error occurs.
+     * @example
+     * isCookieEnabled(); // Returns true or false
+     */
+    isCookieEnabled(): boolean | string;
+    /**
+     * Check for web crawlers.
+     * @returns {boolean|string} True if crawler, false if not.
+     * @example
+     * isCookieEnabled(); // Returns true or false
+     */
+    isCrawler(): boolean;
+    /**
+     * Returns the platform of the device.
+     *
+     * @returns {string} The platform of the device.
+     *
+     * @example
+     * const platform = getPlatform();
+     * console.log(platform); // Output: "64 bits"
+     */
+    getPlatform(): string;
+    /**
+     * Returns an object with navigator properties.
+     * @returns {{userAgent: string, language: string, cpuClass: string, platform: string, doNotTrack: string}} An object with navigator properties.
+     * @example
+     * const navigatorProperties = getNavigatorProperties();
+     * console.log(navigatorProperties); // Output: { userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.3", language: "en-US", cpuClass: "x86_64", platform: "Win32", doNotTrack: "unspecified" }
+     */
+    getNavigatorProperties(): {
+        userAgent: string;
+        language: string;
+        platform: string;
+        doNotTrack: string | null;
+    };
+    /**
+     * Checks whether the browser is being controlled by automation or AI agents connectes through MCP.
+     * @returns {boolean} True if the `navigator.webdriver` flag is set, false otherwise.
+     */
+    isWebDriverEnabled(): boolean;
+    /**
+     * Returns the estimated round-trip time (RTT) of the current network connection in milliseconds.
+     * For more about RTT, see: https://developer.mozilla.org/en-US/docs/Web/API/NetworkInformation/rtt
+     * @returns {number} The RTT in milliseconds, or -1 if the Network Information API is not supported.
+     */
+    getEstimatedRoundTripTime(): number;
+}

package/lib/domain/services/device-fingerprint/navigator.js

@@ -0,0 +1,213 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Navigatior = void 0;
+const ua_parser_js_1 = require("ua-parser-js");
+class Navigatior {
+    /**
+     * Returns the user agent string of the browser.
+     * @returns {string} The user agent string.
+     * @example
+     * const userAgent = getUserAgent();
+     * console.log(userAgent); // Output: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.3"
+     */
+    getUserAgent() {
+        return navigator.userAgent;
+    }
+    /**
+     * Retrieves high entropy User-Agent Client Hints values.
+     *
+     * This method provides access to detailed browser and platform information through the
+     * User-Agent Client Hints API. It returns a promise that resolves with the requested hints.
+     *
+     * @param {string[]} hints - Array of hint names to retrieve. Common hints include:
+     *   - 'architecture': CPU architecture (e.g., 'x86', 'arm')
+     *   - 'bitness': Platform bitness (e.g., '64', '32')
+     *   - 'model': Device model (usually empty on desktop, populated on mobile)
+     *   - 'platform': Operating system name (e.g., 'Windows', 'macOS', 'Android')
+     *   - 'platformVersion': Operating system version
+     *   - 'uaFullVersion': Full browser version
+     *   - 'fullVersionList': Array of browser brands with full version numbers
+     * @returns {Promise<any>} Promise that resolves with an object containing the requested hint values,
+     *   or undefined if the API is not supported in the current browser.
+     * @example
+     * const hints = await getHighEntropyClientHints(['model', 'platform', 'platformVersion']);
+     * console.log(hints); // Output: { model: '', platform: 'macOS', platformVersion: '13.0.0' }
+     *
+     * @note This API is only supported in Chromium-based browsers (Chrome, Edge, Opera).
+     *   Firefox and Safari do not currently support User-Agent Client Hints.
+     */
+    getHighEntropyClientHints() {
+        return __awaiter(this, arguments, void 0, function* (hints = []) {
+            // Return undefined if User-Agent Client Hints API is not supported
+            if (!navigator.userAgentData) {
+                return;
+            }
+            return yield navigator.userAgentData.getHighEntropyValues(hints);
+        });
+    }
+    /**
+     * Returns detailed information about the current device using UAParser.
+     *
+     * This function parses the user agent string and returns an object containing:
+     * - Full UAParser result data.
+     * - A `device` object describing the device type (e.g., mobile, tablet).
+     * - Boolean flags `isMobile` and `isTablet` to quickly identify device category.
+     *
+     * @returns {Object} An object with parsed user agent data, device info, and device type booleans.
+     */
+    getDeviceType() {
+        const parser = new ua_parser_js_1.UAParser();
+        const parserData = parser.getResult();
+        const device = parser.getDevice();
+        return Object.assign(Object.assign({}, parserData), { device: device, isMobile: (device.type && ['mobile'].includes(device.type)) || false, isTablet: (device.type && ['tablet'].includes(device.type)) || false, isDesktop: device.type === undefined ||
+                !['mobile', 'tablet'].includes(device.type) });
+    }
+    /**
+     * Returns whether Java is enabled in the browser.
+     * @returns {boolean|string} True if Java is enabled, false if not, or "Error" if an error occurs.
+     * @example
+     * const isJavaEnabled = isJavaEnabled();
+     * console.log(isJavaEnabled); // Output: true
+     */
+    isJavaEnabled() {
+        return navigator.javaEnabled();
+    }
+    /**
+     * Returns an object with language information.
+     * @returns {{language: string, systemLanguage: string, userLanguage: string}} An object with language information.
+     * @example
+     * const languages = getLanguages();
+     * console.log(languages); // Output: { language: "en-US", systemLanguage: "en-US", userLanguage: "en-US" }
+     */
+    getLanguages() {
+        try {
+            return {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                language: navigator.language || navigator.browserLanguage || "",
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                systemLanguage: navigator.systemLanguage || "",
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                userLanguage: navigator.userLanguage || ""
+            };
+        }
+        catch (err) {
+            return {
+                language: "",
+                systemLanguage: "",
+                userLanguage: ""
+            };
+        }
+    }
+    /**
+     * Checks if cookies are enabled in the browser.
+     * @returns {boolean|string} True if cookies are enabled, false if not, or "Error" if an error occurs.
+     * @example
+     * isCookieEnabled(); // Returns true or false
+     */
+    isCookieEnabled() {
+        let cookieEnabled;
+        try {
+            cookieEnabled = navigator.cookieEnabled || ("testcookie" in document && (document.cookie = "testcookie") && document.cookie.indexOf("testcookie") !== -1);
+            return cookieEnabled;
+        }
+        catch (err) {
+            return "Error";
+        }
+    }
+    /**
+     * Check for web crawlers.
+     * @returns {boolean|string} True if crawler, false if not.
+     * @example
+     * isCookieEnabled(); // Returns true or false
+     */
+    isCrawler() {
+        const userAgent = navigator.userAgent;
+        const crawlerUserAgents = [
+            /googlebot/i,
+            /google-read-aloud/i,
+            /bingbot/i,
+            /slurp/i, // Yahoo
+            /duckduckbot/i,
+            /baiduspider/i,
+            /yandexbot/i,
+            /sogou/i,
+            /exabot/i,
+            /facebookexternalhit/i,
+            /facebot/i,
+            /ia_archiver/i, // Alexa Crawler
+        ];
+        return crawlerUserAgents.some((crawler) => crawler.test(userAgent));
+    }
+    /**
+     * Returns the platform of the device.
+     *
+     * @returns {string} The platform of the device.
+     *
+     * @example
+     * const platform = getPlatform();
+     * console.log(platform); // Output: "64 bits"
+     */
+    getPlatform() {
+        const strPlatform = navigator.platform.toLowerCase();
+        let strOSBits = "Unknown";
+        if (strPlatform.indexOf("x64") !== -1 ||
+            strPlatform.indexOf("wow64") !== -1 ||
+            strPlatform.indexOf("win64") !== -1 ||
+            strPlatform.indexOf("ppc") !== -1 ||
+            strPlatform.indexOf("alpha") !== -1 ||
+            strPlatform.indexOf("68k") !== -1) {
+            strOSBits = "64 bits";
+        }
+        else if (strPlatform.indexOf("win32") !== -1 ||
+            strPlatform.indexOf("x32") !== -1 ||
+            strPlatform.indexOf("x86") !== -1 ||
+            strPlatform.indexOf("iphone") !== -1 ||
+            strPlatform.indexOf("android") !== -1) {
+            strOSBits = "32 bits";
+        }
+        return strOSBits;
+    }
+    /**
+     * Returns an object with navigator properties.
+     * @returns {{userAgent: string, language: string, cpuClass: string, platform: string, doNotTrack: string}} An object with navigator properties.
+     * @example
+     * const navigatorProperties = getNavigatorProperties();
+     * console.log(navigatorProperties); // Output: { userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.3", language: "en-US", cpuClass: "x86_64", platform: "Win32", doNotTrack: "unspecified" }
+     */
+    getNavigatorProperties() {
+        return {
+            userAgent: navigator.userAgent,
+            language: navigator.language,
+            platform: navigator.platform,
+            doNotTrack: navigator.doNotTrack,
+        };
+    }
+    /**
+     * Checks whether the browser is being controlled by automation or AI agents connectes through MCP.
+     * @returns {boolean} True if the `navigator.webdriver` flag is set, false otherwise.
+     */
+    isWebDriverEnabled() {
+        return navigator.webdriver || false;
+    }
+    /**
+     * Returns the estimated round-trip time (RTT) of the current network connection in milliseconds.
+     * For more about RTT, see: https://developer.mozilla.org/en-US/docs/Web/API/NetworkInformation/rtt
+     * @returns {number} The RTT in milliseconds, or -1 if the Network Information API is not supported.
+     */
+    getEstimatedRoundTripTime() {
+        if (navigator.connection && typeof navigator.connection.rtt === 'number') {
+            return navigator.connection.rtt;
+        }
+        return -1;
+    }
+}
+exports.Navigatior = Navigatior;

package/lib/domain/services/device-fingerprint/pointer-capability.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Observes real pointer interactions to detect touch and pen (stylus) input.
+ */
+export declare class PointerCapabilityDetector {
+    private static observed;
+    private static installed;
+    install(): void;
+    hasTouchOrPen(): boolean;
+    hasPen(): boolean;
+    getObserved(): {
+        touch: boolean;
+        pen: boolean;
+    };
+}

package/lib/domain/services/device-fingerprint/pointer-capability.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointerCapabilityDetector = void 0;
+/**
+ * Observes real pointer interactions to detect touch and pen (stylus) input.
+ */
+class PointerCapabilityDetector {
+    install() {
+        if (PointerCapabilityDetector.installed)
+            return;
+        if (typeof window === 'undefined' || !('PointerEvent' in window))
+            return;
+        PointerCapabilityDetector.installed = true;
+        const onPointer = (event) => {
+            const pointerType = event.pointerType;
+            if (pointerType === 'pen')
+                PointerCapabilityDetector.observed.pen = true;
+            else if (pointerType === 'touch')
+                PointerCapabilityDetector.observed.touch = true;
+            // Once both modalities are seen there is nothing left to learn; detach so
+            // we are not carrying a handler on the high-frequency pointermove event.
+            if (PointerCapabilityDetector.observed.pen && PointerCapabilityDetector.observed.touch) {
+                window.removeEventListener('pointerdown', onPointer, true);
+                window.removeEventListener('pointermove', onPointer, true);
+            }
+        };
+        window.addEventListener('pointerdown', onPointer, { capture: true, passive: true });
+        window.addEventListener('pointermove', onPointer, { capture: true, passive: true });
+    }
+    hasTouchOrPen() {
+        return PointerCapabilityDetector.observed.touch || PointerCapabilityDetector.observed.pen;
+    }
+    hasPen() {
+        return PointerCapabilityDetector.observed.pen;
+    }
+    getObserved() {
+        return Object.assign({}, PointerCapabilityDetector.observed);
+    }
+}
+exports.PointerCapabilityDetector = PointerCapabilityDetector;
+PointerCapabilityDetector.observed = { touch: false, pen: false };
+PointerCapabilityDetector.installed = false;