get-browser-fingerprint 1.1.0 → 2.1.1

package/.babelrc

@@ -0,0 +1 @@
+{}

package/.eslintrc

@@ -1,17 +1,8 @@
 {
-    "parserOptions": {
-        "ecmaVersion": 2020,
-        "sourceType": "module"
-    },
-    "env": {
-        "es6": true,
-        "browser": true,
-        "node": true
-    },
-    "extends": [
-        "eslint:recommended"
-    ],
-    "rules": {
-        "no-console": "off"
-    }
+  "extends": [
+    "eslint-config-xs/react"
+  ],
+  "rules": {
+    "jest/no-done-callback": "off"
+  }
 }

package/.github/workflows/commit.yml

@@ -0,0 +1,24 @@
+name: tag
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+    timeout-minutes: 3
+    steps:
+      - name: checkout
+        uses: actions/checkout@v2
+
+      - name: setup node
+        uses: actions/setup-node@v2
+        with:
+          node-version-file: '.nvmrc'
+
+      - name: test
+        run: |
+          yarn install
+          yarn test

package/.github/workflows/tag.yml

@@ -0,0 +1,28 @@
+name: tag
+
+on:
+  push:
+    tags:
+      - v*
+
+jobs:
+  release:
+    runs-on: ubuntu-22.04
+    timeout-minutes: 3
+    steps:
+      - name: checkout
+        uses: actions/checkout@v2
+
+      - name: setup node
+        uses: actions/setup-node@v2
+        with:
+          node-version-file: '.nvmrc'
+          registry-url: https://registry.npmjs.org/
+
+      - name: release
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
+        run: |
+          yarn install
+          yarn test
+          npm publish

package/.jest-run/Template Jest.run.xml

@@ -0,0 +1,9 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="true" type="JavaScriptTestRunnerJest">
+    <node-interpreter value="project" />
+    <node-options value="--experimental-vm-modules" />
+    <working-dir value="" />
+    <scope-kind value="ALL" />
+    <method v="2" />
+  </configuration>
+</component>

package/.nvmrc

@@ -1 +1 @@
-v14.5
+v16.16

package/README.md

@@ -1,19 +1,33 @@
 # get-browser-fingerprint
 
-Zero dependencies package exporting a single function which computes a browser fingerprint.
+Zero dependencies package exporting a single, fast (<15ms) and synchronous function which computes a browser fingerprint, without requiring any permission to the user.
 
 ## Usage
 
 Get browser fingerprint:  
-```javascript
+```js
 import getBrowserFingerprint from 'get-browser-fingerprint';
 const fingerprint = getBrowserFingerprint();
 console.log(fingerprint);
 ```
 
-Get a "stable" browser fingerprint across os/browser updates taking into account only hardware:
-```javascript
-import getBrowserFingerprint from 'get-browser-fingerprint';
-const fingerprint = getBrowserFingerprint(true);
-console.log(fingerprint);
+Options available:
+- `hardwareOnly` (default `false`): leverage only hardware info about device 
+- `enableWebgl` (default `false`): enable webgl renderer, ~4x times slower but adds another deadly powerful hardware detection layer on top of canvas 
+- `debug`: log data used to generate fingerprint to console and add canvas/webgl canvas to body to see rendered image (default `false`)
+
+⚠️ Be careful: the strongest discriminating factor is canvas token which can't be computed on old devices (eg: iPhone 6), deal accordingly ⚠️
+
+## Development
+
+To test locally:
+```sh
+nvm install
+yarn install
+yarn test
 ```
+
+To run example locally:
+```sh
+yarn http-server src -o -c-1 -p 80
+```

package/jest.config.js

@@ -0,0 +1,7 @@
+export default {
+  testEnvironment: 'node',
+  clearMocks: true,
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageProvider: 'v8',
+};

package/package.json

@@ -1,16 +1,19 @@
 {
-    "name": "get-browser-fingerprint",
-    "version": "1.1.0",
-    "author": "Damiano Barbati <damiano.barbati@gmail.com> (http://github.com/damianobarbati)",
-    "repository": "https://github.com/damianobarbati/get-browser-fingerprint",
-    "license": "MIT",
-    "main": "src/index.js",
-    "type": "module",
-    "scripts": {
-        "test": "node src/index.spec.js || echo 'test failed'"
-    },
-    "devDependencies": {
-        "eslint": "^7.8.1",
-        "puppeteer": "^5.2.1"
-    }
+  "name": "get-browser-fingerprint",
+  "version": "2.1.1",
+  "author": "Damiano Barbati <damiano.barbati@gmail.com> (https://github.com/damianobarbati)",
+  "repository": "https://github.com/damianobarbati/get-browser-fingerprint",
+  "license": "MIT",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "eslint": "eslint --ignore-path .gitignore --fix",
+    "test": "NODE_OPTIONS='--experimental-vm-modules' jest --runInBand --no-cache"
+  },
+  "devDependencies": {
+    "eslint-config-xs": "^1.3.0",
+    "http-server": "^14.1.1",
+    "jest": "^28.1.3",
+    "puppeteer": "^16.1.1"
+  }
 }

package/src/index.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>get-browser-fingerprint demo</title>
+  </head>
+  <body>
+    <h1>get-browser-fingerprint</h1>
+
+    <h2 id="default"></h2>
+    <h2 id="hardwareOnly"></h2>
+    <h2 id="enableWebgl"></h2>
+
+    <script type="module">
+      import getFingerprint from './index.js';
+
+      args_default: {
+        const t0 = performance.now();
+        const fingerprint = getFingerprint({ debug: true });
+        const t1 = performance.now();
+
+        const result = `Fingerprint: ${fingerprint} (computed in ${(t1 - t0).toFixed(0)} ms)`;
+        console.log(result);
+        document.getElementById('default').innerText = result;
+      }
+
+      args_hardwareOnly: {
+        const t0 = performance.now();
+        const fingerprint = getFingerprint({ hardwareOnly: true, debug: true });
+        const t1 = performance.now();
+
+        const result = `Fingerprint with hardwareOnly=true: ${fingerprint} (computed in ${(t1 - t0).toFixed(0)} ms)`;
+        console.log(result);
+        document.getElementById('hardwareOnly').innerText = result;
+      }
+
+      args_enableWebgl: {
+        const t0 = performance.now();
+        const fingerprint = getFingerprint({ enableWebgl: true, debug: true });
+        const t1 = performance.now();
+
+        const result = `Fingerprint with enableWebgl=true: ${fingerprint} (computed in ${(t1 - t0).toFixed(0)} ms)`;
+        console.log(result);
+        document.getElementById('enableWebgl').innerText = result;
+      }
+    </script>
+  </body>
+</html>

package/src/index.js

@@ -1,121 +1,248 @@
-export default hardwareOnly => {
-    const { userAgent, language, languages, platform, hardwareConcurrency, deviceMemory } = window.navigator;
-    const plugins = Object.entries(window.navigator.plugins).map(([, plugin]) => plugin.name);
-    const { colorDepth, availWidth, availHeight } = window.screen;
-    const timezoneOffset = new Date().getTimezoneOffset();
-    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    const touchSupport = 'ontouchstart' in window;
-    const canvas = (() => {
-        try {
-            const canvas = document.createElement('canvas');
-            const ctx = canvas.getContext('2d');
-            ctx.textBaseline = 'top';
-            ctx.font = "14px 'Arial'";
-            ctx.textBaseline = 'alphabetic';
-            ctx.fillStyle = '#f60';
-            ctx.fillRect(125, 1, 62, 20);
-            ctx.fillStyle = '#069';
-            ctx.fillText("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`~1!2@3#4$5%6^7&8*9(0)-_=+[{]}|;:',<.>/?", 2, 15);
-            ctx.fillStyle = 'rgba(102, 204, 0, 0.7)';
-            ctx.fillText("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`~1!2@3#4$5%6^7&8*9(0)-_=+[{]}|;:',<.>/?", 4, 17);
-
-            const result = canvas.toDataURL();
-            return result;
-        }
-        catch (error) {
-            return error;
-        }
-    })();
-
-    const data = hardwareOnly ?
-        JSON.stringify({
-            platform,
-            hardwareConcurrency,
-            deviceMemory,
-            colorDepth,
-            availWidth,
-            availHeight,
-            touchSupport,
-            canvas,
-        }) :
-        JSON.stringify({
-            userAgent,
-            language,
-            languages,
-            platform,
-            hardwareConcurrency,
-            deviceMemory,
-            plugins,
-            colorDepth,
-            availWidth,
-            availHeight,
-            timezoneOffset,
-            timezone,
-            touchSupport,
-            canvas,
-        });
-
-    const murmurhash3_32_gc = key => {
-        const remainder = key.length & 3; // key.length % 4
-        const bytes = key.length - remainder;
-        const c1 = 0xcc9e2d51;
-        const c2 = 0x1b873593;
-
-        let h1, h1b, k1;
-
-        for (let i = 0; i < bytes; i++) {
-            k1 =
-            ((key.charCodeAt(i) & 0xff)) |
-            ((key.charCodeAt(++i) & 0xff) << 8) |
-            ((key.charCodeAt(++i) & 0xff) << 16) |
-            ((key.charCodeAt(++i) & 0xff) << 24);
-            ++i;
-
-            k1 = ((((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16))) & 0xffffffff;
-            k1 = (k1 << 15) | (k1 >>> 17);
-            k1 = ((((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16))) & 0xffffffff;
-
-            h1 ^= k1;
-            h1 = (h1 << 13) | (h1 >>> 19);
-            h1b = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16))) & 0xffffffff;
-            h1 = (((h1b & 0xffff) + 0x6b64) + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16));
-        }
-
-        const i = bytes - 1;
-
-        k1 = 0;
-
-        switch (remainder) {
-            case 3: {
-                k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
-                break;
-            }
-            case 2: {
-                k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
-                break;
-            }
-            case 1: {
-                k1 ^= (key.charCodeAt(i) & 0xff);
-                break
-            }
-        }
-
-        k1 = (((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
-        k1 = (k1 << 15) | (k1 >>> 17);
-        k1 = (((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
-        h1 ^= k1;
-
-        h1 ^= key.length;
-
-        h1 ^= h1 >>> 16;
-        h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) & 0xffffffff;
-        h1 ^= h1 >>> 13;
-        h1 = ((((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16))) & 0xffffffff;
-        h1 ^= h1 >>> 16;
-
-        return h1 >>> 0;
+const getBrowserFingerprint = ({ hardwareOnly = false, enableWebgl = false, debug = false } = {}) => {
+  const devicePixelRatio = +parseInt(window.devicePixelRatio);
+
+  const {
+    appName,
+    appCodeName,
+    appVersion,
+    cookieEnabled,
+    deviceMemory,
+    doNotTrack,
+    hardwareConcurrency,
+    language,
+    languages,
+    maxTouchPoints,
+    platform,
+    product,
+    productSub,
+    userAgent,
+    vendor,
+    vendorSub,
+  } = window.navigator;
+
+  const { width, height, colorDepth, pixelDepth } = window.screen;
+  const timezoneOffset = new Date().getTimezoneOffset();
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const touchSupport = 'ontouchstart' in window;
+
+  const canvas = getCanvasID(debug);
+  const webgl = enableWebgl ? getWebglID(debug) : undefined; // undefined will remove this from the stringify down here
+  const webglInfo = enableWebgl ? getWebglInfo(debug) : undefined; // undefined will remove this from the stringify down here
+
+  const data = hardwareOnly
+    ? JSON.stringify({
+        canvas,
+        colorDepth,
+        deviceMemory,
+        devicePixelRatio,
+        hardwareConcurrency,
+        height,
+        maxTouchPoints,
+        pixelDepth,
+        platform,
+        touchSupport,
+        webgl,
+        webglInfo,
+        width,
+      })
+    : JSON.stringify({
+        appCodeName,
+        appName,
+        appVersion,
+        canvas,
+        colorDepth,
+        cookieEnabled,
+        deviceMemory,
+        devicePixelRatio,
+        doNotTrack,
+        hardwareConcurrency,
+        height,
+        language,
+        languages,
+        maxTouchPoints,
+        pixelDepth,
+        platform,
+        product,
+        productSub,
+        timezone,
+        timezoneOffset,
+        touchSupport,
+        userAgent,
+        vendor,
+        vendorSub,
+        webgl,
+        webglInfo,
+        width,
+      });
+
+  const datastring = JSON.stringify(data, null, 4);
+
+  if (debug) console.log('fingerprint data', datastring);
+
+  const result = murmurhash3_32_gc(datastring);
+  return result;
+};
+
+export const getCanvasID = (debug) => {
+  try {
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    const text = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`~1!2@3#4$5%6^7&8*9(0)-_=+[{]}|;:',<.>/?";
+    ctx.textBaseline = 'top';
+    ctx.font = "14px 'Arial'";
+    ctx.textBaseline = 'alphabetic';
+    ctx.fillStyle = '#f60';
+    ctx.fillRect(125, 1, 62, 20);
+    ctx.fillStyle = '#069';
+    ctx.fillText(text, 2, 15);
+    ctx.fillStyle = 'rgba(102, 204, 0, 0.7)';
+    ctx.fillText(text, 4, 17);
+
+    const result = canvas.toDataURL();
+
+    if (debug) {
+      document.body.appendChild(canvas);
+    } else {
+      ctx.clearRect(0, 0, canvas.width, canvas.height);
     }
 
-    const result = murmurhash3_32_gc(data);
+    return murmurhash3_32_gc(result);
+  } catch {
+    return null;
+  }
+};
+
+export const getWebglID = (debug) => {
+  try {
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('webgl');
+    canvas.width = 256;
+    canvas.height = 128;
+
+    const f =
+      'attribute vec2 attrVertex;varying vec2 varyinTexCoordinate;uniform vec2 uniformOffset;void main(){varyinTexCoordinate=attrVertex+uniformOffset;gl_Position=vec4(attrVertex,0,1);}';
+    const g = 'precision mediump float;varying vec2 varyinTexCoordinate;void main() {gl_FragColor=vec4(varyinTexCoordinate,0,1);}';
+    const h = ctx.createBuffer();
+
+    ctx.bindBuffer(ctx.ARRAY_BUFFER, h);
+
+    const i = new Float32Array([-0.2, -0.9, 0, 0.4, -0.26, 0, 0, 0.7321, 0]);
+
+    ctx.bufferData(ctx.ARRAY_BUFFER, i, ctx.STATIC_DRAW), (h.itemSize = 3), (h.numItems = 3);
+
+    const j = ctx.createProgram();
+    const k = ctx.createShader(ctx.VERTEX_SHADER);
+
+    ctx.shaderSource(k, f);
+    ctx.compileShader(k);
+
+    const l = ctx.createShader(ctx.FRAGMENT_SHADER);
+
+    ctx.shaderSource(l, g);
+    ctx.compileShader(l);
+    ctx.attachShader(j, k);
+    ctx.attachShader(j, l);
+    ctx.linkProgram(j);
+    ctx.useProgram(j);
+
+    j.vertexPosAttrib = ctx.getAttribLocation(j, 'attrVertex');
+    j.offsetUniform = ctx.getUniformLocation(j, 'uniformOffset');
+
+    ctx.enableVertexAttribArray(j.vertexPosArray);
+    ctx.vertexAttribPointer(j.vertexPosAttrib, h.itemSize, ctx.FLOAT, !1, 0, 0);
+    ctx.uniform2f(j.offsetUniform, 1, 1);
+    ctx.drawArrays(ctx.TRIANGLE_STRIP, 0, h.numItems);
+
+    const n = new Uint8Array(canvas.width * canvas.height * 4);
+    ctx.readPixels(0, 0, canvas.width, canvas.height, ctx.RGBA, ctx.UNSIGNED_BYTE, n);
+
+    const result = JSON.stringify(n).replace(/,?"[0-9]+":/g, '');
+
+    if (debug) {
+      document.body.appendChild(canvas);
+    } else {
+      ctx.clear(ctx.COLOR_BUFFER_BIT | ctx.DEPTH_BUFFER_BIT | ctx.STENCIL_BUFFER_BIT);
+    }
+
+    return murmurhash3_32_gc(result);
+  } catch {
+    return null;
+  }
+};
+
+export const getWebglInfo = () => {
+  try {
+    const ctx = document.createElement('canvas').getContext('webgl');
+
+    const result = {
+      VERSION: ctx.getParameter(ctx.VERSION),
+      SHADING_LANGUAGE_VERSION: ctx.getParameter(ctx.SHADING_LANGUAGE_VERSION),
+      VENDOR: ctx.getParameter(ctx.VENDOR),
+      SUPORTED_EXTENSIONS: ctx.getSupportedExtensions(),
+    };
+
     return result;
+  } catch {
+    return null;
+  }
+};
+
+export const murmurhash3_32_gc = (key) => {
+  const remainder = key.length & 3; // key.length % 4
+  const bytes = key.length - remainder;
+  const c1 = 0xcc9e2d51;
+  const c2 = 0x1b873593;
+
+  let h1, h1b, k1;
+
+  for (let i = 0; i < bytes; i++) {
+    k1 = (key.charCodeAt(i) & 0xff) | ((key.charCodeAt(++i) & 0xff) << 8) | ((key.charCodeAt(++i) & 0xff) << 16) | ((key.charCodeAt(++i) & 0xff) << 24);
+    ++i;
+
+    k1 = ((k1 & 0xffff) * c1 + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
+    k1 = (k1 << 15) | (k1 >>> 17);
+    k1 = ((k1 & 0xffff) * c2 + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
+
+    h1 ^= k1;
+    h1 = (h1 << 13) | (h1 >>> 19);
+    h1b = ((h1 & 0xffff) * 5 + ((((h1 >>> 16) * 5) & 0xffff) << 16)) & 0xffffffff;
+    h1 = (h1b & 0xffff) + 0x6b64 + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16);
+  }
+
+  const i = bytes - 1;
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3: {
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+      break;
+    }
+    case 2: {
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+      break;
+    }
+    case 1: {
+      k1 ^= key.charCodeAt(i) & 0xff;
+      break;
+    }
+  }
+
+  k1 = ((k1 & 0xffff) * c1 + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
+  k1 = (k1 << 15) | (k1 >>> 17);
+  k1 = ((k1 & 0xffff) * c2 + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
+  h1 ^= k1;
+
+  h1 ^= key.length;
+
+  h1 ^= h1 >>> 16;
+  h1 = ((h1 & 0xffff) * 0x85ebca6b + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) & 0xffffffff;
+  h1 ^= h1 >>> 13;
+  h1 = ((h1 & 0xffff) * 0xc2b2ae35 + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16)) & 0xffffffff;
+  h1 ^= h1 >>> 16;
+
+  return h1 >>> 0;
 };
+
+window.getBrowserFingerprint = getBrowserFingerprint;
+export default getBrowserFingerprint;

package/src/index.spec.js

@@ -1,25 +1,52 @@
-import { strict as assert } from 'assert';
 import puppeteer from 'puppeteer';
-import getBrowserFingerprint from './index.js';
-
-(async () => {
-    await (async () => {
-        const browser = await puppeteer.launch();
-        const page = await browser.newPage();
-        const result = await page.evaluate(getBrowserFingerprint);
-        await browser.close();
-
-        assert.deepStrictEqual(Number.isInteger(result), true, 'fingerprint is not an integer');
-        assert.deepStrictEqual(String(result).length > 7, true, 'fingerprint is not long enough');
-    })();
-
-    await (async () => {
-        const browser = await puppeteer.launch();
-        const page = await browser.newPage();
-        const result = await page.evaluate(getBrowserFingerprint, true);
-        await browser.close();
-
-        assert.deepStrictEqual(Number.isInteger(result), true, 'fingerprint is not an integer');
-        assert.deepStrictEqual(String(result).length > 7, true, 'fingerprint is not long enough');
-    })();
-})().then(console.log).catch(console.error).finally(process.exit);
+
+describe('getBrowserFingerprint', () => {
+  let browser, page;
+
+  beforeAll(async () => {
+    browser = await puppeteer.launch({
+      // headless: false,
+      // devtools: true,
+    });
+    page = await browser.newPage();
+
+    await page.addScriptTag({
+      type: 'module',
+      path: './src/index.js',
+    });
+  });
+
+  afterAll(async () => {
+    await browser.close();
+  });
+
+  it('works without args', async () => {
+    const result = await page.evaluate(() => {
+      const result = window.getBrowserFingerprint();
+      return result;
+    });
+
+    expect(typeof result).toBe('number');
+    expect(String(result).length).toBeGreaterThanOrEqual(7);
+  });
+
+  it('works without hardwareOnly=true', async () => {
+    const result = await page.evaluate(() => {
+      const result = window.getBrowserFingerprint();
+      return result;
+    });
+
+    expect(typeof result).toBe('number');
+    expect(String(result).length).toBeGreaterThanOrEqual(7);
+  });
+
+  it('works with enableWebgl=true', async () => {
+    const result = await page.evaluate(() => {
+      const result = window.getBrowserFingerprint({ enableWebgl: true });
+      return result;
+    });
+
+    expect(typeof result).toBe('number');
+    expect(String(result).length).toBeGreaterThanOrEqual(7);
+  });
+});

package/src/index.spec.js.bak

@@ -0,0 +1,34 @@
+import { strict as assert } from 'assert';
+import puppeteer from 'puppeteer';
+
+const browser = await puppeteer.launch();
+const page = await browser.newPage();
+
+await page.addScriptTag({
+  type: 'module',
+  path: './src/index.js',
+});
+
+await (async () => {
+  const result = await page.evaluate(() => {
+    const result = getBrowserFingerprint();
+    return result;
+  });
+
+  assert.deepStrictEqual(Number.isInteger(result), true, 'fingerprint is not an integer');
+  assert.deepStrictEqual(String(result).length > 7, true, 'fingerprint is not long enough');
+})();
+
+await (async () => {
+  const browser = await puppeteer.launch();
+  const page = await browser.newPage();
+  const result = await page.evaluate(() => {
+    const result = getBrowserFingerprint({ enableWebgl: true });
+    return result;
+  });
+
+  assert.deepStrictEqual(Number.isInteger(result), true, 'fingerprint is not an integer');
+  assert.deepStrictEqual(String(result).length > 7, true, 'fingerprint is not long enough');
+})();
+
+await browser.close();