@versini/ui-fingerprint 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Arno Versini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @versini/ui-fingerprint
+
+This package provides a simple way to fingerprint a user's browser and device.

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+type BrowserFP = { browser: string };
+
+type VideoCardFP = {
+	vendor: string;
+	vendorUnmasked: string;
+	renderer: string;
+	rendererUnmasked: string;
+	version: string;
+	shadingLanguageVersion: string;
+};
+
+type HardwareFP = {
+	hardware: {
+		videocard: VideoCardFP;
+		architecture: number;
+		deviceMemory: string;
+		jsHeapSizeLimit: number;
+	};
+};
+
+type CanvasFP = {
+	canvas: {
+		data: string;
+	};
+};
+
+type AudioFP = {
+	audio: {
+		sampleHash: string;
+		oscillator: string;
+		maxChannels: number;
+		channelCountMode: string;
+	};
+};
+
+type SystemFP = {
+	system: {
+		platform: string;
+		cookieEnabled: boolean;
+		productSub: string;
+		product: string;
+	};
+};
+
+type LocalesFP = {
+	locales: {
+		languages: string;
+		timezone: string;
+	};
+};
+
+type ScreenFP = {
+	screen: {
+		colorDepth: number;
+		pixelDepth: number;
+		isTouchScreen: boolean;
+		maxTouchPoints: number;
+		mediaMatches: string[];
+	};
+};
+
+type FontsFP = string[];
+
+type FingerprintData = [
+    AudioFP,
+    BrowserFP,
+    CanvasFP,
+    FontsFP,
+    HardwareFP,
+    LocalesFP,
+    ScreenFP,
+    SystemFP
+];
+declare const getFingerprintData: (debug: boolean) => Promise<FingerprintData>;
+declare const getFingerprintHash: (debug: boolean) => Promise<string>;
+
+export { getFingerprintData, getFingerprintHash };

package/dist/index.js

@@ -0,0 +1,361 @@
+/*!
+  @versini/ui-fingerprint v0.0.0
+  © 2024 gizmette.com
+*/
+try {
+  window.__VERSINI_UI_FINGERPRINT__ || (window.__VERSINI_UI_FINGERPRINT__ = {
+    version: "0.0.0",
+    buildTime: "07/18/2024 08:42 AM EDT",
+    homepage: "https://github.com/aversini/ui-components",
+    license: "MIT"
+  });
+} catch {
+}
+const D = (t) => Array.from(t).map((e) => e.toString(16).padStart(2, "0")).join(""), v = async (t) => {
+  if (t === "")
+    return "";
+  const e = new TextEncoder().encode(t), o = await crypto.subtle.digest("SHA-256", e);
+  return Array.from(new Uint8Array(o)).map((c) => c.toString(16).padStart(2, "0")).join("");
+};
+function S(t, n) {
+  return new Promise((e) => setTimeout(e, t, n));
+}
+async function T(t, n, e = 50) {
+  var a, c, d;
+  const o = document;
+  for (; !o.body; )
+    await S(e);
+  const r = o.createElement("iframe");
+  try {
+    for (await new Promise((m, y) => {
+      let g = !1;
+      const f = () => {
+        g = !0, m();
+      }, p = (s) => {
+        g = !0, y(s);
+      };
+      r.onload = f, r.onerror = p;
+      const { style: u } = r;
+      u.setProperty("display", "block", "important"), u.position = "absolute", u.top = "0", u.left = "0", u.visibility = "hidden", r.src = "about:blank", o.body.appendChild(r);
+      const i = () => {
+        var s, l;
+        g || (((l = (s = r.contentWindow) == null ? void 0 : s.document) == null ? void 0 : l.readyState) === "complete" ? f() : setTimeout(i, 10));
+      };
+      i();
+    }); !((c = (a = r.contentWindow) == null ? void 0 : a.document) != null && c.body); )
+      await S(e);
+    return await t(r, r.contentWindow);
+  } finally {
+    (d = r.parentNode) == null || d.removeChild(r);
+  }
+}
+const x = {
+  audio: {
+    sampleHash: "",
+    oscillator: "",
+    maxChannels: 0,
+    channelCountMode: ""
+  }
+}, H = async (t) => new Promise((n) => {
+  try {
+    const e = new window.OfflineAudioContext(1, 5e3, 44100), o = e.createBufferSource(), r = e.createOscillator();
+    r.frequency.value = 1e3;
+    const a = e.createDynamicsCompressor();
+    a.threshold.value = -50, a.knee.value = 40, a.ratio.value = 12, a.attack.value = 0, a.release.value = 0.2, r.connect(a), a.connect(e.destination), r.start(), e.startRendering(), e.oncomplete = (c) => {
+      const d = c.renderedBuffer.getChannelData(0);
+      r.disconnect(), a.disconnect(), n({
+        audio: {
+          sampleHash: D(d),
+          oscillator: r.type,
+          maxChannels: e.destination.maxChannelCount,
+          channelCountMode: o.channelCountMode
+        }
+      });
+    };
+  } catch (e) {
+    t && console.error("Error creating audio fingerprint:", e), n({
+      audio: {
+        sampleHash: "",
+        oscillator: "",
+        maxChannels: 0,
+        channelCountMode: ""
+      }
+    });
+  }
+}), E = { browser: "" }, P = async (t) => typeof navigator > "u" ? E : { browser: navigator.userAgent }, C = {
+  canvas: {
+    data: ""
+  }
+}, R = async (t) => {
+  try {
+    const o = Array.from(
+      { length: 3 },
+      () => _(300, 30)
+    ), r = N(o, 300, 30);
+    return {
+      canvas: {
+        data: (await v(r.data.toString())).toString()
+      }
+    };
+  } catch (o) {
+    return t && (console.error("Error creating canvas fingerprint"), console.info(o)), C;
+  }
+}, _ = (t, n) => {
+  const e = document.createElement("canvas"), o = e.getContext("2d");
+  if (!o)
+    return new ImageData(1, 1);
+  e.width = t, e.height = n;
+  const r = o.createLinearGradient(0, 0, e.width, e.height);
+  r.addColorStop(0, "red"), r.addColorStop(1 / 6, "orange"), r.addColorStop(2 / 6, "yellow"), r.addColorStop(3 / 6, "green"), r.addColorStop(4 / 6, "blue"), r.addColorStop(5 / 6, "indigo"), r.addColorStop(1, "violet"), o.fillStyle = r, o.fillRect(0, 0, e.width, e.height);
+  const a = "mmMwWLliI0O&1 - Les sanglots longs des violons de l'automne blessent mon coeur d'une langueur monotone";
+  return o.font = "26.321px Arial", o.fillStyle = "black", o.fillText(a, -5, 15), o.fillStyle = "rgba(0, 0, 255, 0.5)", o.fillText(a, -3.3, 17.7), o.beginPath(), o.moveTo(0, 0), o.lineTo(e.width * 2 / 7, e.height), o.strokeStyle = "white", o.lineWidth = 2, o.stroke(), o.getImageData(0, 0, e.width, e.height);
+}, F = (t) => {
+  if (t.length === 0)
+    return 0;
+  const n = {};
+  for (const o of t)
+    n[o] = (n[o] || 0) + 1;
+  let e = t[0];
+  for (const o in n)
+    n[o] > n[e] && (e = parseInt(o, 10));
+  return e;
+}, N = (t, n, e) => {
+  const o = [];
+  for (let c = 0; c < t[0].data.length; c++) {
+    const d = [];
+    for (let m = 0; m < t.length; m++)
+      d.push(t[m].data[c]);
+    o.push(F(d));
+  }
+  const r = o, a = new Uint8ClampedArray(r);
+  return new ImageData(a, n, e);
+}, G = [], L = "mmMwWLliI0O&1", k = "48px", h = ["monospace", "sans-serif", "serif"], w = [
+  "sans-serif-thin",
+  "ARNO PRO",
+  "Agency FB",
+  "Arabic Typesetting",
+  "Arial Unicode MS",
+  "AvantGarde Bk BT",
+  "BankGothic Md BT",
+  "Bitstream Vera Sans Mono",
+  "Calibri",
+  "Century",
+  "Century Gothic",
+  "Clarendon",
+  "EUROSTILE",
+  "Franklin Gothic",
+  "GOTHAM",
+  "Gill Sans",
+  "Helvetica Neue",
+  "Letter Gothic",
+  "Menlo",
+  "MS Outlook",
+  "MS Reference Specialty",
+  "MS UI Gothic",
+  "MT Extra",
+  "MYRIAD PRO",
+  "Marlett",
+  "Microsoft Uighur",
+  "Minion Pro",
+  "Monotype Corsiva",
+  "PMingLiU",
+  "Pristina",
+  "SCRIPTINA",
+  "SimHei",
+  "Small Fonts",
+  "Staccato222 BT",
+  "TRAJAN PRO",
+  "Univers CE 55 Medium",
+  "ZWAdobeF"
+], O = async (t) => T(async (n, { document: e }) => {
+  const o = e.body;
+  o.style.fontSize = k;
+  const r = e.createElement("div");
+  r.style.setProperty("visibility", "hidden", "important");
+  const a = {}, c = {}, d = (i) => {
+    const s = e.createElement("span"), { style: l } = s;
+    return l.position = "absolute", l.top = "0", l.left = "0", l.fontFamily = i, s.textContent = L, r.appendChild(s), s;
+  }, m = (i, s) => d(`'${i}',${s}`), y = () => h.map(d), g = () => {
+    const i = {};
+    for (const s of w)
+      i[s] = h.map(
+        (l) => m(s, l)
+      );
+    return i;
+  }, f = (i) => h.some(
+    (s, l) => i[l].offsetWidth !== a[s] || i[l].offsetHeight !== c[s]
+  ), p = y(), u = g();
+  o.appendChild(r);
+  for (let i = 0; i < h.length; i++)
+    a[h[i]] = p[i].offsetWidth, c[h[i]] = p[i].offsetHeight;
+  return w.filter((i) => f(u[i]));
+}), A = {
+  vendor: "",
+  vendorUnmasked: "",
+  renderer: "",
+  rendererUnmasked: "",
+  version: "",
+  shadingLanguageVersion: ""
+}, M = {
+  hardware: {
+    videocard: A,
+    architecture: 0,
+    deviceMemory: "undefined",
+    jsHeapSizeLimit: 0
+  }
+};
+function U() {
+  const t = document.createElement("canvas"), n = t.getContext("webgl") ?? t.getContext("experimental-webgl");
+  if (n && "getParameter" in n) {
+    const e = n.getExtension("WEBGL_debug_renderer_info");
+    return {
+      vendor: (n.getParameter(n.VENDOR) || "").toString(),
+      vendorUnmasked: e ? (n.getParameter(e.UNMASKED_VENDOR_WEBGL) || "").toString() : "",
+      renderer: (n.getParameter(n.RENDERER) || "").toString(),
+      rendererUnmasked: e ? (n.getParameter(e.UNMASKED_RENDERER_WEBGL) || "").toString() : "",
+      version: (n.getParameter(n.VERSION) || "").toString(),
+      shadingLanguageVersion: (n.getParameter(n.SHADING_LANGUAGE_VERSION) || "").toString()
+    };
+  }
+  return A;
+}
+function B() {
+  const t = new Float32Array(1), n = new Uint8Array(t.buffer);
+  return t[0] = 1 / 0, t[0] = t[0] - t[0], n[3];
+}
+const W = () => navigator.deviceMemory || 0, V = () => window.performance && window.performance.memory || {
+  jsHeapSizeLimit: 0
+}, z = async (t) => new Promise((n) => {
+  try {
+    const e = W(), o = V();
+    n({
+      hardware: {
+        videocard: U(),
+        architecture: B(),
+        deviceMemory: e.toString() || "undefined",
+        jsHeapSizeLimit: o.jsHeapSizeLimit || 0
+      }
+    });
+  } catch (e) {
+    t && (console.error("Error getting hardware data"), console.info(e)), n(M);
+  }
+}), j = {
+  locales: {
+    languages: "",
+    timezone: ""
+  }
+}, $ = async (t) => new Promise((n) => {
+  n({
+    locales: {
+      languages: navigator.language,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+    }
+  });
+}), b = {
+  screen: {
+    colorDepth: 0,
+    pixelDepth: 0,
+    isTouchScreen: !1,
+    maxTouchPoints: 0,
+    mediaMatches: []
+  }
+}, q = async (t) => new Promise((n) => {
+  try {
+    const e = window.screen, o = {
+      screen: {
+        colorDepth: e.colorDepth,
+        pixelDepth: e.pixelDepth,
+        isTouchScreen: navigator.maxTouchPoints > 0,
+        maxTouchPoints: navigator.maxTouchPoints,
+        mediaMatches: J()
+      }
+    };
+    n(o);
+  } catch (e) {
+    t && (console.error("Error creating screen fingerprint"), console.info(e)), n(b);
+  }
+});
+function J() {
+  const t = [], n = {
+    "prefers-contrast": [
+      "high",
+      "more",
+      "low",
+      "less",
+      "forced",
+      "no-preference"
+    ],
+    "any-hover": ["hover", "none"],
+    "any-pointer": ["none", "coarse", "fine"],
+    pointer: ["none", "coarse", "fine"],
+    hover: ["hover", "none"],
+    update: ["fast", "slow"],
+    "inverted-colors": ["inverted", "none"],
+    "prefers-reduced-motion": ["reduce", "no-preference"],
+    "prefers-reduced-transparency": ["reduce", "no-preference"],
+    scripting: ["none", "initial-only", "enabled"],
+    "forced-colors": ["active", "none"],
+    "color-gamut": ["srgb", "p3", "rec2020"]
+  };
+  return Object.keys(n).forEach((e) => {
+    n[e].forEach((o) => {
+      matchMedia(`(${e}: ${o})`).matches && t.push(`${e}: ${o}`);
+    });
+  }), t;
+}
+const K = async (t) => {
+  try {
+    return {
+      system: {
+        platform: navigator.platform,
+        cookieEnabled: navigator.cookieEnabled,
+        productSub: navigator.productSub,
+        product: navigator.product
+      }
+    };
+  } catch (n) {
+    return t && (console.error("Error getting system data"), console.info(n)), I;
+  }
+}, I = {
+  system: {
+    platform: "",
+    cookieEnabled: !1,
+    productSub: "",
+    product: ""
+  }
+}, Z = async (t) => {
+  try {
+    return Promise.all([
+      H(t),
+      P(),
+      R(t),
+      O(),
+      z(t),
+      $(),
+      q(t),
+      K(t)
+    ]);
+  } catch {
+    return [
+      x,
+      E,
+      C,
+      G,
+      M,
+      j,
+      b,
+      I
+    ];
+  }
+}, Q = async (t) => {
+  try {
+    const n = await Z(t);
+    return await v(JSON.stringify(n));
+  } catch (n) {
+    return t && (console.error("Error getting fingerprint hash"), console.info(n)), "";
+  }
+};
+export {
+  Z as getFingerprintData,
+  Q as getFingerprintHash
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+	"name": "@versini/ui-fingerprint",
+	"version": "0.0.0",
+	"license": "MIT",
+	"author": "Arno Versini",
+	"publishConfig": {
+		"access": "public"
+	},
+	"homepage": "https://github.com/aversini/ui-components",
+	"repository": {
+		"type": "git",
+		"url": "git@github.com:aversini/ui-components.git"
+	},
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build:check": "tsc",
+		"build:js": "vite build",
+		"build:types": "tsup",
+		"build": "npm-run-all --serial clean build:check build:js build:types",
+		"clean": "rimraf dist tmp",
+		"dev:js": "vite build --watch --mode development",
+		"dev:types": "tsup --watch src",
+		"dev": "npm-run-all clean --parallel dev:js dev:types",
+		"lint": "biome lint src",
+		"start": "static-server dist --port 5173",
+		"stats:pr": "bundlesize -c bundlesize.config.js -p \"$npm_package_version\" -o tmp/stats.json --silent",
+		"stats:release": "bundlesize -c bundlesize.config.js -p \"$npm_package_version\" -o stats/stats.json --silent",
+		"stats:report": "bundlesize -c bundlesize.config.js --type report -o tmp/pr-stats.md --silent",
+		"stats": "bundlesize -c bundlesize.config.js -p \"$npm_package_version\"",
+		"test:watch": "vitest",
+		"test": "vitest run"
+	},
+	"gitHead": "30d5e3f729226c417a7554eeb2dad57909d54e47"
+}