@ianmenethil/zp-devicefp 0.1.0 → 0.2.0

package/dist/cdn/zp.dfp.esm.js

@@ -22,6 +22,35 @@ function hasCanvas(env) {
   return Boolean(env.document?.createElement?.("canvas").getContext);
 }
 
+// src/signals/adblock.ts
+var adblockCollector = {
+  name: "adblock",
+  tier: "extended",
+  supportsSync: false,
+  async collect(context) {
+    const started = now(context.env);
+    const doc = context.env.document;
+    if (!doc || !hasDom(context.env)) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    return new Promise((resolve) => {
+      const bait = doc.createElement("div");
+      bait.innerHTML = "\xA0";
+      bait.className = "adsbox";
+      doc.body.appendChild(bait);
+      setTimeout(() => {
+        const adblockEnabled = bait.offsetHeight === 0;
+        doc.body.removeChild(bait);
+        resolve({
+          status: "ok",
+          durationMs: now(context.env) - started,
+          value: { adblockEnabled }
+        });
+      }, 100);
+    });
+  }
+};
+
 // src/signals/audio.ts
 function getOfflineAudioContext(env) {
   const g = env;
@@ -140,7 +169,9 @@ var EXTENDED_SIGNALS = [
   "paymentSupport",
   "referrerInfo",
   "navigationInfo",
-  "riskSignals"
+  "riskSignals",
+  "adblock",
+  "geolocation"
 ];
 var SYNC_SIGNALS = [
   "ua",
@@ -159,16 +190,76 @@ var SYNC_SIGNALS = [
 ];
 var DEFAULT_TIMEOUT_MS = 1500;
 var DEFAULT_FONT_LIST = [
+  "Andale Mono",
+  "American Typewriter",
+  "Apple Chancery",
   "Arial",
-  "Helvetica Neue",
-  "Times New Roman",
-  "Georgia",
+  "Arial Black",
+  "Arial Narrow",
+  "Arial Rounded MT Bold",
+  "Baskerville",
+  "Book Antiqua",
+  "Bookman Old Style",
+  "Bradley Hand ITC",
+  "Calibri",
+  "Cambria",
+  "Candara",
+  "Century",
+  "Century Gothic",
+  "Century Schoolbook",
+  "Chalkboard",
+  "Charcoal",
+  "Cochin",
+  "Comic Sans MS",
+  "Consolas",
+  "Constantia",
+  "Corbel",
+  "Courier",
   "Courier New",
+  "Franklin Gothic Medium",
+  "Futura",
+  "Garamond",
+  "Geneva",
+  "Georgia",
+  "Gill Sans",
+  "Gill Sans MT",
+  "Helvetica",
+  "Hoefler Text",
+  "Impact",
+  "Lucida Bright",
+  "Lucida Console",
+  "Lucida Grande",
+  "Lucida Sans",
+  "MS Gothic",
+  "MS PGothic",
+  "MS Serif",
+  "MS UI Gothic",
+  "Meiryo",
+  "Meiryo UI",
+  "Monaco",
+  "Monotype Corsiva",
+  "New York",
+  "Optima",
+  "Palatino",
+  "Palatino Linotype",
+  "Papyrus",
+  "Plantagenet Cherokee",
+  "Segoe Print",
+  "Segoe Script",
+  "Segoe UI",
+  "Segoe UI Light",
+  "Segoe UI Semibold",
+  "Segoe UI Symbol",
+  "Symbol",
+  "Tahoma",
+  "Times",
+  "Times New Roman",
   "Trebuchet MS",
   "Verdana",
-  "Tahoma",
-  "Impact",
-  "Comic Sans MS"
+  "Wingdings",
+  "Wingdings 2",
+  "Wingdings 3",
+  "Zapfino"
 ];
 var DEFAULT_PERMISSION_NAMES = ["geolocation", "notifications", "camera", "microphone"];
 var DEFAULT_UA_HINTS = [
@@ -296,6 +387,44 @@ var frameInfoCollector = {
   }
 };
 
+// src/signals/geolocation.ts
+var geolocationCollector = {
+  name: "geolocation",
+  tier: "extended",
+  supportsSync: false,
+  async collect(context) {
+    const started = now(context.env);
+    const nav = context.env.navigator;
+    if (!nav?.geolocation) {
+      return { status: "unsupported", durationMs: now(context.env) - started };
+    }
+    return new Promise((resolve) => {
+      nav.geolocation.getCurrentPosition(
+        (pos) => {
+          resolve({
+            status: "ok",
+            durationMs: now(context.env) - started,
+            value: {
+              latitude: pos.coords.latitude,
+              longitude: pos.coords.longitude,
+              accuracy: pos.coords.accuracy
+            }
+          });
+        },
+        (err) => {
+          resolve({
+            // PERMISSION_DENIED = 1
+            status: err.code === 1 ? "blocked" : "error",
+            durationMs: now(context.env) - started,
+            error: err.message
+          });
+        },
+        { timeout: context.options.timeoutMs, maximumAge: 6e4 }
+      );
+    });
+  }
+};
+
 // src/signals/hardware.ts
 var hardwareCollector = {
   name: "hardware",
@@ -311,6 +440,17 @@ var hardwareCollector = {
     if (!nav) {
       return { status: "unsupported", durationMs: now(context.env) - started };
     }
+    const doc = context.env.document;
+    const g = context.env.global;
+    let touchEventCreationSuccessful = false;
+    try {
+      if (doc) {
+        doc.createEvent("TouchEvent");
+        touchEventCreationSuccessful = true;
+      }
+    } catch {
+    }
+    const onTouchStartAvailable = g != null && "ontouchstart" in g;
     return {
       status: "ok",
       durationMs: now(context.env) - started,
@@ -318,7 +458,9 @@ var hardwareCollector = {
         hardwareConcurrency: nav.hardwareConcurrency,
         deviceMemory: nav.deviceMemory,
         platform: nav.platform,
-        maxTouchPoints: nav.maxTouchPoints
+        maxTouchPoints: nav.maxTouchPoints,
+        touchEventCreationSuccessful,
+        onTouchStartAvailable
       }
     };
   }
@@ -340,28 +482,36 @@ var localeCollector = {
     if (!nav || !intl) {
       return { status: "unsupported", durationMs: now(context.env) - started };
     }
-    const formatter = new intl.DateTimeFormat();
-    const options = formatter.resolvedOptions();
-    const numberFormatter = new intl.NumberFormat(nav.language);
-    const relativeTimeFormatter = typeof intl.RelativeTimeFormat === "function" ? new intl.RelativeTimeFormat(nav.language, { numeric: "auto" }) : void 0;
-    const sampleDate = new Date(Date.UTC(2024, 0, 2, 3, 4, 5));
-    return {
-      status: "ok",
-      durationMs: now(context.env) - started,
-      value: {
-        language: nav.language,
-        languages: nav.languages,
-        locale: options.locale,
-        calendar: options.calendar,
-        numberingSystem: options.numberingSystem,
-        timeZone: options.timeZone,
-        hourCycle: options.hourCycle,
-        timeZoneOffsetMinutes: sampleDate.getTimezoneOffset(),
-        formattedNumber: numberFormatter.format(123456.789),
-        formattedDate: formatter.format(sampleDate),
-        formattedRelativeDay: relativeTimeFormatter?.format(-1, "day")
-      }
-    };
+    try {
+      const formatter = new intl.DateTimeFormat();
+      const options = formatter.resolvedOptions();
+      const numberFormatter = new intl.NumberFormat(nav.language);
+      const relativeTimeFormatter = typeof intl.RelativeTimeFormat === "function" ? new intl.RelativeTimeFormat(nav.language, { numeric: "auto" }) : void 0;
+      const sampleDate = new Date(Date.UTC(2024, 0, 2, 3, 4, 5));
+      return {
+        status: "ok",
+        durationMs: now(context.env) - started,
+        value: {
+          language: nav.language,
+          languages: nav.languages,
+          locale: options.locale,
+          calendar: options.calendar,
+          numberingSystem: options.numberingSystem,
+          timeZone: options.timeZone,
+          hourCycle: options.hourCycle,
+          timeZoneOffsetMinutes: sampleDate.getTimezoneOffset(),
+          formattedNumber: numberFormatter.format(123456.789),
+          formattedDate: formatter.format(sampleDate),
+          formattedRelativeDay: relativeTimeFormatter?.format(-1, "day")
+        }
+      };
+    } catch (error) {
+      return {
+        status: "error",
+        durationMs: now(context.env) - started,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
   }
 };
 
@@ -672,6 +822,7 @@ var screenCollector = {
     if (!screen2) {
       return { status: "unsupported", durationMs: now(context.env) - started };
     }
+    const orientation = screen2.orientation;
     return {
       status: "ok",
       durationMs: now(context.env) - started,
@@ -682,10 +833,24 @@ var screenCollector = {
         availHeight: screen2.availHeight,
         colorDepth: screen2.colorDepth,
         pixelDepth: screen2.pixelDepth,
-        orientationType: screen2.orientation.type,
-        orientationAngle: screen2.orientation.angle,
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- orientation is optional at runtime despite the Screen intersection
+        ...orientation ? { orientationType: orientation.type, orientationAngle: orientation.angle } : {},
         maxTouchPoints: nav?.maxTouchPoints ?? 0,
+        resolution: `${String(screen2.width)}x${String(screen2.height)}`,
+        ratio: screen2.height > 0 ? Math.round(screen2.width / screen2.height * 1e10) / 1e10 : 0,
         devicePixelRatio: typeof runtime.devicePixelRatio === "number" ? runtime.devicePixelRatio : void 0,
+        // Fingerprint2 / Cardinal Commerce has_lied_resolution: availWidth never exceeds width on a real device
+        fakedResolution: screen2.availWidth > screen2.width || screen2.availHeight > screen2.height,
+        // Cardinal Commerce CCAScreenSize — outerWidth/outerHeight bucket code
+        ccaScreenSize: (() => {
+          const w = typeof runtime.outerWidth === "number" ? runtime.outerWidth : 0;
+          const h = typeof runtime.outerHeight === "number" ? runtime.outerHeight : 0;
+          if (w < 390) return "01";
+          if (w < 500) return "02";
+          if (w < 600) return "03";
+          if (h < 600) return "04";
+          return "02";
+        })(),
         colorGamutP3: getMediaPreference(runtime, "(color-gamut: p3)"),
         prefersReducedMotion: getMediaPreference(runtime, "(prefers-reduced-motion: reduce)"),
         prefersContrastMore: getMediaPreference(runtime, "(prefers-contrast: more)"),
@@ -752,6 +917,16 @@ var uaCollector = {
     if (!nav) {
       return { status: "unsupported", durationMs: now(context.env) - started };
     }
+    let plugins = [];
+    try {
+      plugins = Array.from(nav.plugins).map((p) => {
+        const mimes = Array.from({ length: p.length }, (_, i) => p.item(i)).filter((m) => m !== null).map((m) => `${m.type}~${m.suffixes}`).join(",");
+        return `${p.name}::${p.description}::${mimes}`;
+      });
+    } catch {
+    }
+    const rawDnt = nav.doNotTrack ?? context.env.global.doNotTrack ?? null;
+    const doNotTrack = rawDnt === "1" ? "enabled" : rawDnt === "0" ? "disabled" : rawDnt ?? "not_set";
     return {
       status: "ok",
       durationMs: now(context.env) - started,
@@ -763,7 +938,9 @@ var uaCollector = {
         webdriver: nav.webdriver,
         maxTouchPoints: nav.maxTouchPoints,
         cookieEnabled: nav.cookieEnabled,
-        vendorSub: nav.vendorSub
+        vendorSub: nav.vendorSub,
+        doNotTrack,
+        plugins
       }
     };
   }
@@ -920,7 +1097,9 @@ var signalCollectors = [
   paymentSupportCollector,
   referrerInfoCollector,
   navigationInfoCollector,
-  riskSignalsCollector
+  riskSignalsCollector,
+  adblockCollector,
+  geolocationCollector
 ];
 var collectorMap = new Map(signalCollectors.map((collector) => [collector.name, collector]));
 
@@ -934,6 +1113,13 @@ function asString(value) {
 function asNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+function canonicalizeLegacyPlatform(legacyPlatform) {
+  if (legacyPlatform.startsWith("win")) return "windows";
+  if (legacyPlatform.startsWith("mac")) return "macos";
+  if (/cros|chrome/.test(legacyPlatform)) return "chrome os";
+  if (/linux|x11/.test(legacyPlatform)) return "linux";
+  return legacyPlatform;
+}
 function analyseSignals(signals) {
   const anomalies = [];
   const automationHints = [];
@@ -955,8 +1141,12 @@ function analyseSignals(signals) {
   if (userAgent.includes("headless")) {
     automationHints.push("headless_user_agent");
   }
-  if (platform && hintPlatform && !platform.includes(hintPlatform) && !hintPlatform.includes(platform)) {
-    anomalies.push("ua_platform_mismatch");
+  if (platform && hintPlatform) {
+    const canonicalLegacy = canonicalizeLegacyPlatform(platform);
+    const linuxFamilyOk = canonicalLegacy === "linux" && (hintPlatform === "linux" || hintPlatform === "android" || hintPlatform === "chrome os");
+    if (!linuxFamilyOk && canonicalLegacy !== hintPlatform) {
+      anomalies.push("ua_platform_mismatch");
+    }
   }
   if (userAgent.includes("iphone") && maxTouchPoints === 0) {
     anomalies.push("touch_claim_without_touch_points");
@@ -976,10 +1166,16 @@ function analyseSignals(signals) {
   const anomalyPenalty = anomalies.length * 0.12;
   const automationPenalty = automationHints.length * 0.18;
   const score = Math.max(0, Math.min(1, Number((1 - anomalyPenalty - automationPenalty).toFixed(3))));
+  const fakedOS = anomalies.includes("ua_platform_mismatch");
+  const riskVal = asRecord(signals.riskSignals?.value);
+  const headlessHints = Array.isArray(riskVal?.headlessHints) ? riskVal.headlessHints : [];
+  const fakedBrowser = headlessHints.includes("missing-chrome-object");
   return {
     score,
     anomalies,
-    automationHints
+    automationHints,
+    fakedOS,
+    fakedBrowser
   };
 }
 
@@ -1049,7 +1245,9 @@ var SIGNAL_WEIGHTS = {
   paymentSupport: 0.2,
   referrerInfo: 0.3,
   navigationInfo: 0.4,
-  riskSignals: 0.7
+  riskSignals: 0.7,
+  adblock: 0.3,
+  geolocation: 0.5
 };
 function computeConfidence(signals, antiSpoof) {
   let earned = 0;
@@ -1271,28 +1469,9 @@ function resolveSignalSet(options, mode = "async") {
   return included.filter((signal) => !excluded.has(signal));
 }
 
-// src/core/upload.ts
-async function uploadFingerprint(env, result, options) {
-  const fetchImpl = options.endpoint && env.fetch;
-  if (!fetchImpl) {
-    throw new Error("Fetch is not available in this runtime.");
-  }
-  return fetchImpl(options.endpoint, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      ...options.headers
-    },
-    body: JSON.stringify({
-      fingerprint: result,
-      ...options.bodyExtras
-    })
-  });
-}
-
 // src/version.ts
-var LIBRARY_VERSION = "0.1.0";
-var SCHEMA_VERSION = 1;
+var LIBRARY_VERSION = true ? "0.2.0" : "0.0.0-dev";
+var SCHEMA_VERSION = 2;
 
 // src/client.ts
 function toTimedOutResult(durationMs) {
@@ -1302,6 +1481,18 @@ function toTimedOutResult(durationMs) {
     error: "Signal collection timed out."
   };
 }
+function toErrorResult(durationMs, error) {
+  return {
+    status: "error",
+    durationMs,
+    error: error instanceof Error ? error.message : String(error)
+  };
+}
+function debugLog(resolved, message) {
+  if (resolved.debug) {
+    console.debug(`[zp-devicefp] ${message}`);
+  }
+}
 async function runCollectorWithTimeout(collector, env, options, warn) {
   const started = env.performance?.now?.() ?? Date.now();
   if (options.abortSignal?.aborted) {
@@ -1313,31 +1504,36 @@ async function runCollectorWithTimeout(collector, env, options, warn) {
   }
   let clearTimeoutHandle = () => {
   };
+  let removeAbortListener = () => {
+  };
   const timeoutPromise = new Promise((resolve) => {
     const timeout = setTimeout(() => {
       resolve(toTimedOutResult((env.performance?.now?.() ?? Date.now()) - started));
     }, options.timeoutMs);
     clearTimeoutHandle = () => clearTimeout(timeout);
-    options.abortSignal?.addEventListener(
-      "abort",
-      () => {
-        clearTimeoutHandle();
-        resolve({
-          status: "error",
-          durationMs: (env.performance?.now?.() ?? Date.now()) - started,
-          error: "Collection aborted."
-        });
-      },
-      { once: true }
-    );
-  });
-  const resultPromise = collector.collect({
-    env,
-    options,
-    warn
+    const onAbort = () => {
+      clearTimeoutHandle();
+      resolve({
+        status: "error",
+        durationMs: (env.performance?.now?.() ?? Date.now()) - started,
+        error: "Collection aborted."
+      });
+    };
+    options.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    removeAbortListener = () => options.abortSignal?.removeEventListener("abort", onAbort);
   });
+  const resultPromise = (async () => {
+    try {
+      return await collector.collect({ env, options, warn });
+    } catch (error) {
+      const result = toErrorResult((env.performance?.now?.() ?? Date.now()) - started, error);
+      warn(`Signal "${collector.name}" threw: ${result.error ?? "unknown error"}`, collector.name);
+      return result;
+    }
+  })();
   return Promise.race([resultPromise, timeoutPromise]).finally(() => {
     clearTimeoutHandle();
+    removeAbortListener();
   });
 }
 function buildResult(signals, warnings, requestedSignals, elapsedMs) {
@@ -1399,6 +1595,7 @@ async function createFingerprintClient(options) {
           }
           const result = await runCollectorWithTimeout(collector, env, resolved, warn);
           collected[name] = result;
+          debugLog(resolved, `${name}: ${result.status} (${String(result.durationMs)}ms)`);
           completed += 1;
           emitter.emit("progress", {
             completed,
@@ -1429,21 +1626,34 @@ async function createFingerprintClient(options) {
           warn(`Signal "${name}" is not available in synchronous mode.`, name);
           continue;
         }
-        collected[name] = collector.collectSync({
-          env,
-          options: resolved,
-          warn
-        });
+        const signalStarted = env.performance?.now?.() ?? Date.now();
+        let result;
+        try {
+          result = collector.collectSync({
+            env,
+            options: resolved,
+            warn
+          });
+        } catch (error) {
+          result = toErrorResult((env.performance?.now?.() ?? Date.now()) - signalStarted, error);
+          warn(`Signal "${name}" threw: ${result.error ?? "unknown error"}`, name);
+        }
+        collected[name] = result;
+        debugLog(resolved, `${name}: ${result.status} (${String(result.durationMs)}ms)`);
       }
       return buildResult(collected, warnings, signalNames, (env.performance?.now?.() ?? Date.now()) - started);
-    },
-    upload(result, uploadOptions) {
-      return uploadFingerprint(getBrowserEnv(), result, uploadOptions);
     }
   };
 }
 export {
+  CORE_SIGNALS,
+  DEFAULT_FONT_LIST,
+  DEFAULT_PERMISSION_NAMES,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_UA_HINTS,
+  EXTENDED_SIGNALS,
   LIBRARY_VERSION,
   SCHEMA_VERSION,
+  SYNC_SIGNALS,
   createFingerprintClient
 };