get-browser-fingerprint 4.1.1 → 5.0.1

package/README.md

@@ -1,10 +1,35 @@
 # get-browser-fingerprint
 
-Zero dependencies package exporting a single and fast (<50ms) asynchronous function returning a browser fingerprint, without requiring any permission to the user.  
+A single and fast (<50ms) asynchronous function returning a browser fingerprint, without requiring any permission to the user.  
+
+## Assumptions
+
+The function is targeting stock installations of the following browsers (no extensions or add-ons installed):
+- Google Chrome (desktop and Android)
+- Mozilla Firefox (desktop, default tracking protection, no custom privacy flags enabled)
+- Microsoft Edge (desktop and Android)
+- Apple Safari (macOS)
+- Safari on iOS / iPadOS
+
+Explicit assumptions:
+- No privacy-focused extensions or add-ons installed.
+- Browser privacy settings left at factory defaults (no manual changes to fingerprint resistance features).
+- No hardened, anti-detect or heavily modified browser variants.
+
+Under these conditions the collected signals retain meaningful entropy in February 2026:
+- Canvas rendering (stable on Chrome, Edge, Firefox default; noisy or low-entropy on iOS Safari and partially on macOS Safari)
+- WebGL unmasked vendor and renderer (strong on desktop, more uniform on mobile)
+- Offline audio context (useful on Chrome, Edge, Firefox; heavily restricted on Safari)
+- WebGPU properties (if available; low but increasing entropy)
+- Locally installed fonts (valuable mainly on desktop Windows and macOS)
+- Passive signals (hardwareConcurrency, deviceMemory, screen, timezone, languages, etc.)
+
+On browsers with strong default fingerprint resistance (Safari iOS, certain Firefox modes) entropy and stability decrease significantly.  
+The script does not attempt to bypass intentional randomization or hardening.
 
 ## Usage
 
-Get browser fingerprint:  
+Get browser fingerprint:
 ```js
 import getBrowserFingerprint from 'get-browser-fingerprint';
 const fingerprint = await getBrowserFingerprint();
@@ -19,9 +44,13 @@ Options available:
 
 To test locally:
 ```sh
-fnm install
-pnpm install
+fnm install # nodejs from .nvmrc
+npm install -g corepack
+corepack enable # package manager from package.json
+corepack install # package manager from package.json
+pnpm install # install deps
 pnpm exec playwright install chromium
+pnpm exec playwright install firefox
 pnpm test
 ```
 

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "get-browser-fingerprint",
-  "version": "4.1.1",
+  "version": "5.0.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",
+  "packageManager": "pnpm@10.28.2",
+  "engines": {
+    "node": ">=25.6",
+    "pnpm": ">=10.28"
+  },
   "type": "module",
+  "main": "src/index.js",
   "files": [
     "README.md",
     "package.json",
@@ -14,13 +19,13 @@
   ],
   "types": "./src/index.d.ts",
   "scripts": {
+    "postinstall": "pnpm audit --audit-level critical",
     "lint": "biome check --write",
-    "test": "vitest run"
+    "test": "node --test --test-reporter=spec --test-reporter-destination=stdout"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.2.2",
-    "@playwright/test": "^1.55.0",
-    "serve": "^14.2.4",
-    "vitest": "^3.2.4"
+    "@biomejs/biome": "^2.4.0",
+    "@playwright/test": "^1.58.2",
+    "serve": "^14.2.5"
   }
 }

package/src/index.d.ts

@@ -1,9 +1,12 @@
 export interface FingerprintOptions {
-  hardwareOnly?: boolean;
   debug?: boolean;
 }
 
-export default function getBrowserFingerprint(options?: FingerprintOptions): Promise<number>;
+export type FingerprintResult = {
+  fingerprint: string;
+} & Record<string, string>;
+
+export default function getBrowserFingerprint(options?: FingerprintOptions): Promise<FingerprintResult>;
 
 declare global {
   interface Window {

package/src/index.js

@@ -1,339 +1,358 @@
-/** @type {import('./index.d.ts').getBrowserFingerprint} */
-const getBrowserFingerprint = async ({ hardwareOnly = true, debug = false } = {}) => {
-  const { cookieEnabled, deviceMemory, doNotTrack, hardwareConcurrency, language, languages, maxTouchPoints, platform, userAgent, vendor } = window.navigator;
+const murmurHash3 = (key, seed = 0) => {
+  let h = seed ^ key.length;
+
+  let i = 0;
+  const len = key.length;
+
+  while (i + 3 < len) {
+    let k = (key.charCodeAt(i) & 0xff) | ((key.charCodeAt(i + 1) & 0xff) << 8) | ((key.charCodeAt(i + 2) & 0xff) << 16) | ((key.charCodeAt(i + 3) & 0xff) << 24);
+    k = Math.imul(k, 0xcc9e2d51);
+    k = (k << 15) | (k >>> 17); // ROTL32(k, 15)
+    k = Math.imul(k, 0x1b873593);
+    h ^= k;
+    h = (h << 13) | (h >>> 19); // ROTL32(h, 13)
+    h = Math.imul(h, 5) + 0xe6546b64;
+    i += 4;
+  }
+
+  // tail
+  let k1 = 0;
+  switch (len - i) {
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: ignore
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+    // biome-ignore lint/suspicious/noFallthroughSwitchClause: ignore
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = Math.imul(k1, 0xcc9e2d51);
+      k1 = (k1 << 15) | (k1 >>> 17);
+      k1 = Math.imul(k1, 0x1b873593);
+      h ^= k1;
+  }
 
-  // we use screen info only on mobile, because on desktop the user may use multiple monitors
-  const enableScreen = /Mobi|Android|iPhone|iPad|iPod/i.test(navigator.userAgent);
+  h ^= h >>> 16;
+  h = Math.imul(h, 0x85ebca6b);
+  h ^= h >>> 13;
+  h = Math.imul(h, 0xc2b2ae35);
+  h ^= h >>> 16;
+  h = h >>> 0; // force unsigned 32 bit
 
-  const { width, height, colorDepth, pixelDepth } = enableScreen ? window.screen : {}; // undefined will remove this from the stringify down here
-  const timezoneOffset = new Date().getTimezoneOffset();
-  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  const touchSupport = "ontouchstart" in window;
-  const devicePixelRatio = window.devicePixelRatio;
-
-  const canvas = getCanvasID(debug);
-  const audio = await getAudioID(debug);
-  const audioInfo = getAudioInfo();
-  const webgl = getWebglID(debug);
-  const webglInfo = getWebglInfo();
-
-  const data = hardwareOnly
-    ? {
-        audioInfo,
-        audio,
-        canvas,
-        colorDepth,
-        deviceMemory,
-        devicePixelRatio,
-        hardwareConcurrency,
-        height,
-        maxTouchPoints,
-        pixelDepth,
-        platform,
-        touchSupport,
-        webgl,
-        webglInfo,
-        width,
-      }
-    : {
-        audioInfo,
-        audio,
-        canvas,
-        colorDepth,
-        cookieEnabled,
-        deviceMemory,
-        devicePixelRatio,
-        doNotTrack,
-        hardwareConcurrency,
-        height,
-        language,
-        languages,
-        maxTouchPoints,
-        pixelDepth,
-        platform,
-        timezone,
-        timezoneOffset,
-        touchSupport,
-        userAgent,
-        vendor,
-        webgl,
-        webglInfo,
-        width,
-      };
-
-  if (debug) console.log("Fingerprint data:", JSON.stringify(data, null, 2));
-
-  const payload = JSON.stringify(data, null, 2);
-  const result = murmurhash3_32_gc(payload);
+  const result = h.toString(16).padStart(8, '0');
   return result;
 };
 
-const getCanvasID = (debug) => {
+const safe = async (fn) => {
   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);
-    }
-
-    return murmurhash3_32_gc(result);
+    return await fn();
   } catch {
     return null;
   }
 };
 
-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;
+const stableStringify = (obj) => {
+  // handle null, string, number, boolean
+  if (obj === null || typeof obj !== 'object') return JSON.stringify(obj);
+  // handle arrays recursively
+  if (Array.isArray(obj)) return `[${obj.map(stableStringify).join(',')}]`;
+
+  const keys = Object.keys(obj).sort();
+  const parts = [];
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== undefined) parts.push(`${stableStringify(key)}:${stableStringify(value)}`);
   }
-};
 
-const getWebglInfo = () => {
-  try {
-    const ctx = document.createElement("canvas").getContext("webgl");
+  return `{${parts.join(',')}}`;
+};
 
-    const result = {
-      VERSION: String(ctx.getParameter(ctx.VERSION)),
-      SHADING_LANGUAGE_VERSION: String(ctx.getParameter(ctx.SHADING_LANGUAGE_VERSION)),
-      VENDOR: String(ctx.getParameter(ctx.VENDOR)),
-      SUPPORTED_EXTENSIONS: String(ctx.getSupportedExtensions()),
-    };
+const isMobile = () =>
+  navigator.userAgentData?.mobile === true ||
+  /Mobi|Android|iPhone|iPad|iPod|webOS|BlackBerry|Windows Phone/i.test(navigator.userAgent) ||
+  (navigator.maxTouchPoints > 0 && matchMedia('(pointer:coarse)').matches && innerWidth <= 1024);
 
-    return result;
-  } catch {
-    return null;
-  }
+/** @type {import('./index.d.ts').getBrowserFingerprint} */
+const getBrowserFingerprint = async ({ debug = false } = {}) => {
+  // software
+  const fonts = await safe(() => getFonts());
+  const numberingSystem = await safe(() => new Intl.NumberFormat(window.navigator.languages?.[0] || 'en').resolvedOptions().numberingSystem);
+  const languages = window.navigator.languages ? Array.from(window.navigator.languages).join(',') : window.navigator.language || null;
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const timezoneOffset = new Date().getTimezoneOffset();
+  const reducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches ? 'reduce' : 'no-preference';
+  const colorScheme = window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+
+  // hardware
+  const forcedColors = window.matchMedia('(forced-colors: active)').matches ? 'active' : null;
+  const { pixelDepth, colorDepth } = window.screen;
+  const touchSupport = 'ontouchstart' in window || window.navigator.maxTouchPoints > 0;
+  const canvasID = await safe(() => getCanvasID(debug));
+  const webglID = await safe(() => getWebglID());
+  const webgpuID = await safe(() => getWebgpuID(debug));
+  const audioID = await safe(() => getAudioID(debug));
+  const aspectRatio = window.screen.width && window.screen.height ? (window.screen.width / window.screen.height).toFixed(4) : null;
+
+  const data = {
+    // SOFTWARE
+    vendor: window.navigator.vendor || null, // vendor
+    platform: window.navigator.platform || null, // os
+    fonts, // stable default os setting
+    numberingSystem, // stable default os setting
+    languages, // stable user locale/setting
+    timezone, // stable user locale/setting
+    timezoneOffset, // stable user locale/setting
+    reducedMotion, // stable user locale/setting
+    colorScheme, // stable user locale/setting
+    // HARDWARE
+    hardwareConcurrency: window.navigator.hardwareConcurrency || null, // cpu
+    deviceMemory: window.navigator.deviceMemory || null, // ram
+    forcedColors, // display
+    pixelDepth, // display
+    colorDepth, // display
+    touchSupport, // display
+    canvasID, // gpu
+    webglID, // gpu
+    webgpuID, // gpu
+    audioID, // audio
+  };
+
+  const mobileData = {
+    aspectRatio,
+    width: window.screen.width,
+    height: window.screen.height,
+    maxTouchPoints: window.navigator.maxTouchPoints,
+  };
+
+  if (isMobile()) Object.assign(data, mobileData);
+
+  const payload = stableStringify(data);
+  const fingerprint = murmurHash3(payload);
+  return { fingerprint, ...data };
 };
 
-const getAudioInfo = () => {
-  try {
-    const OfflineAudioContext = window.OfflineAudioContext || window.webkitOfflineAudioContext;
-    const length = 44100;
-    const sampleRate = 44100;
-    const context = new OfflineAudioContext(1, length, sampleRate);
-
-    const result = {
-      sampleRate: context.sampleRate,
-      channelCount: context.destination.maxChannelCount,
-      outputLatency: context.outputLatency,
-      state: context.state,
-      baseLatency: context.baseLatency,
-    };
-
-    return result;
-  } catch {
-    return null;
+const getCanvasID = async (debug) => {
+  const canvas = document.createElement('canvas');
+  canvas.width = 280;
+  canvas.height = 100;
+  const ctx = canvas.getContext('2d');
+
+  // background with gradient
+  const grad = ctx.createLinearGradient(0, 0, 280, 100);
+  grad.addColorStop(0, '#f60');
+  grad.addColorStop(0.4, '#09f');
+  grad.addColorStop(0.7, '#f09');
+  grad.addColorStop(1, '#0f9');
+  ctx.fillStyle = grad;
+  ctx.fillRect(0, 0, 280, 100);
+
+  // text with multiple fonts and emoji
+  ctx.font = '18px "Arial","Helvetica","DejaVu Sans",sans-serif';
+  ctx.fillStyle = '#000';
+  ctx.textBaseline = 'alphabetic';
+  ctx.fillText('Fingerprint ¼½¾™©®∆π∑€¶§', 12, 45);
+
+  ctx.font = 'bold 22px "Georgia","Times New Roman",serif';
+  ctx.fillStyle = '#222';
+  ctx.fillText('🦊🐱🚀 2026', 12, 78);
+
+  // content with antialiasing and compositing
+  ctx.globalAlpha = 0.7;
+  ctx.fillStyle = 'rgba(255, 80, 0, 0.35)';
+  ctx.fillRect(180, 20, 80, 60);
+
+  ctx.beginPath();
+  ctx.arc(220, 50, 32, 0, Math.PI * 2);
+  ctx.strokeStyle = '#fff';
+  ctx.lineWidth = 4;
+  ctx.stroke();
+
+  ctx.beginPath();
+  ctx.moveTo(30, 85);
+  ctx.quadraticCurveTo(140, 20, 240, 85);
+  ctx.strokeStyle = '#00f';
+  ctx.lineWidth = 3;
+  ctx.stroke();
+
+  if (debug) {
+    canvas.style.border = '1px solid #444';
+    document.body.appendChild(canvas);
   }
-};
 
-const getAudioID = async (debug) => {
-  try {
-    const OfflineAudioContext = window.OfflineAudioContext || window.webkitOfflineAudioContext;
-    const sampleRate = 44100;
-    const length = 44100; // Number of samples (1 second of audio)
-    const context = new OfflineAudioContext(1, length, sampleRate);
-
-    // Create an oscillator to generate sound
-    const oscillator = context.createOscillator();
-    oscillator.type = "sine";
-    oscillator.frequency.value = 440;
-
-    oscillator.connect(context.destination);
-    oscillator.start();
-
-    // Render the audio into a buffer
-    const renderedBuffer = await context.startRendering();
-    const channelData = renderedBuffer.getChannelData(0);
-
-    // Generate fingerprint by summing the absolute values of the audio data
-    const result = channelData.reduce((acc, val) => acc + Math.abs(val), 0).toString();
-
-    if (debug) {
-      const wavBlob = bufferToWav(renderedBuffer);
-      const audioURL = URL.createObjectURL(wavBlob);
-
-      const audioElement = document.createElement("audio");
-      audioElement.controls = true;
-      audioElement.src = audioURL;
-      document.body.appendChild(audioElement);
-    }
+  const dataUrl = canvas.toDataURL('image/png');
+  const result = murmurHash3(dataUrl);
+  return result;
+};
 
-    return murmurhash3_32_gc(result);
-  } catch {
-    return null;
-  }
+const getWebglID = () => {
+  const canvas = document.createElement('canvas');
+  const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+  const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+  const vendor = debugInfo ? gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) : gl.getParameter(gl.VENDOR);
+  const renderer = debugInfo ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER);
+  const info = { vendor, renderer };
+  const result = murmurHash3(stableStringify(info));
+  return result;
 };
 
-const bufferToWav = (buffer) => {
-  const numOfChannels = buffer.numberOfChannels;
-  const length = buffer.length * numOfChannels * 2 + 44; // Buffer size in bytes
-  const wavBuffer = new ArrayBuffer(length);
-  const view = new DataView(wavBuffer);
-
-  // Write WAV file header
-  writeString(view, 0, "RIFF");
-  view.setUint32(4, length - 8, true);
-  writeString(view, 8, "WAVE");
-  writeString(view, 12, "fmt ");
-  view.setUint32(16, 16, true);
-  view.setUint16(20, 1, true);
-  view.setUint16(22, numOfChannels, true);
-  view.setUint32(24, buffer.sampleRate, true);
-  view.setUint32(28, buffer.sampleRate * numOfChannels * 2, true);
-  view.setUint16(32, numOfChannels * 2, true);
-  view.setUint16(34, 16, true);
-  writeString(view, 36, "data");
-  view.setUint32(40, length - 44, true);
-
-  // Write interleaved audio data
-  let offset = 44;
-  for (let i = 0; i < buffer.length; i++) {
-    for (let channel = 0; channel < numOfChannels; channel++) {
-      const sample = buffer.getChannelData(channel)[i];
-      const intSample = Math.max(-1, Math.min(1, sample)) * 32767;
-      view.setInt16(offset, intSample, true);
-      offset += 2;
-    }
+const getWebgpuID = async (debug) => {
+  const adapter = await navigator.gpu.requestAdapter({ powerPreference: 'high-performance' });
+  const vendor = adapter.info?.vendor ?? '';
+  const architecture = adapter.info?.architecture ?? '';
+  const description = adapter.info?.description ?? '';
+  const features = Array.from(adapter.features).sort();
+  const limits = Array.from(adapter.limits).sort();
+  const info = { vendor, architecture, description, features, limits };
+
+  if (debug) {
+    const debugDiv = document.createElement('pre');
+    debugDiv.style.margin = '10px 0';
+    debugDiv.style.padding = '10px';
+    debugDiv.style.border = '1px solid #444';
+    debugDiv.style.background = '#111';
+    debugDiv.style.color = '#0f8';
+    debugDiv.style.fontFamily = 'monospace';
+    debugDiv.textContent = `WebGPU:\n${JSON.stringify(info, null, 2)}`;
+    document.body.appendChild(debugDiv);
   }
 
-  return new Blob([view], { type: "audio/wav" });
+  const result = murmurHash3(stableStringify(info));
+  return result;
 };
 
-const writeString = (view, offset, string) => {
-  for (let i = 0; i < string.length; i++) {
-    view.setUint8(offset + i, string.charCodeAt(i));
+const getAudioID = async (debug) => {
+  const OfflineCtx = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+
+  const context = new OfflineCtx(1, 6000, 44100);
+  const osc = context.createOscillator();
+  osc.type = 'sawtooth';
+  osc.frequency.value = 8800;
+
+  const compressor = context.createDynamicsCompressor();
+  compressor.threshold.value = -48;
+  compressor.knee.value = 30;
+  compressor.ratio.value = 14;
+  compressor.attack.value = 0;
+  compressor.release.value = 0.3;
+
+  const gain = context.createGain();
+  gain.gain.value = 0.4;
+
+  osc.connect(compressor);
+  compressor.connect(gain);
+  gain.connect(context.destination);
+
+  osc.start(0);
+  const buffer = await context.startRendering();
+  const channel = buffer.getChannelData(0);
+
+  let hash = 0;
+  let hash2 = 0;
+  for (let i = 3000; i < 5800; i += 2) {
+    const v = channel[i];
+    hash = (hash * 31 + Math.floor((v + 1) * 100000)) | 0;
+    hash2 = Math.imul(hash2 ^ Math.floor(v * 98765), 0x85ebca77);
   }
-};
-
-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;
-  let h1b;
-  let 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;
+  const final = (hash >>> 0) ^ (hash2 >>> 0);
+
+  if (debug) {
+    const wc = document.createElement('canvas');
+    wc.width = 500;
+    wc.height = 120;
+    wc.style.border = '1px solid #444';
+    wc.style.margin = '10px 0';
+    wc.title = 'Audio buffer snippet (4500–5000 samples)';
+
+    const ctx = wc.getContext('2d');
+    ctx.fillStyle = '#111';
+    ctx.fillRect(0, 0, wc.width, wc.height);
+
+    ctx.font = '14px monospace';
+    ctx.fillStyle = '#0f8';
+    ctx.textAlign = 'left';
+    ctx.fillText('AudioID', 10, 20);
+
+    ctx.strokeStyle = '#0f8';
+    ctx.lineWidth = 1.5;
+    ctx.beginPath();
+
+    const waveform = Array.from(channel.slice(4500, 5000));
+    const step = wc.width / waveform.length;
+
+    for (let i = 0; i < waveform.length; i++) {
+      const x = i * step;
+      const y = ((waveform[i] + 1) / 2) * wc.height;
+      if (i === 0) ctx.moveTo(x, y);
+      else ctx.lineTo(x, y);
+    }
+    ctx.stroke();
 
-    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);
+    document.body.appendChild(wc);
   }
 
-  const i = bytes - 1;
+  const result = murmurHash3(final.toString(16));
+  return result;
+};
 
-  k1 = 0;
+const getFonts = () => {
+  const baseFonts = ['monospace', 'serif', 'sans-serif'];
+  const testFonts = [
+    'Arial',
+    'Helvetica',
+    'Verdana',
+    'Trebuchet MS',
+    'Comic Sans MS',
+    'Georgia',
+    'Times New Roman',
+    'Courier New',
+    'Segoe UI',
+    'Roboto',
+    'Open Sans',
+    'Noto Sans',
+    'system-ui',
+    '-apple-system',
+    'BlinkMacSystemFont',
+  ];
+
+  const span = document.createElement('span');
+  span.style.fontSize = '72px';
+  span.style.position = 'absolute';
+  span.style.visibility = 'hidden';
+  span.style.whiteSpace = 'nowrap';
+  span.textContent = 'mmmmmmmmmwwwwwww';
+  document.body.appendChild(span);
+
+  const defaults = {};
+  for (const base of baseFonts) {
+    span.style.fontFamily = base;
+    defaults[base] = span.offsetWidth;
+  }
 
-  switch (remainder) {
-    case 3: {
-      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
-      break;
-    }
-    case 2: {
-      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
-      break;
+  const detected = [];
+  for (const font of testFonts) {
+    let found = false;
+    for (const base of baseFonts) {
+      span.style.fontFamily = `"${font}", ${base}`;
+      if (span.offsetWidth !== defaults[base]) {
+        detected.push(font);
+        found = true;
+        break;
+      }
     }
-    case 1: {
-      k1 ^= key.charCodeAt(i) & 0xff;
-      break;
+    if (!found) {
+      span.style.fontFamily = `"${font}"`;
+      if (span.offsetWidth !== defaults.monospace && span.offsetWidth !== defaults.serif) {
+        detected.push(font);
+      }
     }
   }
 
-  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;
+  document.body.removeChild(span);
+  const info = detected.length ? detected.sort().join(',') : null;
+  return info;
 };
 
-if (typeof window !== "undefined") {
+if (typeof window !== 'undefined') {
   window.getBrowserFingerprint = getBrowserFingerprint;
 }