user-agents 2.0.0-alpha.98 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "user-agents",
-  "version": "2.0.0-alpha.98",
+  "version": "2.1.1",
   "description": "A JavaScript library for generating random user agents. ",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -19,6 +19,9 @@
     "import": "./dist/index.js",
     "require": "./dist/index.cjs"
   },
+  "engines": {
+    "node": ">=18"
+  },
   "license": "BSD-2-Clause",
   "private": false,
   "type": "module",
@@ -26,8 +29,8 @@
     "build": "tsup",
     "postbuild": "yarn gunzip-data && cp src/user-agents.json dist/",
     "gunzip-data": "node --loader ts-node/esm src/gunzip-data.ts src/user-agents.json.gz",
-    "lint": "eslint src/ && prettier --check src/",
-    "test": "NODE_ENV=testing mocha --exit --require @babel/register --extensions '.ts, .js'",
+    "lint": "eslint src/ test/ && prettier --check src/ test/",
+    "test": "NODE_OPTIONS='--import tsx' mocha --exit --extensions '.ts, .js'",
     "update-data": "node --loader ts-node/esm src/update-data.ts src/user-agents.json.gz"
   },
   "devDependencies": {
@@ -35,39 +38,39 @@
     "@babel/core": "^7.23.2",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
     "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
-    "@babel/plugin-syntax-import-assertions": "^7.22.5",
+    "@babel/plugin-syntax-import-attributes": "^7.22.5",
     "@babel/plugin-transform-classes": "^7.22.15",
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.23.2",
     "@babel/register": "^7.22.15",
-    "@types/lodash.clonedeep": "^4.5.8",
+    "@types/node": "^25.5.0",
     "@types/ua-parser-js": "^0.7.38",
-    "@typescript-eslint/eslint-plugin": "^6.9.0",
-    "@typescript-eslint/parser": "^6.9.0",
     "babel-loader": "^9.1.3",
     "babel-plugin-add-module-exports": "^1.0.4",
     "babel-preset-power-assert": "^3.0.0",
     "dynamoose": "^3.2.1",
-    "esbuild": "^0.19.5",
-    "eslint": "^8.52.0",
-    "eslint-config-airbnb": "^19.0.4",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-import": "^2.29.0",
+    "esbuild": "^0.25.0",
+    "eslint": "^9",
+    "eslint-config-prettier": "^10.1.8",
     "fast-json-stable-stringify": "^2.1.0",
     "imports-loader": "^4.0.1",
     "isbot": "^3.7.0",
-    "mocha": "^10.2.0",
+    "mocha": "^11.7.5",
     "power-assert": "^1.6.1",
-    "prettier": "^3.0.3",
+    "prettier": "^3.1.0",
     "random": "^4.1.0",
     "source-map-support": "^0.5.21",
     "ts-node": "^10.9.1",
-    "tsup": "^7.2.0",
-    "typescript": "^5.2.2",
+    "tsup": "^8.5.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.57.0",
     "typescript-language-server": "^4.0.0",
     "ua-parser-js": "^1.0.36"
   },
-  "dependencies": {
-    "lodash.clonedeep": "^4.5.0"
+  "dependencies": {},
+  "resolutions": {
+    "diff": "^8.0.3",
+    "serialize-javascript": "^7.0.3"
   }
 }

package/src/update-data.ts

@@ -1,4 +1,3 @@
-/* eslint-disable import/no-extraneous-dependencies */
 import fs from 'fs';
 import { argv } from 'process';
 import { fileURLToPath } from 'url';
@@ -67,6 +66,16 @@ const getUserAgentTable = async (limit = 1e4) => {
       // Filter out bots like Googlebot and YandexBot.
       if (isbot(profile.userAgent)) return;
 
+      // Strip extra quotes that some browsers include around the user agent string.
+      profile.userAgent = (profile.userAgent as string).replace(/^"|"$/g, '');
+
+      // Filter out spam/fake user agents with non-ASCII characters.
+      // Real browser UA strings are always pure ASCII per the HTTP spec.
+      if (/[^\x20-\x7E]/.test(profile.userAgent as string)) return;
+
+      // Filter out the literal `{userAgent}` placeholder string that some clients send.
+      if (profile.userAgent === '{userAgent}') return;
+
       // Track the counts for this exact profile.
       const stringifiedProfile = stableStringify(profile);
       if (!countsByProfile[stringifiedProfile]) {
@@ -91,7 +100,7 @@ const getUserAgentTable = async (limit = 1e4) => {
   // Accumulate the profiles and add/remove a few properties to match the historical format.
   const profiles: UserAgentData[] = [];
   Object.entries(countsByProfile).forEach(([stringifiedProfile, weight]) => {
-    if (countsByProfile.hasOwnProperty(stringifiedProfile)) {
+    if (Object.hasOwn(countsByProfile, stringifiedProfile)) {
       const profile = JSON.parse(stringifiedProfile);
       profile.weight = weight;
       delete profile.sessionId;
@@ -136,7 +145,6 @@ if (fileURLToPath(import.meta.url) === argv[1]) {
       fs.writeFileSync(filename, content);
     })
     .catch((error) => {
-      // eslint-disable-next-line no-console
       console.error(error);
       process.exit(1);
     });

package/src/user-agent.ts

@@ -1,6 +1,4 @@
-import cloneDeep from 'lodash.clonedeep';
-
-import untypedUserAgents from './user-agents.json' assert { type: 'json' };
+import untypedUserAgents from './user-agents.json' with { type: 'json' };
 
 const userAgents: UserAgentData[] = untypedUserAgents as UserAgentData[];
 
@@ -108,7 +106,7 @@ const constructFilter = <T extends UserAgentData | NestedValueOf<UserAgentData>>
     try {
       const value = accessor(parentObject);
       return childFilters.every((childFilter) => childFilter(value as T));
-    } catch (error) {
+    } catch {
       // This happens when a user-agent lacks a nested property.
       return false;
     }
@@ -146,9 +144,34 @@ const setCumulativeWeightIndexPairs = (
   });
 };
 
-export class UserAgent extends Function {
+// WeakSet tracking all UserAgent instances for `instanceof` support through proxies.
+const userAgentInstances = new WeakSet<object>();
+
+export class UserAgent {
+  static [Symbol.hasInstance](instance: unknown): boolean {
+    return instance instanceof Object && userAgentInstances.has(instance as object);
+  }
+
+  static random = (filters: Filter) => {
+    try {
+      return new UserAgent(filters);
+    } catch {
+      return null;
+    }
+  };
+
+  // Static version that creates a temporary instance with the given filters and returns the top entries.
+  static top = (count?: number, filters?: Filter): UserAgentData[] => {
+    try {
+      return new UserAgent(filters).top(count);
+    } catch {
+      return [];
+    }
+  };
+
+  readonly data!: UserAgentData;
+
   constructor(filters?: Filter) {
-    super();
     setCumulativeWeightIndexPairs(this, constructCumulativeWeightIndexPairsFromFilters(filters));
     if (this.cumulativeWeightIndexPairs.length === 0) {
       throw new Error('No user agents matched your filters.');
@@ -156,39 +179,41 @@ export class UserAgent extends Function {
 
     this.randomize();
 
-    // eslint-disable-next-line no-constructor-return
-    return new Proxy(this, {
+    // Use a plain function as the proxy target so the `apply` trap works without
+    // extending `Function`, which requires `eval` and violates CSP in browser extensions.
+    // All property access is forwarded to the real UserAgent instance via the traps.
+    const target = () => {};
+    const proxy = new Proxy(target as unknown as this, {
       apply: () => this.random(),
-      get: (target, property, receiver) => {
-        const dataCandidate =
-          target.data &&
+      get: (_target, property) => {
+        if (
+          this.data &&
           typeof property === 'string' &&
-          Object.prototype.hasOwnProperty.call(target.data, property) &&
-          Object.prototype.propertyIsEnumerable.call(target.data, property);
-        if (dataCandidate) {
-          const value = target.data[property as keyof UserAgentData];
+          Object.prototype.hasOwnProperty.call(this.data, property) &&
+          Object.prototype.propertyIsEnumerable.call(this.data, property)
+        ) {
+          const value = this.data[property as keyof UserAgentData];
           if (value !== undefined) {
             return value;
           }
         }
 
-        return Reflect.get(target, property, receiver);
+        return Reflect.get(this, property);
       },
+      set: (_target, property, value) => Reflect.set(this, property, value),
+      defineProperty: (_target, property, descriptor) =>
+        Reflect.defineProperty(this, property, descriptor),
+      getOwnPropertyDescriptor: (_target, property) =>
+        Reflect.getOwnPropertyDescriptor(this, property),
+      has: (_target, property) => Reflect.has(this, property),
+      deleteProperty: (_target, property) => Reflect.deleteProperty(this, property),
+      ownKeys: () => Reflect.ownKeys(this),
+      getPrototypeOf: () => UserAgent.prototype,
     });
+    userAgentInstances.add(proxy);
+    return proxy;
   }
 
-  static random = (filters: Filter) => {
-    try {
-      return new UserAgent(filters);
-    } catch (error) {
-      return null;
-    }
-  };
-
-  //
-  // Standard Object Methods
-  //
-
   [Symbol.toPrimitive] = (): string => this.data.userAgent;
 
   toString = (): string => this.data.userAgent;
@@ -200,6 +225,18 @@ export class UserAgent extends Function {
     return userAgent;
   };
 
+  top = (count?: number): UserAgentData[] => {
+    // Recover individual weights from the cumulative distribution and sort by descending weight.
+    const pairs = this.cumulativeWeightIndexPairs;
+    const entries = pairs.map(([cumWeight, index], i) => ({
+      weight: i > 0 ? cumWeight - pairs[i - 1][0] : cumWeight,
+      index,
+    }));
+    entries.sort((a, b) => b.weight - a.weight);
+    const n = count != null ? Math.min(count, entries.length) : entries.length;
+    return entries.slice(0, n).map(({ index }) => structuredClone(userAgents[index]));
+  };
+
   randomize = (): void => {
     // Find a random raw random user agent.
     const randomNumber = Math.random();
@@ -210,8 +247,7 @@ export class UserAgent extends Function {
     if (index == null) {
       throw new Error('Error finding a random user agent.');
     }
-    const rawUserAgent = userAgents[index];
 
-    (this as { data: UserAgentData }).data = cloneDeep(rawUserAgent);
+    (this as { data: UserAgentData }).data = structuredClone(userAgents[index]);
   };
 }