@thumbmarkjs/thumbmarkjs 1.0.0-rc.2 → 1.1.0-rc.1

package/dist/types/functions/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * ThumbmarkJS: Main fingerprinting and API logic
+ *
+ * This module handles component collection, API calls, uniqueness scoring, and data filtering
+ * for the ThumbmarkJS browser fingerprinting library.
+ *
+ * Exports:
+ *   - getThumbmark
+ *   - getThumbmarkDataFromPromiseMap
+ *   - resolveClientComponents
+ *   - filterThumbmarkData
+ *
+ * Internal helpers and types are also defined here.
+ */
+import { optionsInterface } from "../options";
+import { componentInterface, includeComponent as globalIncludeComponent } from "../factory";
+/**
+ * Info returned from the API (IP, classification, uniqueness, etc)
+ */
+interface infoInterface {
+    ip_address?: {
+        ip_address: string;
+        ip_identifier: string;
+        autonomous_system_number: number;
+        ip_version: 'v6' | 'v4';
+    };
+    classification?: {
+        tor: boolean;
+        proxy: boolean;
+        datacenter: boolean;
+        danger_level: number;
+    };
+    uniqueness?: {
+        score: number | string;
+    };
+    timed_out?: boolean;
+}
+/**
+ * API response structure
+ */
+interface apiResponse {
+    thumbmark?: string;
+    info?: infoInterface;
+    version?: string;
+    components?: componentInterface;
+}
+/**
+ * Final thumbmark response structure
+ */
+interface thumbmarkResponse {
+    components: componentInterface;
+    info: {
+        [key: string]: any;
+    };
+    version: string;
+    thumbmark: string;
+    /**
+     * Only present if options.performance is true.
+     */
+    elapsed?: any;
+}
+/**
+ * Calls the Thumbmark API with the given components, using caching and deduplication.
+ * Returns a promise for the API response or null on error.
+ */
+export declare const getApiPromise: (options: optionsInterface, components: componentInterface) => Promise<apiResponse | null>;
+/**
+ * Main entry point: collects all components, optionally calls API, and returns thumbmark data.
+ *
+ * @param options - Options for fingerprinting and API
+ * @returns thumbmarkResponse (elapsed is present only if options.performance is true)
+ */
+export declare function getThumbmark(options?: optionsInterface): Promise<thumbmarkResponse>;
+/**
+ * Resolves and times all filtered component promises from a component function map.
+ *
+ * @param comps - Map of component functions
+ * @param options - Options for filtering and timing
+ * @returns Object with elapsed times and filtered resolved components
+ */
+export declare function resolveClientComponents(comps: {
+    [key: string]: (options?: optionsInterface) => Promise<componentInterface | null>;
+}, options?: optionsInterface): Promise<{
+    elapsed: Record<string, number>;
+    resolvedComponents: componentInterface;
+}>;
+export { globalIncludeComponent as includeComponent };

package/dist/types/functions/legacy_functions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * This file is here to support legacy implementations.
+ * Eventually, these functions will be removed to keep the library small.
+ */
+import { componentInterface } from '../factory';
+/**
+ *
+ * @deprecated
+ */
+export declare function getFingerprintData(): Promise<componentInterface>;
+/**
+ *
+ * @param includeData boolean
+ * @deprecated this function is going to be removed. use getThumbmark or Thumbmark class instead.
+ */
+export declare function getFingerprint(includeData?: false): Promise<string>;
+export declare function getFingerprint(includeData: true): Promise<{
+    hash: string;
+    data: componentInterface;
+}>;
+/**
+ *
+ * @deprecated use Thumbmark or getThumbmark instead with options
+ */
+export declare function getFingerprintPerformance(): Promise<{
+    elapsed: Record<string, number>;
+}>;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+import { getFingerprint, getFingerprintData, getFingerprintPerformance } from './functions/legacy_functions';
+import { getThumbmark } from './functions';
+import { getVersion } from './utils/version';
+import { setOption } from './options';
+import { includeComponent } from './factory';
+import { Thumbmark } from './thumbmark';
+export { Thumbmark, getThumbmark, getVersion, setOption, getFingerprint, getFingerprintData, getFingerprintPerformance, includeComponent };

package/dist/types/options.d.ts

@@ -0,0 +1,28 @@
+export interface optionsInterface {
+    exclude?: string[];
+    include?: string[];
+    permissions_to_check?: PermissionName[];
+    timeout?: number;
+    logging?: boolean;
+    api_key?: string;
+    cache_api_call?: boolean;
+    performance?: boolean;
+}
+export declare const API_ENDPOINT = "https://api.thumbmarkjs.com";
+export declare const defaultOptions: optionsInterface;
+export declare let options: {
+    exclude?: string[] | undefined;
+    include?: string[] | undefined;
+    permissions_to_check?: PermissionName[] | undefined;
+    timeout?: number | undefined;
+    logging?: boolean | undefined;
+    api_key?: string | undefined;
+    cache_api_call?: boolean | undefined;
+    performance?: boolean | undefined;
+};
+/**
+ *
+ * @param key @deprecated this function will be removed
+ * @param value
+ */
+export declare function setOption<K extends keyof optionsInterface>(key: K, value: optionsInterface[K]): void;

package/dist/types/thumbmark.d.ts

@@ -0,0 +1,26 @@
+import { optionsInterface } from "./options";
+import { componentInterface } from "./factory";
+/**
+ * A client for generating thumbmarks with a persistent configuration.
+ */
+export declare class Thumbmark {
+    private options;
+    /**
+     * Creates a new Thumbmarker client instance.
+     * @param options - Default configuration options for this instance.
+     */
+    constructor(options?: optionsInterface);
+    /**
+     * Generates a thumbmark using the instance's configuration.
+     * @param overrideOptions - Options to override for this specific call.
+     * @returns The thumbmark result.
+     */
+    get(overrideOptions?: optionsInterface): Promise<any>;
+    getVersion(): string;
+    /**
+     * Register a custom component to be included in the fingerprint.
+     * @param key - The component name
+     * @param fn - The component function
+     */
+    includeComponent(key: string, fn: (options?: optionsInterface) => Promise<componentInterface | null>): void;
+}

package/dist/types/utils/commonPixels.d.ts

@@ -0,0 +1 @@
+export declare function getCommonPixels(images: ImageData[], width: number, height: number): ImageData;

package/dist/types/utils/ephemeralIFrame.d.ts

@@ -0,0 +1,4 @@
+export declare function ephemeralIFrame(callback: ({ iframe }: {
+    iframe: Document;
+}) => void): Promise<any>;
+export declare function wait<T = void>(durationMs: number, resolveWith?: T): Promise<T>;

package/dist/types/utils/getMostFrequent.d.ts

@@ -0,0 +1,5 @@
+export declare function mostFrequentValuesInArrayOfDictionaries(arr: {
+    [key: string]: any;
+}[], keys: string[]): {
+    [key: string]: any;
+};

package/dist/types/utils/hash.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This code is taken from https://github.com/LinusU/murmur-128/blob/master/index.js
+ * But instead of dependencies to encode-utf8 and fmix, I've implemented them here.
+ */
+export declare function hash(key: ArrayBuffer | string, seed?: number): string;

package/dist/types/utils/imageDataToDataURL.d.ts

@@ -0,0 +1 @@
+export declare function imageDataToDataURL(imageData: ImageData): string;

package/dist/types/utils/log.d.ts

@@ -0,0 +1,8 @@
+import { componentInterface } from '../factory';
+import { optionsInterface } from '../options';
+/**
+ * Logs thumbmark data to remote logging endpoint (only once per session)
+ * You can disable this by setting options.logging to false.
+ * @internal
+ */
+export declare function logThumbmarkData(thisHash: string, thumbmarkData: componentInterface, options: optionsInterface): Promise<void>;

package/dist/types/utils/raceAll.d.ts

@@ -0,0 +1,9 @@
+type DelayedPromise<T> = Promise<T>;
+export declare function delay<T>(t: number, val: T): DelayedPromise<T>;
+export interface RaceResult<T> {
+    value: T;
+    elapsed?: number;
+}
+export declare function raceAllPerformance<T>(promises: Promise<T>[], timeoutTime: number, timeoutVal: T): Promise<RaceResult<T>[]>;
+export declare function raceAll<T>(promises: Promise<T>[], timeoutTime: number, timeoutVal: T): Promise<(T | undefined)[]>;
+export {};

package/dist/types/utils/version.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns the current package version
+ */
+export declare function getVersion(): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thumbmarkjs/thumbmarkjs",
-  "version": "1.0.0-rc.2",
+  "version": "1.1.0-rc.1",
   "description": "",
   "type": "module",
   "main": "./dist/thumbmark.cjs.js",

package/src/components/audio/index.ts

@@ -1,8 +1,7 @@
 import { componentInterface, componentFunctionInterface, includeComponent } from '../../factory'
-import { optionsInterface } from '../../options';
 import { getBrowser } from '../system/browser'
 
-export default async function getAudio(options?: optionsInterface): Promise<componentInterface | null> {
+export default async function getAudio(): Promise<componentInterface | null> {
   const browser = getBrowser()
   if (!['SamsungBrowser', 'Safari'].includes(browser.name))
     return createAudioFingerprint()

package/src/components/canvas/index.ts

@@ -4,11 +4,6 @@ import { hash } from '../../utils/hash';
 import { getBrowser } from '../system/browser';
 import { optionsInterface } from '../../options';
 
-const browser = getBrowser();
-const name = browser.name.toLowerCase();
-const ver = browser.version.split('.')[0] || '0';
-const majorVer = parseInt(ver, 10);
-
 const _RUNS = 3;
 
 /**
@@ -20,9 +15,12 @@ const _RUNS = 3;
 const _WIDTH = 280;
 const _HEIGHT = 20;
 
-export default async function getCanvas(options?: optionsInterface): Promise<componentInterface | null> {
-  const browser = getBrowser()
-  if (name !== 'firefox' && !(name === 'safari' && majorVer >= 17))
+export default async function getCanvas(): Promise<componentInterface | null> {
+  const browser = getBrowser();
+  const name = browser.name.toLowerCase();
+  const ver = browser.version.split('.')[0] || '0';
+  const majorVer = parseInt(ver, 10);
+  if (!['firefox', 'brave'].includes(name) && !(name === 'safari' && majorVer >= 17))
     return generateCanvasFingerprint()
   return null;
 }
@@ -30,7 +28,6 @@ export default async function getCanvas(options?: optionsInterface): Promise<com
 
 export function generateCanvasFingerprint(): Promise<componentInterface> {
   const canvas = document.createElement('canvas');
-  const ctx = canvas.getContext('2d');
 
   return new Promise((resolve) => {
     /**

package/src/components/plugins/index.ts

@@ -1,20 +1,29 @@
 import { componentInterface, includeComponent } from '../../factory'
+import { getBrowser } from '../system/browser';
 
-export default function getPlugins(): Promise<componentInterface> {
-    const plugins: string[] = [];
-  
-    if (navigator.plugins) {
-      for (let i = 0; i < navigator.plugins.length; i++) {
-        const plugin = navigator.plugins[i];
-        plugins.push([plugin.name, plugin.filename, plugin.description ].join("|"));
-      }
+export default async function getPlugins(): Promise<componentInterface | null> {
+  const browser = getBrowser();
+  const name = browser.name.toLowerCase();
+
+  // Brave will scramble the plugins list, so not including it.
+  if (['brave'].includes(name)) {
+    return null;
+  }
+
+  const plugins: string[] = [];
+
+  if (navigator.plugins) {
+    for (let i = 0; i < navigator.plugins.length; i++) {
+      const plugin = navigator.plugins[i];
+      plugins.push([plugin.name, plugin.filename, plugin.description ].join("|"));
     }
-  
-    return new Promise((resolve) => {
-      resolve(
-        {
-          'plugins': plugins
-        }
-      );
-  });
-  }
+  }
+
+  return new Promise((resolve) => {
+    resolve(
+      {
+        'plugins': plugins
+      }
+    );
+});
+}

package/src/components/screen/index.ts

@@ -1,18 +1,29 @@
 import { componentInterface, includeComponent } from '../../factory';
+import { isMobileUserAgent } from '../system/browser';
 
 export default function getScreen(): Promise<componentInterface> {
     return new Promise((resolve) => {
-        resolve(
-            {
-                'is_touchscreen': navigator.maxTouchPoints > 0,
-                'maxTouchPoints': navigator.maxTouchPoints,
-                'colorDepth': screen.colorDepth,
-                'mediaMatches': matchMedias(),
-            }
-        );
+        const result: componentInterface = {
+            'is_touchscreen': navigator.maxTouchPoints > 0,
+            'maxTouchPoints': navigator.maxTouchPoints,
+            'colorDepth': screen.colorDepth,
+            'mediaMatches': matchMedias(),
+        };
+        if (isMobileUserAgent() && navigator.maxTouchPoints > 0) {
+            result['resolution'] = screenResolution()
+        }
+        resolve(result);
     });
 }
 
+function screenResolution() {
+    const w = window.screen.width;
+    const h = window.screen.height;
+    const longer = Math.max(w, h).toString();
+    const shorter = Math.min(w, h).toString();
+    return `${longer}x${shorter}`
+}
+
 function matchMedias(): string[] {
     let results: string[] = [];
 

package/src/components/system/browser.test.ts

@@ -0,0 +1,113 @@
+import { getBrowser } from './browser';
+
+describe('getBrowser', () => {
+  const originalNavigator = global.navigator;
+
+  function mockUserAgent(ua: string) {
+    Object.defineProperty(global, 'navigator', {
+      value: { userAgent: ua },
+      configurable: true,
+    });
+  }
+
+  afterAll(() => {
+    // Restore original navigator
+    Object.defineProperty(global, 'navigator', {
+      value: originalNavigator,
+      configurable: true,
+    });
+  });
+
+  // Authoritative user agent test cases from DeviceAtlas
+  const cases = [
+    // Chrome (Windows)
+    {
+      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36',
+      expected: { name: 'Chrome', version: '120.0.6099.110' },
+    },
+    // Firefox (Windows)
+    {
+      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0',
+      expected: { name: 'Firefox', version: '120.0' },
+    },
+    // Edge (Windows)
+    {
+      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36 Edg/120.0.2210.61',
+      expected: { name: 'Edge', version: '120.0.2210.61' },
+    },
+    // Safari (macOS)
+    {
+      ua: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15',
+      expected: { name: 'Safari', version: '17.1' },
+    },
+    // Chrome (macOS)
+    {
+      ua: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36',
+      expected: { name: 'Chrome', version: '120.0.6099.110' },
+    },
+    // Firefox (macOS)
+    {
+      ua: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:120.0) Gecko/20100101 Firefox/120.0',
+      expected: { name: 'Firefox', version: '120.0' },
+    },
+    // Chrome (Android)
+    {
+      ua: 'Mozilla/5.0 (Linux; Android 13; SM-G991B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Mobile Safari/537.36',
+      expected: { name: 'Chrome', version: '120.0.6099.110' },
+    },
+    // Samsung Internet (Android)
+    {
+      ua: 'Mozilla/5.0 (Linux; Android 13; SAMSUNG SM-G991B) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/23.0 Chrome/120.0.6099.110 Mobile Safari/537.36',
+      expected: { name: 'SamsungBrowser', version: '23.0' },
+    },
+    // Firefox (Android)
+    {
+      ua: 'Mozilla/5.0 (Android 13; Mobile; rv:120.0) Gecko/120.0 Firefox/120.0',
+      expected: { name: 'Firefox', version: '120.0' },
+    },
+    // Safari (iPhone)
+    {
+      ua: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1',
+      expected: { name: 'Safari', version: '17.1' },
+    },
+    // Chrome (iPhone)
+    {
+      ua: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/120.0.6099.110 Mobile/15E148 Safari/604.1',
+      expected: { name: 'Chrome', version: '120.0.6099.110' },
+    },
+    // Firefox (iPhone)
+    {
+      ua: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/120.0 Mobile/15E148 Safari/604.1',
+      expected: { name: 'Firefox', version: '120.0' },
+    },
+    // Opera (Windows)
+    {
+      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36 OPR/107.0.5045.36',
+      expected: { name: 'Opera', version: '107.0.5045.36' },
+    },
+    // Vivaldi (Windows)
+    {
+      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36 Vivaldi/6.4.3160.49',
+      expected: { name: 'Vivaldi', version: '6.4.3160.49' },
+    },
+    // Brave (Windows)
+    {
+      ua: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.6099.110 Safari/537.36 Brave/1.62.153',
+      expected: { name: 'Brave', version: '1.62.153' },
+    },
+    // Unknown
+    {
+      ua: 'SomeRandomUserAgent/1.0',
+      expected: { name: 'SomeRandomUserAgent', version: '1.0' },
+    },
+  ];
+
+  cases.forEach(({ ua, expected }) => {
+    it(`should detect ${expected.name} ${expected.version} from UA: ${ua}`, () => {
+      mockUserAgent(ua);
+      const result = getBrowser();
+      expect(result.name.toLowerCase()).toBe(expected.name.toLowerCase());
+      expect(result.version).toContain(expected.version.split('.')[0]); // loose match for version
+    });
+  });
+}); 

package/src/components/system/browser.ts

@@ -12,52 +12,84 @@ export function getBrowser(): BrowserResult {
       version: "unknown"
     }
   }
-    const ua = navigator.userAgent
-    // Define some regular expressions to match different browsers and their versions
-    const regexes = [
-      // Samsung internet browser
-      /(?<name>SamsungBrowser)\/(?<version>\d+(?:\.\d+)?)/,
-      // Edge
-      /(?<name>Edge|Edg)\/(?<version>\d+(?:\.\d+)?)/,
-      // Chrome, Chromium, Opera, Vivaldi, Brave, etc.
-      /(?<name>(?:Chrome|Chromium|OPR|Opera|Vivaldi|Brave))\/(?<version>\d+(?:\.\d+)?)/,
-      // Firefox, Waterfox, etc.
-      /(?<name>(?:Firefox|Waterfox|Iceweasel|IceCat))\/(?<version>\d+(?:\.\d+)?)/,
-      // Safari, Mobile Safari, etc.
-      /(?<name>Safari)\/(?<version>\d+(?:\.\d+)?)/,
-      // Internet Explorer, IE Mobile, etc.
-      /(?<name>MSIE|Trident|IEMobile).+?(?<version>\d+(?:\.\d+)?)/,
-      // Samsung browser (Tizen format)
-      /(?<name>samsung).*Version\/(?<version>\d+(?:\.\d+)?)/i,
-      // Other browsers that use the format "BrowserName/version"
-      /(?<name>[A-Za-z]+)\/(?<version>\d+(?:\.\d+)?)/,
-    ];
-  
-    // Define a map for browser name translations
-    const browserNameMap: { [key: string]: string } = {
-      'edg': 'Edge',
-      'opr': 'Opera',
-      'samsung': 'SamsungBrowser'
-    };
+  const ua = navigator.userAgent;
+  // DeviceAtlas authoritative regex order and patterns
+  const regexes = [
+    // Samsung Internet (Android)
+    /(?<name>SamsungBrowser)\/(?<version>\d+(?:\.\d+)+)/,
+    // Edge (Chromium, Android, iOS)
+    /(?<name>EdgA|EdgiOS|Edg)\/(?<version>\d+(?:\.\d+)+)/,
+    // Opera (OPR, OPX, Opera Mini, Opera Mobi)
+    /(?<name>OPR|OPX)\/(?<version>\d+(?:\.\d+)+)/,
+    /Opera[\s\/](?<version>\d+(?:\.\d+)+)/,
+    /Opera Mini\/(?<version>\d+(?:\.\d+)+)/,
+    /Opera Mobi\/(?<version>\d+(?:\.\d+)+)/,
+    // Vivaldi
+    /(?<name>Vivaldi)\/(?<version>\d+(?:\.\d+)+)/,
+    // Brave (Brave/1.62.153)
+    /(?<name>Brave)\/(?<version>\d+(?:\.\d+)+)/,
+    // Chrome iOS (CriOS)
+    /(?<name>CriOS)\/(?<version>\d+(?:\.\d+)+)/,
+    // Firefox iOS (FxiOS)
+    /(?<name>FxiOS)\/(?<version>\d+(?:\.\d+)+)/,
+    // Chrome, Chromium (desktop & Android)
+    /(?<name>Chrome|Chromium)\/(?<version>\d+(?:\.\d+)+)/,
+    // Firefox (desktop & Android)
+    /(?<name>Firefox|Waterfox|Iceweasel|IceCat)\/(?<version>\d+(?:\.\d+)+)/,
+    // Safari (desktop & iOS): prefer Version/x.y if present, else Safari/x.y
+    /Version\/(?<version1>[\d.]+).*Safari\/[\d.]+|(?<name>Safari)\/(?<version2>[\d.]+)/,
+    // Internet Explorer, IE Mobile
+    /(?<name>MSIE|Trident|IEMobile).+?(?<version>\d+(?:\.\d+)+)/,
+    // Other browsers that use the format "BrowserName/version"
+    /(?<name>[A-Za-z]+)\/(?<version>\d+(?:\.\d+)+)/,
+  ];
+
+  // Map UA tokens to canonical browser names
+  const browserNameMap: { [key: string]: string } = {
+    'edg': 'Edge',
+    'edga': 'Edge',
+    'edgios': 'Edge',
+    'opr': 'Opera',
+    'opx': 'Opera',
+    'crios': 'Chrome',
+    'fxios': 'Firefox',
+    'samsung': 'SamsungBrowser',
+    'vivaldi': 'Vivaldi',
+    'brave': 'Brave',
+  };
 
-    // Loop through the regexes and try to find a match
-    for (const regex of regexes) {
-      const match = ua.match(regex);
-      if (match && match.groups) {
-        // Translate the browser name if necessary
-        const name = browserNameMap[match.groups.name.toLowerCase()] || match.groups.name;
-        // Return the browser name and version
-        return {
-          name: name,
-          version: match.groups.version
-        };
+  for (const regex of regexes) {
+    const match = ua.match(regex);
+    if (match) {
+      let name = match.groups?.name;
+      let version = match.groups?.version || match.groups?.version1 || match.groups?.version2;
+      // For Safari, if Version/x.y matched, set name to Safari
+      if (!name && (match.groups?.version1 || match.groups?.version2)) name = 'Safari';
+      // Fallbacks for legacy Opera/Opera Mini/Opera Mobi
+      if (!name && regex.source.includes('Opera Mini')) name = 'Opera Mini';
+      if (!name && regex.source.includes('Opera Mobi')) name = 'Opera Mobi';
+      if (!name && regex.source.includes('Opera')) name = 'Opera';
+      // Fallback for generic [A-Za-z]+/version
+      if (!name && match[1]) name = match[1];
+      if (!version && match[2]) version = match[2];
+      if (name) {
+        const canonical = browserNameMap[name.toLowerCase()] || name;
+        return { name: canonical, version: version || 'unknown' };
       }
     }
-  
-    // If no match is found, return unknown
-    return {
-      name: "unknown",
-      version: "unknown"
-    };
   }
+  return {
+    name: "unknown",
+    version: "unknown"
+  };
+}
+
+// Utility function to detect if a user agent is a mobile device (DeviceAtlas-style)
+export function isMobileUserAgent(): boolean {
+  if (typeof navigator === 'undefined' || !navigator.userAgent) return false;
+  const ua = navigator.userAgent;
+  // Exclude iPad from 'mobile' (treat as tablet)
+  return /Mobi|Android|iPhone|iPod|IEMobile|Opera Mini|Opera Mobi|webOS|BlackBerry|Windows Phone/i.test(ua)
+    && !/iPad/i.test(ua);
+}
   

package/src/components/system/index.ts

@@ -1,9 +1,10 @@
-import { componentInterface, includeComponent } from '../../factory';
-import { getBrowser } from './browser'
+import { componentInterface } from '../../factory';
+import { getBrowser, isMobileUserAgent } from './browser'
 
 export default function getSystem(): Promise<componentInterface> {
     return new Promise((resolve) => {
         const browser = getBrowser()
+        const ua = navigator.userAgent;
 
         const result: componentInterface = {
         'platform': window.navigator.platform,
@@ -12,6 +13,7 @@ export default function getSystem(): Promise<componentInterface> {
         'useragent': navigator.userAgent,
         'hardwareConcurrency': navigator.hardwareConcurrency,
         'browser': {'name': browser.name, 'version': browser.version },
+        'mobile': isMobileUserAgent(),
         }
         // Safari handles these differently in an iFrame so removing them from components
         if (browser.name.toLowerCase() !== 'safari') {

package/src/functions/functions.test.ts

@@ -1,5 +1,5 @@
 import { componentInterface } from '../factory'
-import { filterThumbmarkData } from '../utils/filterComponents'
+import { filterThumbmarkData } from './filterComponents'
 import { defaultOptions } from '../options';
 
 const test_components: componentInterface = {