devicer.js 1.0.13 → 1.2.0

package/README.md

@@ -1,21 +1,30 @@
-# FP-Devicer
-## Developed by Gateway Corporate Solutions LLC
-
-FP-Devicer is a digital fingerprinting middleware library designed for ease of use and near-universal compatibility with servers.
-
-Importing and using the library to compare fingerprints between users is as simple as collecting some user data and running the calculateConfidence function.
-```javascript
-import { FPUserDataSet as UserData, calculateConfidence } from "devicer.js";
-
-const user1: UserData = {
-  // Collected data goes here
-}
-
-const user2: UserData = {
-  // Collected data goes here
-}
-
-const confidence = calculateConfidence(user1, user2);
-```
-
+# FP-Devicer
+## Developed by Gateway Corporate Solutions LLC
+
+FP-Devicer is a digital fingerprinting middleware library designed for ease of use and near-universal compatibility with servers.
+
+Importing and using the library to compare fingerprints between users is as simple as collecting some user data and running the calculateConfidence function.
+```javascript
+import { calculateConfidence, createConfidenceCalculator, registerPlugin } from "devicer.js";
+
+// 1. Simple Method (Using defaults)
+const score = calculateConfidence(fpData1, fpData2);
+
+// 2. Advanced Method (Custom weights & comparitors)
+registerPlugin("userAgent", {
+  weight: 25,
+  comparator: (a, b) => levenshteinSimilarity(String(a || "").toLowerCase(), String(b || "").toLowerCase())
+});
+
+const advancedCalculator = createConfidenceCalculator({
+  weights: {
+    platform: 20,
+    fonts: 20,
+    screen: 15
+  }
+})
+
+const advancedScore = advancedCalculator.calculateConfidence(fpData1, fpData2);
+```
+
 The resulting confidence will range between 0 and 100, with 100 providing the highest confidence of the users being identical.

package/dist/libs/comparitors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.levenshteinSimilarity = levenshteinSimilarity;
+function levenshteinSimilarity(a, b) {
+    if (a === b)
+        return 1;
+    if (!a || !b)
+        return 0;
+    const maxLen = Math.max(a.length, b.length);
+    let distance = Math.abs(a.length - b.length);
+    const minLen = Math.min(a.length, b.length);
+    for (let i = 0; i < minLen; i++) {
+        if (a[i] !== b[i])
+            distance++;
+    }
+    return Math.max(0, 1 - distance / maxLen);
+}

package/dist/libs/confidence.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateConfidence = void 0;
+exports.createConfidenceCalculator = createConfidenceCalculator;
+const tlsh_1 = require("./tlsh");
+const registry_1 = require("./registry");
+const DEFAULT_WEIGHTS = {
+    userAgent: 20,
+    platform: 15,
+    timezone: 10,
+    language: 10,
+    languages: 10,
+    cookieEnabled: 5,
+    doNotTrack: 5,
+    hardwareConcurrency: 5,
+    deviceMemory: 5,
+    product: 5,
+    productSub: 5,
+    vendor: 5,
+    vendorSub: 5,
+    appName: 5,
+    appVersion: 5,
+    appCodeName: 5,
+    appMinorVersion: 5,
+    buildID: 5,
+    plugins: 10,
+    mimeTypes: 10,
+    screen: 10,
+    fonts: 15
+};
+function createConfidenceCalculator(userOptions = {}) {
+    var _a;
+    const { weights: localWeights = {}, comparators: localComparators = {}, defaultWeight: localDefaultWeight = 5, tlshWeight = 0.30, maxDepth = 5, useGlobalRegistry = true, } = userOptions;
+    // Merge global registry (if enabled) → local always wins
+    const global = useGlobalRegistry ? (0, registry_1.getGlobalRegistry)() : { comparators: {}, weights: {}, defaultWeight: 5 };
+    const finalDefaultWeight = (_a = localDefaultWeight !== null && localDefaultWeight !== void 0 ? localDefaultWeight : global.defaultWeight) !== null && _a !== void 0 ? _a : 5;
+    const mergedWeights = Object.assign(Object.assign(Object.assign({}, global.weights), DEFAULT_WEIGHTS), localWeights);
+    const mergedComparators = Object.assign(Object.assign({}, global.comparators), localComparators);
+    const defaultComparator = (a, b) => Number(a === b);
+    const getComparator = (path) => { var _a; return (_a = mergedComparators[path]) !== null && _a !== void 0 ? _a : defaultComparator; };
+    const getWeight = (path) => { var _a; return (_a = mergedWeights[path]) !== null && _a !== void 0 ? _a : finalDefaultWeight; };
+    function compareRecursive(data1, data2, path = "", depth = 0) {
+        if (depth > maxDepth)
+            return { totalWeight: 0, matchedWeight: 0 };
+        if (data1 === undefined || data2 === undefined)
+            return { totalWeight: 0, matchedWeight: 0 };
+        // Leaf / primitive value
+        if (typeof data1 !== "object" || data1 === null || typeof data2 !== "object" || data2 === null) {
+            const comparator = getComparator(path);
+            const similarity = Math.max(0, Math.min(1, comparator(data1, data2, path)));
+            const weight = getWeight(path);
+            return { totalWeight: weight, matchedWeight: weight * similarity };
+        }
+        // Array
+        if (Array.isArray(data1) && Array.isArray(data2)) {
+            let total = 0;
+            let matched = 0;
+            const len = Math.min(data1.length, data2.length);
+            for (let i = 0; i < len; i++) {
+                const res = compareRecursive(data1[i], data2[i], `${path}[${i}]`, depth + 1);
+                total += res.totalWeight;
+                matched += res.matchedWeight;
+            }
+            return { totalWeight: total, matchedWeight: matched };
+        }
+        // Object
+        let totalWeight = 0;
+        let matchedWeight = 0;
+        const keys = new Set([...Object.keys(data1 || {}), ...Object.keys(data2 || {})]);
+        for (const key of keys) {
+            const newPath = path ? `${path}.${key}` : key;
+            const res = compareRecursive(data1 === null || data1 === void 0 ? void 0 : data1[key], data2 === null || data2 === void 0 ? void 0 : data2[key], newPath, depth + 1);
+            totalWeight += res.totalWeight;
+            matchedWeight += res.matchedWeight;
+        }
+        return { totalWeight, matchedWeight };
+    }
+    return {
+        calculateConfidence(data1, data2) {
+            try {
+                const { totalWeight, matchedWeight } = compareRecursive(data1, data2);
+                const structuralScore = totalWeight > 0 ? matchedWeight / totalWeight : 0;
+                // TLSH fuzzy component (kept exactly as before)
+                let tlshScore = 1;
+                if (tlshWeight > 0) {
+                    const hash1 = (0, tlsh_1.getHash)(JSON.stringify(data1));
+                    const hash2 = (0, tlsh_1.getHash)(JSON.stringify(data2));
+                    const diff = (0, tlsh_1.compareHashes)(hash1, hash2);
+                    tlshScore = Math.max(0, (100 - diff) / 100);
+                }
+                const finalScore = structuralScore * (1 - tlshWeight) + tlshScore * tlshWeight;
+                return Math.round(Math.max(0, Math.min(100, finalScore * 100)));
+            }
+            catch (error) {
+                console.error("Error calculating confidence:", error);
+                return 0;
+            }
+        },
+    };
+}
+exports.calculateConfidence = createConfidenceCalculator().calculateConfidence;

package/dist/libs/registry.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerComparator = registerComparator;
+exports.registerWeight = registerWeight;
+exports.registerPlugin = registerPlugin;
+exports.setDefaultWeight = setDefaultWeight;
+exports.unregisterComparator = unregisterComparator;
+exports.unregisterWeight = unregisterWeight;
+exports.clearRegistry = clearRegistry;
+exports.getGlobalRegistry = getGlobalRegistry;
+let registry = {
+    comparators: {},
+    weights: {},
+    defaultWeight: 5,
+};
+/** Register a custom similarity comparator for a field or nested path */
+function registerComparator(path, comparator) {
+    if (typeof comparator !== "function") {
+        throw new Error("Comparator must be a function returning a 0–1 similarity score");
+    }
+    registry.comparators[path] = comparator;
+}
+/** Register (or override) the weight for a field or nested path */
+function registerWeight(path, weight) {
+    if (typeof weight !== "number" || weight < 0) {
+        throw new Error("Weight must be a non-negative number");
+    }
+    registry.weights[path] = weight;
+}
+/** Convenience: register weight + comparator in one call (most common pattern) */
+function registerPlugin(path, config) {
+    if (config.weight !== undefined)
+        registerWeight(path, config.weight);
+    if (config.comparator !== undefined)
+        registerComparator(path, config.comparator);
+}
+/** Change the fallback weight for any unregistered field */
+function setDefaultWeight(weight) {
+    registry.defaultWeight = Math.max(0, weight);
+}
+/** Remove a registered comparator */
+function unregisterComparator(path) {
+    return delete registry.comparators[path];
+}
+/** Remove a registered weight */
+function unregisterWeight(path) {
+    return delete registry.weights[path];
+}
+/** Reset everything (perfect for tests) */
+function clearRegistry() {
+    registry = { comparators: {}, weights: {}, defaultWeight: 5 };
+}
+// Internal only – used by createConfidenceCalculator
+function getGlobalRegistry() {
+    return Object.assign(Object.assign({}, registry), { comparators: Object.assign({}, registry.comparators), weights: Object.assign({}, registry.weights) });
+}

package/{src → dist}/libs/tlsh.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareHashes = exports.getHash = void 0;
+exports.getHash = getHash;
+exports.compareHashes = compareHashes;
 const tlsh_1 = __importDefault(require("tlsh"));
 const digest_hash_builder_js_1 = __importDefault(require("tlsh/lib/digests/digest-hash-builder.js"));
 function getHash(data) {
@@ -14,10 +15,8 @@ function getHash(data) {
     // Return the hash as a string
     return tlshHash;
 }
-exports.getHash = getHash;
 function compareHashes(hash1, hash2) {
     const digest1 = (0, digest_hash_builder_js_1.default)().withHash(hash1).build();
     const digest2 = (0, digest_hash_builder_js_1.default)().withHash(hash2).build();
     return digest1.calculateDifference(digest2, true);
 }
-exports.compareHashes = compareHashes;

package/dist/main.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearRegistry = exports.setDefaultWeight = exports.unregisterWeight = exports.unregisterComparator = exports.registerPlugin = exports.registerWeight = exports.registerComparator = exports.createConfidenceCalculator = exports.calculateConfidence = void 0;
+const confidence_1 = require("./libs/confidence");
+Object.defineProperty(exports, "calculateConfidence", { enumerable: true, get: function () { return confidence_1.calculateConfidence; } });
+Object.defineProperty(exports, "createConfidenceCalculator", { enumerable: true, get: function () { return confidence_1.createConfidenceCalculator; } });
+const registry_1 = require("./libs/registry");
+Object.defineProperty(exports, "registerComparator", { enumerable: true, get: function () { return registry_1.registerComparator; } });
+Object.defineProperty(exports, "registerWeight", { enumerable: true, get: function () { return registry_1.registerWeight; } });
+Object.defineProperty(exports, "registerPlugin", { enumerable: true, get: function () { return registry_1.registerPlugin; } });
+Object.defineProperty(exports, "unregisterComparator", { enumerable: true, get: function () { return registry_1.unregisterComparator; } });
+Object.defineProperty(exports, "unregisterWeight", { enumerable: true, get: function () { return registry_1.unregisterWeight; } });
+Object.defineProperty(exports, "setDefaultWeight", { enumerable: true, get: function () { return registry_1.setDefaultWeight; } });
+Object.defineProperty(exports, "clearRegistry", { enumerable: true, get: function () { return registry_1.clearRegistry; } });

package/license.txt

@@ -1,27 +1,27 @@
-# DON'T BE A DICK PUBLIC LICENSE
-
-> Version 1.1, December 2016
-
-> Copyright (C) 2025 Gateway Corporate Solutions LLC
-
-Everyone is permitted to copy and distribute verbatim or modified
-copies of this license document.
-
-> DON'T BE A DICK PUBLIC LICENSE
-> TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-1. Do whatever you like with the original work, just don't be a dick.
-
-   Being a dick includes - but is not limited to - the following instances:
-
- 1a. Outright copyright infringement - Don't just copy this and change the name.
- 1b. Selling the unmodified original with no work done what-so-ever, that's REALLY being a dick.
- 1c. Modifying the original work to contain hidden harmful content. That would make you a PROPER dick.
-
-2. If you become rich through modifications, related works/services, or supporting the original work,
-share the love. Only a dick would make loads off this work and not buy the original work's
-creator(s) a pint.
-
-3. Code is provided with no warranty. Using somebody else's code and bitching when it goes wrong makes
-you a DONKEY dick. Fix the problem yourself. A non-dick would submit the fix back.
+# DON'T BE A DICK PUBLIC LICENSE
+
+> Version 1.1, December 2016
+
+> Copyright (C) 2025 Gateway Corporate Solutions LLC
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document.
+
+> DON'T BE A DICK PUBLIC LICENSE
+> TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+1. Do whatever you like with the original work, just don't be a dick.
+
+   Being a dick includes - but is not limited to - the following instances:
+
+ 1a. Outright copyright infringement - Don't just copy this and change the name.
+ 1b. Selling the unmodified original with no work done what-so-ever, that's REALLY being a dick.
+ 1c. Modifying the original work to contain hidden harmful content. That would make you a PROPER dick.
+
+2. If you become rich through modifications, related works/services, or supporting the original work,
+share the love. Only a dick would make loads off this work and not buy the original work's
+creator(s) a pint.
+
+3. Code is provided with no warranty. Using somebody else's code and bitching when it goes wrong makes
+you a DONKEY dick. Fix the problem yourself. A non-dick would submit the fix back.
         

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "devicer.js",
-  "version": "1.0.13",
+  "version": "1.2.0",
   "description": "Open-Source Digital Fingerprinting Middleware",
-  "main": "src/main.js",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
   "scripts": {
     "test": "npx vitest",
-    "build": "tsc"
+    "build": "tsc --outDir dist"
   },
   "repository": {
     "type": "git",
@@ -24,7 +25,11 @@
   },
   "homepage": "https://github.com/gatewaycorporate/fp-devicer#readme",
   "dependencies": {
-    "tlsh": "^1.0.8",
+    "tlsh": "^1.0.8"
+  },
+  "devDependencies": {
+    "@types/node": "^18.15.11",
+    "typescript": "^5.0.3",
     "vitest": "^3.2.3"
   }
 }

package/src/libs/comparitors.ts

@@ -0,0 +1,11 @@
+export function levenshteinSimilarity(a: string, b: string): number {
+  if (a === b) return 1;
+  if (!a || !b) return 0;
+  const maxLen = Math.max(a.length, b.length);
+  let distance = Math.abs(a.length - b.length);
+  const minLen = Math.min(a.length, b.length);
+  for (let i = 0; i < minLen; i++) {
+    if (a[i] !== b[i]) distance++;
+  }
+  return Math.max(0, 1 - distance / maxLen);
+}

package/src/libs/confidence.ts

@@ -1,143 +1,123 @@
-import { compareHashes, getHash } from "./tlsh";
-import { FPDataSet } from "../types/data";
-
-export function compareArrays(
-  arr1: any[],
-  arr2: any[],
-  max_depth: number = 5,
-): [number, number] {
-  let fields = 0;
-  let matches = 0;
-
-  // Ensure max_depth is not exceeded
-  if (max_depth <= 0) {
-    throw new Error("Max depth exceeded");
-  }
-
-  // Sort arrays to ensure consistent comparison
-  const sortedArr1 = arr1.map((item) => JSON.stringify(item)).sort().map(
-    (item) => {
-      try {
-        return JSON.parse(item);
-      } catch (e) {
-        return undefined;
-      }
-    },
-  );
-  const sortedArr2 = arr2.map((item) => JSON.stringify(item)).sort().map(
-    (item) => {
-      try {
-        return JSON.parse(item);
-      } catch (e) {
-        return undefined;
-      }
-    },
-  );
-
-  const maxLength = Math.min(arr1.length, arr2.length);
-  for (let i = 0; i < maxLength; i++) {
-    fields++;
-    if (Array.isArray(sortedArr1[i]) && Array.isArray(sortedArr2[i])) {
-      const subData = compareArrays(
-        sortedArr1[i],
-        sortedArr2[i],
-        max_depth - 1,
-      );
-      fields += subData[0] - 1; // Subtract 1 for the index itself
-      matches += subData[1];
-    }
-    
-    else if (
-      (typeof sortedArr1[i] == "object" && sortedArr1[i]) &&
-      (typeof sortedArr2[i] == "object" && sortedArr2[i])
-    ) {
-      const subData = compareDatasets(
-        sortedArr1[i] as FPDataSet,
-        sortedArr2[i] as FPDataSet,
-        max_depth - 1,
-      );
-      fields += subData[0] - 1; // Subtract 1 for the index itself
-      matches += subData[1];
-    }
-
-    if (sortedArr2.includes(sortedArr1[i])) {
-      matches++;
-    }
-  }
-  return [fields, matches];
-}
-
-export function compareDatasets(
-  data1: FPDataSet,
-  data2: FPDataSet,
-  max_depth: number = 5,
-): [number, number] {
-  let fields = 0;
-  let matches = 0;
-
-  // Ensure max_depth is not exceeded
-  if (max_depth <= 0) {
-    throw new Error("Max depth exceeded");
-  }
-
-  for (const key in data1) {
-    if (data1[key] !== undefined && data2[key] !== undefined) {
-      fields++;
-      if (
-        (typeof data1[key] == "object" && data1[key]) &&
-        (typeof data2[key] == "object" && data2[key])
-      ) {
-        const subData = compareDatasets(
-          data1[key] as FPDataSet,
-          data2[key] as FPDataSet,
-          max_depth - 1,
-        );
-        fields += subData[0] - 1; // Subtract 1 for the key itself
-        matches += subData[1];
-      }
-      
-      else if (Array.isArray(data1[key]) && Array.isArray(data2[key])) {
-        const subData = compareArrays(data1[key], data2[key], max_depth - 1);
-        fields += subData[0] - 1; // Subtract 1 for the key itself
-        matches += subData[1];
-      }
-
-      else if (data1[key] == data2[key]) {
-        matches++;
-      }
-    }
-  }
-  return [fields, matches];
-}
-
-export function calculateConfidence(
-  data1: FPDataSet,
-  data2: FPDataSet,
-): number {
-  try {
-    // Compare how many fields are the same in both datasets
-    const [fields, matches] = compareDatasets(data1, data2);
-
-    if (fields === 0 || matches === 0) {
-      return 0;
-    }
-
-    // Calculate the hash for each user data
-    const hash1 = getHash(JSON.stringify(data1));
-    const hash2 = getHash(JSON.stringify(data2));
-
-    // Compare the hashes to get their difference
-    const differenceScore = compareHashes(hash1, hash2);
-
-    const inverseMatchScore = 1 - (matches / fields);
-    const x = 1.3 * differenceScore * inverseMatchScore;
-    if (inverseMatchScore === 0 || differenceScore === 0) {
-      return 100;
-    }
-    const confidenceScore = 100 / (1 + Math.E ** (-4.5 + (0.3 * x)));
-    return confidenceScore;
-  } catch (error) {
-    console.error("Error calculating confidence:", error);
-    return 0; // Return 0 if an error occurs during comparison
-  }
-}
+import { compareHashes, getHash } from "./tlsh";
+import { getGlobalRegistry } from "./registry";
+import { FPDataSet, ComparisonOptions, Comparator } from "../types/data";
+
+const DEFAULT_WEIGHTS: Record<string, number> = {
+  userAgent: 20,
+  platform: 15,
+  timezone: 10,
+  language: 10,
+  languages: 10,
+  cookieEnabled: 5,
+  doNotTrack: 5,
+  hardwareConcurrency: 5,
+  deviceMemory: 5,
+  product: 5,
+  productSub: 5,
+  vendor: 5,
+  vendorSub: 5,
+  appName: 5,
+  appVersion: 5,
+  appCodeName: 5,
+  appMinorVersion: 5,
+  buildID: 5,
+  plugins: 10,
+  mimeTypes: 10,
+  screen: 10,
+  fonts: 15
+};
+
+export function createConfidenceCalculator(userOptions: ComparisonOptions = {}) {
+  const {
+    weights: localWeights = {},
+    comparators: localComparators = {},
+    defaultWeight: localDefaultWeight = 5,
+    tlshWeight = 0.30,
+    maxDepth = 5,
+    useGlobalRegistry = true,
+  } = userOptions;
+
+  // Merge global registry (if enabled) → local always wins
+  const global = useGlobalRegistry ? getGlobalRegistry() : { comparators: {}, weights: {}, defaultWeight: 5 };
+
+  const finalDefaultWeight = localDefaultWeight ?? global.defaultWeight ?? 5;
+  const mergedWeights = { ...global.weights, ...DEFAULT_WEIGHTS, ...localWeights };
+  const mergedComparators = { ...global.comparators, ...localComparators };
+
+  const defaultComparator: Comparator = (a, b) => Number(a === b);
+
+  const getComparator = (path: string): Comparator => mergedComparators[path] ?? defaultComparator;
+
+  const getWeight = (path: string): number => mergedWeights[path] ?? finalDefaultWeight;
+
+  function compareRecursive(
+    data1: any,
+    data2: any,
+    path = "",
+    depth = 0
+  ): { totalWeight: number; matchedWeight: number } {
+    if (depth > maxDepth) return { totalWeight: 0, matchedWeight: 0 };
+    if (data1 === undefined || data2 === undefined) return { totalWeight: 0, matchedWeight: 0 };
+
+    // Leaf / primitive value
+    if (typeof data1 !== "object" || data1 === null || typeof data2 !== "object" || data2 === null) {
+      const comparator = getComparator(path);
+      const similarity = Math.max(0, Math.min(1, comparator(data1, data2, path)));
+      const weight = getWeight(path);
+      return { totalWeight: weight, matchedWeight: weight * similarity };
+    }
+
+    // Array
+    if (Array.isArray(data1) && Array.isArray(data2)) {
+      let total = 0;
+      let matched = 0;
+      const len = Math.min(data1.length, data2.length);
+      for (let i = 0; i < len; i++) {
+        const res = compareRecursive(data1[i], data2[i], `${path}[${i}]`, depth + 1);
+        total += res.totalWeight;
+        matched += res.matchedWeight;
+      }
+      return { totalWeight: total, matchedWeight: matched };
+    }
+
+    // Object
+    let totalWeight = 0;
+    let matchedWeight = 0;
+    const keys = new Set([...Object.keys(data1 || {}), ...Object.keys(data2 || {})]);
+
+    for (const key of keys) {
+      const newPath = path ? `${path}.${key}` : key;
+      const res = compareRecursive(data1?.[key], data2?.[key], newPath, depth + 1);
+      totalWeight += res.totalWeight;
+      matchedWeight += res.matchedWeight;
+    }
+
+    return { totalWeight, matchedWeight };
+  }
+
+  return {
+    calculateConfidence(data1: FPDataSet, data2: FPDataSet): number {
+      try {
+        const { totalWeight, matchedWeight } = compareRecursive(data1, data2);
+        const structuralScore = totalWeight > 0 ? matchedWeight / totalWeight : 0;
+
+        // TLSH fuzzy component (kept exactly as before)
+        let tlshScore = 1;
+        if (tlshWeight > 0) {
+          const hash1 = getHash(JSON.stringify(data1));
+          const hash2 = getHash(JSON.stringify(data2));
+          const diff = compareHashes(hash1, hash2);
+          tlshScore = Math.max(0, (100 - diff) / 100);
+        }
+
+        const finalScore = structuralScore * (1 - tlshWeight) + tlshScore * tlshWeight;
+        return Math.round(Math.max(0, Math.min(100, finalScore * 100)));
+      } catch (error) {
+        console.error("Error calculating confidence:", error);
+        return 0;
+      }
+    },
+  };
+}
+
+export const calculateConfidence = createConfidenceCalculator().calculateConfidence;

package/src/libs/defaults.ts

@@ -0,0 +1,22 @@
+import { registerPlugin } from "./registry";
+import type { Comparator } from "../types/data";
+import { levenshteinSimilarity } from "./comparitors";
+
+const BUILT_IN_PLUGINS = [
+    {
+        path: "userAgent",
+        weight: 20,
+        comparator: (a: any, b: any) => levenshteinSimilarity(String(a || "").toLowerCase(), String(b || "").toLowerCase())
+    },
+    {
+        path: "platform",
+        weight: 15,
+        comparator: (a: any, b: any) => levenshteinSimilarity(String(a || "").toLowerCase(), String(b || "").toLowerCase())
+    }
+]
+
+export function initializeDefaultRegistry() {
+    for (const plugin of BUILT_IN_PLUGINS) {
+        registerPlugin(plugin.path, { weight: plugin.weight, comparator: plugin.comparator as Comparator });
+    }
+}