@cloudglides/veil 1.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,1000 @@
+// src/entropy/userAgent.ts
+async function getUserAgentEntropy() {
+  const ua = navigator.userAgent;
+  let entropy = 0;
+  const freq = {};
+  for (const char of ua) {
+    freq[char] = (freq[char] || 0) + 1;
+  }
+  for (const count of Object.values(freq)) {
+    const p = count / ua.length;
+    entropy -= p * Math.log2(p);
+  }
+  return `${ua}|H(UA)=${entropy.toFixed(4)}`;
+}
+
+// src/entropy/canvas.ts
+async function getCanvasEntropy() {
+  try {
+    const canvas = document.createElement("canvas");
+    if (canvas.getContext === void 0) return "canvas:unavailable";
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return "canvas:unavailable";
+    const support = ctx.fillText ? "fillText" : "none";
+    const textMetrics = ctx.measureText ? "measureText" : "none";
+    const imageDataSupport = ctx.getImageData ? "getImageData" : "none";
+    return `support:${support}|metrics:${textMetrics}|imageData:${imageDataSupport}`;
+  } catch {
+    return "canvas:unavailable";
+  }
+}
+
+// src/entropy/webgl.ts
+async function getWebGLEntropy() {
+  const canvas = document.createElement("canvas");
+  const gl = canvas.getContext("webgl") || canvas.getContext("webgl2");
+  if (!gl) return "webgl:unavailable";
+  const vendor = gl.getParameter(gl.VENDOR) || "unknown";
+  const renderer = gl.getParameter(gl.RENDERER) || "unknown";
+  const version = gl.getParameter(gl.VERSION) || "unknown";
+  return `vendor:${vendor}|renderer:${renderer}|version:${version}`;
+}
+
+// src/entropy/fonts.ts
+async function getFontsEntropy() {
+  const fonts = ["Arial", "Courier", "Georgia", "Verdana"];
+  return fonts.join(",");
+}
+
+// src/entropy/storage.ts
+async function getStorageEntropy() {
+  let ls = false;
+  let idb = false;
+  try {
+    const test = "__storage_test__";
+    window.localStorage.setItem(test, test);
+    window.localStorage.removeItem(test);
+    ls = true;
+  } catch {
+    ls = false;
+  }
+  try {
+    const request = window.indexedDB.open("__idb_test__");
+    idb = true;
+  } catch {
+    idb = false;
+  }
+  return `localStorage:${ls}|indexedDB:${idb}`;
+}
+
+// src/entropy/screen.ts
+async function getScreenEntropy() {
+  const w = screen.width;
+  const h = screen.height;
+  const d = screen.colorDepth;
+  const pixelCount = w * h;
+  const totalColors = Math.pow(2, d);
+  const colorSpace = Math.log2(totalColors);
+  const screenSurface = Math.log2(pixelCount);
+  return `${w}x${h}|colors:${d}|log\u2082(A)=${screenSurface.toFixed(2)}|log\u2082(C)=${colorSpace.toFixed(2)}`;
+}
+
+// src/wasm-loader.ts
+var wasmInitialized = false;
+var wasmModule = null;
+async function loadWasmModule() {
+  if (wasmModule) return wasmModule;
+  const paths = [
+    () => import("./veil_core.js"),
+    () => import("../veil-core/pkg/veil_core.js")
+  ];
+  for (const pathFn of paths) {
+    try {
+      wasmModule = await pathFn();
+      return wasmModule;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error("Failed to load WASM module from any location");
+}
+async function initializeWasm() {
+  if (wasmInitialized) return;
+  try {
+    const wasm = await loadWasmModule();
+    if (typeof wasm.default === "function") {
+      await wasm.default();
+    }
+    wasmInitialized = true;
+  } catch (error) {
+    console.error("Failed to initialize WASM module:", error);
+    throw error;
+  }
+}
+async function getWasmModule() {
+  if (!wasmInitialized) {
+    await initializeWasm();
+  }
+  return wasmModule;
+}
+
+// src/seeded-rng.ts
+function seededRng(seed, count) {
+  let hash = 5381;
+  for (let i = 0; i < seed.length; i++) {
+    hash = (hash << 5) + hash ^ seed.charCodeAt(i);
+  }
+  const samples = [];
+  for (let i = 0; i < count; i++) {
+    hash = hash * 1103515245 + 12345 & 2147483647;
+    samples.push(hash / 2147483647);
+  }
+  return samples;
+}
+
+// src/entropy/distribution.ts
+async function getDistributionEntropy(seed) {
+  const samples = seededRng(seed, 1e3);
+  const wasm = await getWasmModule();
+  const ksStatistic = wasm.ks_test(new Float64Array(samples));
+  return `ks:${ksStatistic.toFixed(6)}`;
+}
+
+// src/entropy/complexity.ts
+async function getComplexityEntropy() {
+  const ua = navigator.userAgent;
+  const bytes = new Uint8Array(ua.length);
+  for (let i = 0; i < ua.length; i++) {
+    bytes[i] = ua.charCodeAt(i) % 256;
+  }
+  const wasm = await getWasmModule();
+  const complexity = wasm.lz_complexity(bytes);
+  return `lz:${complexity}`;
+}
+
+// src/entropy/spectral.ts
+async function getSpectralEntropy(seed) {
+  const samples = seededRng(seed, 128);
+  const wasm = await getWasmModule();
+  const entropy = wasm.spectral(new Float64Array(samples));
+  return `spectral:${entropy.toFixed(6)}`;
+}
+
+// src/entropy/approximate.ts
+async function getApproximateEntropy(seed) {
+  const samples = seededRng(seed, 256);
+  const wasm = await getWasmModule();
+  const apen = wasm.approx_entropy(new Float64Array(samples), 2);
+  return `apen:${apen.toFixed(6)}`;
+}
+
+// src/entropy/os.ts
+async function getOSEntropy() {
+  const platform = navigator.platform || "unknown";
+  const oscpu = navigator.oscpu || "unknown";
+  const combined = platform + oscpu;
+  const uniqueChars = new Set(combined).size;
+  const totalChars = combined.length;
+  const charDiversity = uniqueChars / totalChars;
+  const surprisal = -Math.log2(1 / uniqueChars);
+  return `OS:${platform}|CPU:${oscpu}|\u03B4=${charDiversity.toFixed(4)}|I=${surprisal.toFixed(2)}`;
+}
+
+// src/entropy/language.ts
+async function getLanguageEntropy() {
+  const language = navigator.language;
+  const languages = navigator.languages;
+  const langCount = languages.length;
+  const langDiversity = Math.log2(langCount + 1);
+  const primaryEntropy = -Array.from(language).reduce((h, c) => {
+    const p = 1 / language.length;
+    return h + p * Math.log2(p);
+  }, 0);
+  const combined = languages.join("|");
+  return `primary:${language}|langs:${langCount}|H(L)=${primaryEntropy.toFixed(3)}|D=${langDiversity.toFixed(3)}`;
+}
+
+// src/entropy/timezone.ts
+async function getTimezoneEntropy() {
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const offset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+  const tzEntropy = Math.log2(Math.abs(offset) + 1);
+  const offsetBits = offset.toString().length * 8;
+  const tzUniqueness = Math.log2(24 * 60 / Math.max(Math.abs(offset), 1));
+  return `TZ:${tz}|offset:${offset}|H(TZ)=${tzEntropy.toFixed(3)}|U=${tzUniqueness.toFixed(3)}`;
+}
+
+// src/entropy/hardware.ts
+async function getHardwareEntropy() {
+  const cores = navigator.hardwareConcurrency || 1;
+  const memory = navigator.deviceMemory || 4;
+  const computePower = Math.log2(cores) * Math.log2(memory);
+  const memoryBits = Math.ceil(Math.log2(memory * 1024));
+  const coreEntropy = cores > 0 ? Math.log2(cores) : 0;
+  return `cores:${cores}|mem:${memory}GB|P(compute)=${computePower.toFixed(3)}|H(cores)=${coreEntropy.toFixed(3)}`;
+}
+
+// src/entropy/plugins.ts
+async function getPluginsEntropy() {
+  const plugins = Array.from(navigator.plugins).map((p) => p.name);
+  const pluginStr = plugins.join("|");
+  const pluginCount = plugins.length;
+  const pluginEntropy = pluginCount > 0 ? -plugins.reduce((h, p) => {
+    const p_freq = 1 / pluginCount;
+    return h + p_freq * Math.log2(p_freq);
+  }, 0) : 0;
+  return `count:${pluginCount}|H(plugins)=${pluginEntropy.toFixed(3)}|plugins:${pluginStr || "none"}`;
+}
+
+// src/entropy/browser.ts
+async function getBrowserEntropy() {
+  const ua = navigator.userAgent;
+  const vendor = navigator.vendor;
+  const cookieEnabled = navigator.cookieEnabled;
+  const doNotTrack = navigator.doNotTrack;
+  return `ua:${ua}|vendor:${vendor}|cookies:${cookieEnabled}|dnt:${doNotTrack}`;
+}
+
+// src/entropy/osVersion.ts
+async function getOSVersionEntropy() {
+  const ua = navigator.userAgent;
+  const match = ua.match(/Windows NT|Mac OS|Linux|Android|iOS/i);
+  const os = match ? match[0] : "unknown";
+  return os;
+}
+
+// src/entropy/screenInfo.ts
+async function getScreenInfoEntropy() {
+  const width = screen.width;
+  const height = screen.height;
+  const depth = screen.colorDepth;
+  const pixelDepth = screen.pixelDepth;
+  const devicePixelRatio = window.devicePixelRatio;
+  return `${width}x${height}|depth:${depth}|px:${pixelDepth}|ratio:${devicePixelRatio}`;
+}
+
+// src/entropy/adblock.ts
+async function detectAdblock() {
+  try {
+    const response = await fetch("https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js", {
+      method: "HEAD",
+      mode: "no-cors"
+    });
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function getAdblockEntropy() {
+  const adblockPresent = await detectAdblock();
+  return `adblock:${adblockPresent}`;
+}
+
+// src/entropy/webFeatures.ts
+async function getWebFeaturesEntropy() {
+  const features = {
+    localStorage: !!window.localStorage,
+    sessionStorage: !!window.sessionStorage,
+    indexedDB: !!window.indexedDB,
+    openDatabase: !!window.openDatabase,
+    serviceWorker: !!navigator.serviceWorker,
+    webWorker: typeof Worker !== "undefined",
+    geolocation: !!navigator.geolocation,
+    notifications: !!window.Notification
+  };
+  const enabled = Object.values(features).filter(Boolean).length;
+  const total = Object.keys(features).length;
+  const supportRatio = enabled / total;
+  const supportEntropy = Math.log2(total) * (1 - Math.abs(supportRatio - 0.5) * 2);
+  return `enabled:${enabled}/${total}|\u03C3=${supportRatio.toFixed(3)}|H(features)=${supportEntropy.toFixed(3)}|${Object.entries(features).map(([k, v]) => `${k}:${v}`).join("|")}`;
+}
+
+// src/entropy/preferences.ts
+async function getPreferencesEntropy() {
+  const darkMode = window.matchMedia("(prefers-color-scheme: dark)").matches;
+  const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  const highContrast = window.matchMedia("(prefers-contrast: more)").matches;
+  const prefCount = [darkMode, reducedMotion, highContrast].filter(Boolean).length;
+  const maxCombinations = Math.pow(2, 3);
+  const preferenceBits = Math.log2(maxCombinations);
+  const actualEntropy = prefCount > 0 ? -(prefCount / 3 * Math.log2(prefCount / 3) + (3 - prefCount) / 3 * Math.log2((3 - prefCount) / 3)) : 0;
+  return `dark:${darkMode}|motion:${reducedMotion}|contrast:${highContrast}|enabled:${prefCount}|H(pref)=${actualEntropy.toFixed(3)}`;
+}
+
+// src/entropy/permissions.ts
+async function getPermissionsEntropy() {
+  const perms = [];
+  const checks = ["geolocation", "notifications", "camera", "microphone"];
+  for (const perm of checks) {
+    try {
+      const result = await navigator.permissions.query({ name: perm });
+      perms.push(`${perm}:${result.state}`);
+    } catch {
+      perms.push(`${perm}:unknown`);
+    }
+  }
+  return perms.join("|");
+}
+
+// src/entropy/statistical.ts
+async function getStatisticalEntropy() {
+  const ua = navigator.userAgent;
+  const freq = {};
+  for (const char of ua) {
+    freq[char] = (freq[char] || 0) + 1;
+  }
+  const values = Object.values(freq);
+  const mean = values.reduce((a, b) => a + b) / values.length;
+  const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / values.length;
+  const stdDev = Math.sqrt(variance);
+  return `mean:${mean.toFixed(4)}|var:${variance.toFixed(4)}|std:${stdDev.toFixed(4)}`;
+}
+
+// src/entropy/probabilistic.ts
+async function getProbabilisticEntropy() {
+  const metrics = [];
+  const screen_values = [screen.width, screen.height, screen.colorDepth];
+  const hw_values = [navigator.hardwareConcurrency || 1, navigator.deviceMemory || 4];
+  const all_values = [...screen_values, ...hw_values];
+  const mean = all_values.reduce((a, b) => a + b) / all_values.length;
+  const sorted = [...all_values].sort((a, b) => a - b);
+  const median = sorted[Math.floor(sorted.length / 2)];
+  const q1 = sorted[Math.floor(sorted.length / 4)];
+  const q3 = sorted[Math.floor(sorted.length * 3 / 4)];
+  const iqr = q3 - q1;
+  metrics.push(`mean:${mean.toFixed(2)}`);
+  metrics.push(`median:${median.toFixed(2)}`);
+  metrics.push(`iqr:${iqr.toFixed(2)}`);
+  return metrics.join("|");
+}
+
+// src/probability.ts
+function calculateMean(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function hellingerDistance(p, q) {
+  if (p.length !== q.length) return 0;
+  const sum = p.reduce((s, pi, i) => s + Math.pow(Math.sqrt(pi) - Math.sqrt(q[i]), 2), 0);
+  return Math.sqrt(sum / 2);
+}
+
+// src/scoring.ts
+function calculateEntropy(data) {
+  const freq = {};
+  for (const char of data) {
+    freq[char] = (freq[char] || 0) + 1;
+  }
+  let entropy = 0;
+  for (const count of Object.values(freq)) {
+    const p = count / data.length;
+    if (p > 0) {
+      entropy -= p * Math.log2(p);
+    }
+  }
+  return entropy;
+}
+function calculateLikelihood(sources) {
+  const entropies = sources.map((s) => s.entropy).filter((e) => !isNaN(e) && e > 0);
+  if (entropies.length === 0) return 0;
+  const mean = entropies.reduce((a, b) => a + b) / entropies.length;
+  const variance = entropies.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / entropies.length;
+  const stdDev = Math.sqrt(variance);
+  return mean * (1 + stdDev / mean);
+}
+function calculateConfidence(sources, likelihood) {
+  const maxPossibleEntropy = Math.log2(256);
+  const sourceCount = sources.length;
+  const normalizedLikelihood = Math.min(likelihood / maxPossibleEntropy, 1);
+  const sourceWeighting = Math.log2(sourceCount + 1) / Math.log2(32);
+  return normalizedLikelihood * sourceWeighting;
+}
+function calculateUniqueness(sources, likelihood, confidence) {
+  const distinctSources = new Set(sources.map((s) => s.value)).size;
+  const totalSources = sources.length;
+  const diversity = distinctSources / totalSources;
+  const informationContent = likelihood * Math.log2(totalSources);
+  const uniquenessScore = informationContent * confidence * diversity;
+  return Math.min(uniquenessScore / 100, 0.999);
+}
+function scoreFingerprint(sources) {
+  const likelihood = calculateLikelihood(sources);
+  const confidence = calculateConfidence(sources, likelihood);
+  const uniqueness = calculateUniqueness(sources, likelihood, confidence);
+  const entropies = sources.map((s) => s.entropy).filter((e) => !isNaN(e) && e > 0);
+  const uniformDist = new Array(entropies.length).fill(1 / entropies.length);
+  const normalizedEntropies = entropies.length > 0 ? entropies.map((e) => e / calculateMean(entropies)) : [];
+  const divergence = normalizedEntropies.length > 0 ? hellingerDistance(normalizedEntropies, uniformDist.slice(0, normalizedEntropies.length)) : 0;
+  return {
+    likelihood,
+    confidence,
+    uniqueness,
+    divergence,
+    sources
+  };
+}
+
+// src/tamper.ts
+function analyzeTamper(sources) {
+  const anomalies = [];
+  let riskScore = 0;
+  if (sources.length === 0) {
+    anomalies.push({
+      id: "no_sources",
+      category: "missing_sources",
+      severity: "critical",
+      message: "No entropy sources collected",
+      explanation: "The fingerprinting process failed to collect any entropy data. This may indicate a sandbox environment or blocked APIs.",
+      riskContribution: 0.9
+    });
+    return { tampering_risk: 0.9, anomalies };
+  }
+  const entropies = sources.map((s) => s.entropy);
+  const values = sources.map((s) => s.value);
+  const mean = entropies.reduce((a, b) => a + b, 0) / entropies.length;
+  const variance = entropies.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / entropies.length;
+  const stdDev = Math.sqrt(variance);
+  if (stdDev < 0.05) {
+    const contribution = 0.25;
+    anomalies.push({
+      id: "uniform_entropy",
+      category: "entropy_distribution",
+      severity: "high",
+      message: "All entropy sources have suspiciously similar values",
+      explanation: `Standard deviation of entropy across sources is ${stdDev.toFixed(4)}, indicating very low variance. Real fingerprints should show diverse entropy patterns.`,
+      riskContribution: contribution
+    });
+    riskScore += contribution;
+  }
+  const uniqueValues = new Set(values);
+  if (uniqueValues.size < sources.length * 0.5) {
+    const contribution = 0.2;
+    const duplicateCount = sources.length - uniqueValues.size;
+    anomalies.push({
+      id: "duplicate_values",
+      category: "data_quality",
+      severity: "medium",
+      message: `${duplicateCount} duplicate values detected across entropy sources`,
+      explanation: "High duplication suggests cached or placeholder values. Expected diversity is not present.",
+      riskContribution: contribution
+    });
+    riskScore += contribution;
+  }
+  const emptyOrShort = values.filter((v) => !v || v.length < 2).length;
+  if (emptyOrShort > sources.length * 0.3) {
+    const contribution = 0.15;
+    anomalies.push({
+      id: "empty_sources",
+      category: "data_quality",
+      severity: "high",
+      message: `${emptyOrShort} sources are empty or too short`,
+      explanation: "Several entropy sources produced minimal data. This may indicate blocked APIs or restricted environment.",
+      riskContribution: contribution
+    });
+    riskScore += contribution;
+  }
+  const sourceNames = sources.map((s) => s.name);
+  const criticalSources = ["userAgent", "canvas", "webgl", "fonts"];
+  const missingCritical = criticalSources.filter(
+    (c) => !sourceNames.includes(c)
+  );
+  if (missingCritical.length > 0) {
+    const contribution = 0.2 * (missingCritical.length / criticalSources.length);
+    anomalies.push({
+      id: "missing_critical",
+      category: "missing_sources",
+      severity: missingCritical.length === criticalSources.length ? "critical" : "high",
+      message: `Missing critical sources: ${missingCritical.join(", ")}`,
+      explanation: "These sources are fundamental to browser fingerprinting. Their absence reduces fingerprint reliability and suggests API restrictions or tampering.",
+      riskContribution: contribution
+    });
+    riskScore += contribution;
+  }
+  const canvasSource = sources.find((s) => s.name === "canvas");
+  const webglSource = sources.find((s) => s.name === "webgl");
+  if (canvasSource && webglSource && canvasSource.value === webglSource.value && canvasSource.entropy < 0.5) {
+    const contribution = 0.15;
+    anomalies.push({
+      id: "canvas_webgl_match",
+      category: "cross_source_inconsistency",
+      severity: "high",
+      message: "Canvas and WebGL fingerprints are identical",
+      explanation: "Canvas and WebGL rendering engines should produce different fingerprints. Identical values indicate either spoofing or a very unusual environment.",
+      riskContribution: contribution
+    });
+    riskScore += contribution;
+  }
+  const screenSource = sources.find((s) => s.name === "screen");
+  if (screenSource && screenSource.value.length < 3) {
+    const contribution = 0.1;
+    anomalies.push({
+      id: "screen_entropy_low",
+      category: "data_quality",
+      severity: "low",
+      message: "Screen entropy data is suspiciously minimal",
+      explanation: "Screen information should provide resolution and color depth data. Very short values suggest incomplete data collection.",
+      riskContribution: contribution
+    });
+    riskScore += contribution;
+  }
+  const maxEntropy = Math.max(...entropies);
+  const minEntropy = Math.min(...entropies);
+  if (maxEntropy > 0 && minEntropy / maxEntropy < 0.1) {
+    const contribution = 0.15;
+    anomalies.push({
+      id: "entropy_variance",
+      category: "entropy_distribution",
+      severity: "medium",
+      message: `Extreme variance in entropy: min/max ratio is ${(minEntropy / maxEntropy).toFixed(3)}`,
+      explanation: "Some sources have drastically different entropy levels, suggesting uneven data collection or selective API blocking.",
+      riskContribution: contribution
+    });
+    riskScore += contribution;
+  }
+  const zeroEntropyCount = entropies.filter((e) => e === 0).length;
+  if (zeroEntropyCount > sources.length * 0.4) {
+    const contribution = 0.1;
+    anomalies.push({
+      id: "zero_entropy",
+      category: "data_quality",
+      severity: "medium",
+      message: `${zeroEntropyCount} sources have zero entropy`,
+      explanation: "Zero entropy typically means identical or highly repetitive data. Many sources with zero entropy suggests a restricted or heavily spoofed environment.",
+      riskContribution: contribution
+    });
+    riskScore += contribution;
+  }
+  const suspiciousPatterns = sources.filter(
+    (s) => /^(null|undefined|test|fake|mock)$/i.test(s.value)
+  );
+  if (suspiciousPatterns.length > 0) {
+    const contribution = 0.2;
+    anomalies.push({
+      id: "placeholder_values",
+      category: "value_spoofing",
+      severity: "critical",
+      message: `Placeholder values detected: ${suspiciousPatterns.map((s) => s.name).join(", ")}`,
+      explanation: "Sources contain obvious placeholder/test values (null, undefined, fake, mock). This is a strong indicator of intentional spoofing.",
+      riskContribution: contribution
+    });
+    riskScore += contribution;
+  }
+  const finalRisk = Math.min(riskScore, 1);
+  return {
+    tampering_risk: finalRisk,
+    anomalies
+  };
+}
+
+// src/stability.ts
+var STABILITY_THRESHOLDS = {
+  stable: 0.85,
+  semi_volatile: 0.5
+};
+function getSourceStability(sources) {
+  const stabilityMap = {
+    userAgent: 0.95,
+    os: 0.95,
+    timezone: 0.98,
+    hardware: 0.9,
+    language: 0.92,
+    screen: 0.88,
+    osVersion: 0.85,
+    browser: 0.93,
+    canvas: 0.82,
+    webgl: 0.8,
+    fonts: 0.7,
+    plugins: 0.75,
+    storage: 0.5,
+    adblock: 0.65,
+    screenInfo: 0.85,
+    webFeatures: 0.8,
+    permissions: 0.6,
+    preferences: 0.55,
+    statistical: 0.7,
+    probabilistic: 0.65,
+    distribution: 0.75,
+    complexity: 0.8,
+    spectral: 0.75,
+    approximate: 0.75,
+    connection: 0.4,
+    battery: 0.3,
+    audio: 0.85,
+    performance: 0.2
+  };
+  return sources.map((source) => {
+    const stability = stabilityMap[source.name] ?? 0.5;
+    const volatility = 1 - stability;
+    let category;
+    if (stability >= STABILITY_THRESHOLDS.stable) {
+      category = "stable";
+    } else if (stability >= STABILITY_THRESHOLDS.semi_volatile) {
+      category = "semi_volatile";
+    } else {
+      category = "volatile";
+    }
+    return {
+      source: source.name,
+      stability,
+      volatility,
+      category
+    };
+  });
+}
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16);
+}
+function detectEntropyAnomalies(sources) {
+  const warnings = [];
+  const sourceMap = new Map(sources.map((s) => [s.name, s]));
+  for (const source of sources) {
+    const value = source.value.toLowerCase();
+    if (!value || value.length === 0) {
+      warnings.push({
+        source: source.name,
+        severity: "error",
+        message: "Empty entropy value",
+        reason: "Source returned no data, likely blocked or unavailable API"
+      });
+    }
+    if (/^(null|undefined|nan|n\/a|-1|0x0|unknown|not available|blocked)$/i.test(value)) {
+      warnings.push({
+        source: source.name,
+        severity: "error",
+        message: "Suspicious placeholder value detected",
+        reason: "Value appears to be a default/placeholder, not real entropy"
+      });
+    }
+    if (source.entropy === 0 && value.length > 2) {
+      warnings.push({
+        source: source.name,
+        severity: "warning",
+        message: "Zero entropy despite non-empty value",
+        reason: "Value is highly repetitive or contains minimal information"
+      });
+    }
+    if (source.entropy > 8 && value.length < 5) {
+      warnings.push({
+        source: source.name,
+        severity: "warning",
+        message: "Suspiciously high entropy in very short value",
+        reason: "Short strings cannot contain this much entropy mathematically"
+      });
+    }
+    if (source.name === "canvas" || source.name === "webgl") {
+      if (value.length < 10) {
+        warnings.push({
+          source: source.name,
+          severity: "warning",
+          message: "Graphics fingerprint is unusually short",
+          reason: "Canvas/WebGL fingerprints should contain detailed rendering info"
+        });
+      }
+    }
+    if (source.name === "fonts") {
+      if (value === "0" || value === "[]" || value.split(",").length < 3) {
+        warnings.push({
+          source: source.name,
+          severity: "warning",
+          message: "Suspiciously few fonts detected",
+          reason: "System should report 50+ fonts; low count suggests API blocking"
+        });
+      }
+    }
+    if (source.name === "screen") {
+      const match = value.match(/(\d+)x(\d+)/);
+      if (match) {
+        const [w, h] = [parseInt(match[1]), parseInt(match[2])];
+        if (w < 320 || h < 240 || w > 7680 || h > 4320) {
+          warnings.push({
+            source: source.name,
+            severity: "warning",
+            message: "Unusual screen resolution detected",
+            reason: `Resolution ${w}x${h} is outside normal range`
+          });
+        }
+      }
+    }
+    if (source.name === "userAgent") {
+      const isCommonUA = /chrome|firefox|safari|edge|mozilla/i.test(value);
+      if (!isCommonUA && value.length > 10) {
+        warnings.push({
+          source: source.name,
+          severity: "info",
+          message: "Unusual user agent detected",
+          reason: "User agent does not match known browsers"
+        });
+      }
+    }
+  }
+  if (sources.length > 0) {
+    const avgEntropy = sources.reduce((a, b) => a + b.entropy, 0) / sources.length;
+    if (avgEntropy < 0.3) {
+      warnings.push({
+        source: "_system",
+        severity: "warning",
+        message: "Overall entropy is very low",
+        reason: "Average entropy across sources is below 0.3, fingerprint may be unreliable"
+      });
+    }
+  }
+  return warnings;
+}
+function extractDeviceSignature(sources) {
+  const osSource = sources.find((s) => s.name === "os");
+  const hardwareSource = sources.find((s) => s.name === "hardware");
+  const screenSource = sources.find((s) => s.name === "screen");
+  const uaSource = sources.find((s) => s.name === "userAgent");
+  const os = osSource?.value.split("|")[0] ?? "unknown";
+  const hardwareStr = hardwareSource?.value ?? "0";
+  const cores = parseInt(hardwareStr.match(/\d+/)?.[0] ?? "0");
+  const resolution = screenSource?.value ?? "0x0";
+  const uaHash = uaSource ? hashString(uaSource.value) : "0";
+  return {
+    os,
+    hardware_cores: cores,
+    screen_resolution: resolution,
+    user_agent_hash: uaHash
+  };
+}
+function extractPreferencesOffset(sources) {
+  const langSource = sources.find((s) => s.name === "language");
+  const tzSource = sources.find((s) => s.name === "timezone");
+  const prefSource = sources.find((s) => s.name === "preferences");
+  let theme = null;
+  let dark_mode = null;
+  let accessibility = null;
+  if (prefSource && prefSource.value) {
+    const parts = prefSource.value.split("|");
+    if (parts.length > 0) dark_mode = parts[0] === "true";
+    if (parts.length > 1) theme = parts[1];
+    if (parts.length > 2) accessibility = parts[2];
+  }
+  return {
+    language: langSource ? langSource.value.split("|")[0] : null,
+    timezone: tzSource ? tzSource.value.split("|")[0] : null,
+    theme,
+    dark_mode,
+    font_size: null,
+    accessibility
+  };
+}
+function generateDeviceIdentity(sources) {
+  const signature = extractDeviceSignature(sources);
+  const signatureStr = `${signature.os}|${signature.hardware_cores}|${signature.screen_resolution}|${signature.user_agent_hash}`;
+  const coreHash = hashString(signatureStr);
+  const preferences = extractPreferencesOffset(sources);
+  const prefsStr = `${preferences.language}|${preferences.timezone}|${preferences.theme}|${preferences.dark_mode}|${preferences.accessibility}`;
+  const prefsHash = hashString(prefsStr);
+  const qualityScore = sources.filter((s) => s.entropy > 0.5).length / Math.max(sources.length, 1);
+  return {
+    core_hash: coreHash,
+    device_signature: signature,
+    entropy_quality: qualityScore,
+    preferences_offset: preferences,
+    preferences_hash: prefsHash
+  };
+}
+function assessFingerprint(sources) {
+  const stability = getSourceStability(sources);
+  const entropyWarnings = detectEntropyAnomalies(sources);
+  const warnings = [];
+  let usable = true;
+  let confidence = 1;
+  const stableCount = stability.filter((s) => s.category === "stable").length;
+  const volatileCount = stability.filter((s) => s.category === "volatile").length;
+  if (stableCount < 5) {
+    warnings.push(
+      `Only ${stableCount} stable sources available, fingerprint may be unreliable`
+    );
+    confidence -= 0.2;
+  }
+  if (volatileCount > sources.length * 0.5) {
+    warnings.push("Fingerprint heavily dependent on volatile sources");
+    confidence -= 0.15;
+  }
+  const zeroEntropyCount = sources.filter((s) => s.entropy === 0).length;
+  if (zeroEntropyCount > sources.length * 0.3) {
+    warnings.push(`${zeroEntropyCount} sources have zero entropy`);
+    confidence -= 0.25;
+    if (zeroEntropyCount > sources.length * 0.6) {
+      usable = false;
+    }
+  }
+  const errorWarnings = entropyWarnings.filter((w) => w.severity === "error").length;
+  if (errorWarnings > sources.length * 0.2) {
+    confidence -= 0.2;
+    if (errorWarnings > sources.length * 0.4) {
+      usable = false;
+    }
+  }
+  return {
+    usable,
+    confidence: Math.max(0, confidence),
+    warnings,
+    entropy_warnings: entropyWarnings
+  };
+}
+
+// src/index.ts
+function levenshteinDistance(s1, s2) {
+  const len1 = s1.length;
+  const len2 = s2.length;
+  const matrix = Array(len1 + 1).fill(null).map(() => Array(len2 + 1).fill(0));
+  for (let i = 0; i <= len1; i++) matrix[i][0] = i;
+  for (let j = 0; j <= len2; j++) matrix[0][j] = j;
+  for (let i = 1; i <= len1; i++) {
+    for (let j = 1; j <= len2; j++) {
+      const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(
+        matrix[i - 1][j] + 1,
+        matrix[i][j - 1] + 1,
+        matrix[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return matrix[len1][len2];
+}
+function similarityScore(s1, s2) {
+  const distance = levenshteinDistance(s1, s2);
+  const maxLen = Math.max(s1.length, s2.length);
+  return maxLen === 0 ? 1 : 1 - distance / maxLen;
+}
+async function getFingerprint(options) {
+  await initializeWasm();
+  const opts = {
+    entropy: {},
+    hash: "sha256",
+    ...options
+  };
+  const sources = [];
+  if (opts.entropy.userAgent !== false) {
+    const value = await getUserAgentEntropy();
+    sources.push({ name: "userAgent", value, entropy: calculateEntropy(value) });
+  }
+  if (opts.entropy.canvas !== false) {
+    const value = await getCanvasEntropy();
+    sources.push({ name: "canvas", value, entropy: calculateEntropy(value) });
+  }
+  if (opts.entropy.webgl !== false) {
+    const value = await getWebGLEntropy();
+    sources.push({ name: "webgl", value, entropy: calculateEntropy(value) });
+  }
+  if (opts.entropy.fonts !== false) {
+    const value = await getFontsEntropy();
+    sources.push({ name: "fonts", value, entropy: calculateEntropy(value) });
+  }
+  if (opts.entropy.storage !== false) {
+    const value = await getStorageEntropy();
+    sources.push({ name: "storage", value, entropy: calculateEntropy(value) });
+  }
+  if (opts.entropy.screen !== false) {
+    const value = await getScreenEntropy();
+    sources.push({ name: "screen", value, entropy: calculateEntropy(value) });
+  }
+  const baseSeed = sources.map((s) => s.value).join("|");
+  sources.push({ name: "distribution", value: await getDistributionEntropy(baseSeed), entropy: 0 });
+  sources.push({ name: "complexity", value: await getComplexityEntropy(), entropy: 0 });
+  sources.push({ name: "spectral", value: await getSpectralEntropy(baseSeed), entropy: 0 });
+  sources.push({ name: "approximate", value: await getApproximateEntropy(baseSeed), entropy: 0 });
+  sources.push({ name: "os", value: await getOSEntropy(), entropy: 0 });
+  sources.push({ name: "language", value: await getLanguageEntropy(), entropy: 0 });
+  sources.push({ name: "timezone", value: await getTimezoneEntropy(), entropy: 0 });
+  sources.push({ name: "hardware", value: await getHardwareEntropy(), entropy: 0 });
+  sources.push({ name: "plugins", value: await getPluginsEntropy(), entropy: 0 });
+  sources.push({ name: "browser", value: await getBrowserEntropy(), entropy: 0 });
+  sources.push({ name: "osVersion", value: await getOSVersionEntropy(), entropy: 0 });
+  sources.push({ name: "screenInfo", value: await getScreenInfoEntropy(), entropy: 0 });
+  sources.push({ name: "adblock", value: await getAdblockEntropy(), entropy: 0 });
+  sources.push({ name: "webFeatures", value: await getWebFeaturesEntropy(), entropy: 0 });
+  sources.push({ name: "preferences", value: await getPreferencesEntropy(), entropy: 0 });
+  sources.push({ name: "permissions", value: await getPermissionsEntropy(), entropy: 0 });
+  sources.push({ name: "statistical", value: await getStatisticalEntropy(), entropy: 0 });
+  sources.push({ name: "probabilistic", value: await getProbabilisticEntropy(), entropy: 0 });
+  for (const source of sources) {
+    if (source.entropy === 0) {
+      source.entropy = calculateEntropy(source.value);
+    }
+  }
+  const score = scoreFingerprint(sources);
+  const tamper = analyzeTamper(sources);
+  const stability = getSourceStability(sources);
+  const assessment = assessFingerprint(sources);
+  const deviceIdentity = generateDeviceIdentity(sources);
+  const data = sources.map((s) => s.value);
+  const combined = data.join("|");
+  const coreWeight = "core:" + deviceIdentity.core_hash;
+  const prefsWeight = "prefs:" + deviceIdentity.preferences_hash;
+  const weightedInput = `${coreWeight}|${prefsWeight}|${combined}`;
+  const algorithm = opts.hash === "sha512" ? "SHA-512" : "SHA-256";
+  const hash = await crypto.subtle.digest(
+    algorithm,
+    new TextEncoder().encode(weightedInput)
+  );
+  let fingerprint = Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  if (opts.detailed) {
+    const os = await getOSVersionEntropy();
+    const lang = await getLanguageEntropy();
+    const tz = await getTimezoneEntropy();
+    const hw = await getHardwareEntropy();
+    const sr = await getScreenInfoEntropy();
+    const ua = await getUserAgentEntropy();
+    const browser = await getBrowserEntropy();
+    const sourceMetrics = sources.map((s) => {
+      const stab = stability.find((st) => st.source === s.name);
+      return {
+        source: s.name,
+        value: s.value,
+        entropy: s.entropy,
+        confidence: score.likelihood > 0 ? Math.min(s.entropy / score.likelihood, 1) : 0,
+        stability: stab?.stability
+      };
+    });
+    const avgStability = stability.length > 0 ? stability.reduce((a, b) => a + b.stability, 0) / stability.length : 0;
+    const response = {
+      hash: fingerprint,
+      uniqueness: score.uniqueness,
+      confidence: score.confidence,
+      stability_score: avgStability,
+      usable: assessment.usable,
+      warnings: assessment.warnings.length > 0 ? assessment.warnings : void 0,
+      entropy_warnings: assessment.entropy_warnings.length > 0 ? assessment.entropy_warnings : void 0,
+      tampering_risk: tamper.tampering_risk,
+      anomalies: tamper.anomalies,
+      device_identity: deviceIdentity,
+      sources: sourceMetrics,
+      system: {
+        os,
+        language: lang.split("|")[0],
+        timezone: tz.split("|")[0],
+        hardware: {
+          cores: navigator.hardwareConcurrency || 0,
+          memory: navigator.deviceMemory || 0
+        }
+      },
+      display: {
+        resolution: `${screen.width}x${screen.height}`,
+        colorDepth: screen.colorDepth,
+        devicePixelRatio: window.devicePixelRatio
+      },
+      browser: {
+        userAgent: navigator.userAgent,
+        vendor: navigator.vendor,
+        cookieEnabled: navigator.cookieEnabled
+      }
+    };
+    return response;
+  }
+  return fingerprint;
+}
+async function compareFingerpints(fp1, fp2) {
+  const hash1 = typeof fp1 === "string" ? fp1 : fp1.hash;
+  const hash2 = typeof fp2 === "string" ? fp2 : fp2.hash;
+  const sim = similarityScore(hash1, hash2);
+  const match = sim > 0.95;
+  return { similarity: sim, match };
+}
+async function matchProbability(storedFingerprints, currentFingerprint) {
+  const currentHash = typeof currentFingerprint === "string" ? currentFingerprint : currentFingerprint.hash;
+  let bestMatch = 0;
+  for (const stored of storedFingerprints) {
+    const storedHash = typeof stored === "string" ? stored : stored.hash;
+    const sim = similarityScore(currentHash, storedHash);
+    if (sim > bestMatch) {
+      bestMatch = sim;
+    }
+  }
+  const confidence = Math.min(bestMatch * 1.2, 1);
+  return { bestMatch, confidence };
+}
+export {
+  compareFingerpints,
+  getFingerprint,
+  matchProbability
+};