@tinkoff/user-agent 0.7.204 → 0.8.105

package/README.md

@@ -1,5 +1,194 @@
 # User agent
 
-Library for parsing and executing checks by:
+A set of methods for parsing userAgent and getting browser data. Library for parsing and executing checks by:
+
 - userAgent string. Based on [ua-parser-js](https://github.com/faisalman/ua-parser-js)
 - [Client Hints](https://developer.mozilla.org/en-US/docs/Web/HTTP/Client_hints) headers
+
+## parseClientHintsHeaders
+
+Used on the **server** to supplement information from ClientHints headers (`sec-ch-ua`). The parseClientHintsUserAgentData method constructs an object with information based on the headers, enriches it with browser details, fills in additional fields, and ensures backward compatibility in naming. Essentially, it performs data preparation and some data hygiene. For example, when parsing headers with low entropy,
+
+```tsx
+const headers = {
+  'sec-ch-ua': '"Chromium";v="106", "Google Chrome";v="106", "Not;A=Brand";v="99"',
+  'sec-ch-ua-mobile': '?0',
+  'sec-ch-ua-platform': '"Windows"',
+};
+```
+
+We get
+
+```tsx
+const userAgent = {
+  browser: {
+    browserEngine: 'chrome',
+    major: '106',
+    name: 'chrome',
+    version: '106',
+  },
+  cpu: {
+    architecture: undefined,
+  },
+  device: {
+    model: undefined,
+    type: 'desktop',
+    vendor: undefined,
+  },
+  engine: {
+    name: 'Blink',
+    version: '106',
+  },
+  mobileOS: undefined,
+  os: {
+    name: 'Windows',
+    version: undefined,
+  },
+  sameSiteNoneCompatible: true,
+};
+```
+
+When parsing headers with high entropy,
+
+```tsx
+const headers = {
+  'sec-ch-ua-full-version-list':
+    '"Not.A/Brand";v="8.0.0.0", "Chromium";v="110.0.5481.100", "Google Chrome";v="110.0.5481.100"',
+  'sec-ch-ua-platform-version': '"10.0.19044.2364"',
+  'sec-ch-ua-arch': '"x86_64"',
+  'sec-ch-ua-model': '"iPhone 13"',
+};
+```
+
+We get
+
+```tsx
+const userAgent = {
+  browser: {
+    browserEngine: 'chrome',
+    major: '110.0.5481.100',
+    name: 'chrome',
+    version: '110.0.5481.100',
+  },
+  cpu: {
+    architecture: 'x86_64',
+  },
+  device: {
+    model: 'iPhone 13',
+    type: 'desktop',
+    vendor: undefined,
+  },
+  engine: {
+    name: 'Blink',
+    version: '110.0.5481.100',
+  },
+  mobileOS: undefined,
+  os: {
+    name: undefined,
+    version: '10.0.19044.2364',
+  },
+  sameSiteNoneCompatible: true,
+};
+```
+
+## parseClientHintsUserAgentData
+
+Used on the **client** to supplement information from navigator.userAgentData.
+
+The parseClientHintsUserAgentData method enriches the object with browser information, fills in additional fields, and ensures backward compatibility in naming. Essentially, it performs data preparation and some data hygiene.
+
+For example, when parsing:
+
+```tsx
+const userAgentData = {
+  brands: [
+    {
+      brand: 'Not.A/Brand',
+      version: '8',
+    },
+    {
+      brand: 'Chromium',
+      version: '114',
+    },
+    {
+      brand: 'Google Chrome',
+      version: '114',
+    },
+  ],
+  mobile: true,
+  platform: 'Android',
+};
+```
+
+We get
+
+```tsx
+const userAgent = {
+  browser: {
+    browserEngine: 'chrome',
+    major: '114',
+    name: 'chrome',
+    version: '114',
+  },
+  cpu: {
+    architecture: undefined,
+  },
+  device: {
+    model: undefined,
+    type: 'mobile',
+    vendor: undefined,
+  },
+  engine: {
+    name: 'Blink',
+    version: '114',
+  },
+  mobileOS: 'android',
+  os: {
+    name: 'Android',
+    version: undefined,
+  },
+  sameSiteNoneCompatible: true,
+};
+```
+
+## parseUserAgentHeader
+
+Used in the following cases:
+
+- Headers are unavailable on the **server**.
+- There were errors in obtaining navigator.userAgentData on the **client**.
+
+The parseUserAgentHeader method parses the userAgent string and returns an object with browser data. For example, when parsing `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36` We get
+
+```tsx
+const userAgent = {
+  browser: {
+    browserEngine: 'chrome',
+    major: '83',
+    name: 'chrome',
+    version: '83.0.4103.61',
+  },
+  cpu: {
+    architecture: undefined,
+  },
+  device: {
+    model: undefined,
+    type: undefined,
+    vendor: undefined,
+  },
+  engine: {
+    name: 'Blink',
+    version: '83.0.4103.61',
+  },
+  mobileOS: undefined,
+  os: {
+    name: 'Mac OS',
+    version: '10.15.4',
+  },
+  sameSiteNoneCompatible: true,
+};
+```
+
+## isBrowserSatisfiesRequirements
+
+The function isBrowserSatisfiesRequirements checks if a given user agent satisfies the specified browser requirements based on a browserslist configuration. It parses the user agent to determine the browser and its version, normalizes the browserslist configuration, and compares the browser version against the specified requirements. The function returns true if the browser meets the requirements, false if it does not, and null if the browser is not found in the browserslist. It also handles special cases for Chromium-based browsers and allows forcing the use of minimum requested versions for browsers with incomplete statistics.

package/lib/client-hints/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const KNOWN_VENDORS: Set<string>;
+export declare const KNOWN_ENGINES: Set<string>;
+export declare const BACKWARD_COMPATIBILITY_BROWSER_NAME: Record<string, string>;
+export declare const BACKWARD_COMPATIBILITY_ENGINE_NAME: Record<string, string>;
+export declare const BACKWARD_COMPATIBILITY_ARCH: Record<string, string>;
+export declare const BACKWARD_COMPATIBILITY_OS_NAME: Record<string, string>;
+//# sourceMappingURL=constants.d.ts.map

package/lib/client-hints/constants.es.js

@@ -0,0 +1,23 @@
+const KNOWN_VENDORS = new Set([
+    'Opera',
+    'Google Chrome',
+    'Microsoft Edge',
+    'Firefox',
+    'Safari',
+]);
+const KNOWN_ENGINES = new Set(['Chromium']);
+const BACKWARD_COMPATIBILITY_BROWSER_NAME = {
+    'Google Chrome': 'chrome',
+    'Microsoft Edge': 'edge',
+};
+const BACKWARD_COMPATIBILITY_ENGINE_NAME = {
+    Chromium: 'Blink',
+};
+const BACKWARD_COMPATIBILITY_ARCH = {
+    x86: 'amd64',
+};
+const BACKWARD_COMPATIBILITY_OS_NAME = {
+    macOS: 'Mac OS',
+};
+
+export { BACKWARD_COMPATIBILITY_ARCH, BACKWARD_COMPATIBILITY_BROWSER_NAME, BACKWARD_COMPATIBILITY_ENGINE_NAME, BACKWARD_COMPATIBILITY_OS_NAME, KNOWN_ENGINES, KNOWN_VENDORS };

package/lib/client-hints/constants.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const KNOWN_VENDORS = new Set([
+    'Opera',
+    'Google Chrome',
+    'Microsoft Edge',
+    'Firefox',
+    'Safari',
+]);
+const KNOWN_ENGINES = new Set(['Chromium']);
+const BACKWARD_COMPATIBILITY_BROWSER_NAME = {
+    'Google Chrome': 'chrome',
+    'Microsoft Edge': 'edge',
+};
+const BACKWARD_COMPATIBILITY_ENGINE_NAME = {
+    Chromium: 'Blink',
+};
+const BACKWARD_COMPATIBILITY_ARCH = {
+    x86: 'amd64',
+};
+const BACKWARD_COMPATIBILITY_OS_NAME = {
+    macOS: 'Mac OS',
+};
+
+exports.BACKWARD_COMPATIBILITY_ARCH = BACKWARD_COMPATIBILITY_ARCH;
+exports.BACKWARD_COMPATIBILITY_BROWSER_NAME = BACKWARD_COMPATIBILITY_BROWSER_NAME;
+exports.BACKWARD_COMPATIBILITY_ENGINE_NAME = BACKWARD_COMPATIBILITY_ENGINE_NAME;
+exports.BACKWARD_COMPATIBILITY_OS_NAME = BACKWARD_COMPATIBILITY_OS_NAME;
+exports.KNOWN_ENGINES = KNOWN_ENGINES;
+exports.KNOWN_VENDORS = KNOWN_VENDORS;

package/lib/client-hints/parse-client-hints-headers/consts.d.ts

@@ -0,0 +1,11 @@
+export declare const ClientHintsHeaders: {
+    readonly BASE: "sec-ch-ua";
+    readonly FULL_VERSION_LIST: "sec-ch-ua-full-version-list";
+    readonly PLATFORM: "sec-ch-ua-platform";
+    readonly PLATFORM_VERSION: "sec-ch-ua-platform-version";
+    readonly ARCH: "sec-ch-ua-arch";
+    readonly MODEL: "sec-ch-ua-model";
+    readonly MOBILE: "sec-ch-ua-mobile";
+};
+export type ClientHintsHeaders = (typeof ClientHintsHeaders)[keyof typeof ClientHintsHeaders];
+//# sourceMappingURL=consts.d.ts.map

package/lib/client-hints/parse-client-hints-headers/consts.es.js

@@ -0,0 +1,11 @@
+const ClientHintsHeaders = {
+    BASE: 'sec-ch-ua',
+    FULL_VERSION_LIST: 'sec-ch-ua-full-version-list',
+    PLATFORM: 'sec-ch-ua-platform',
+    PLATFORM_VERSION: 'sec-ch-ua-platform-version',
+    ARCH: 'sec-ch-ua-arch',
+    MODEL: 'sec-ch-ua-model',
+    MOBILE: 'sec-ch-ua-mobile',
+};
+
+export { ClientHintsHeaders };

package/lib/client-hints/parse-client-hints-headers/consts.js

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const ClientHintsHeaders = {
+    BASE: 'sec-ch-ua',
+    FULL_VERSION_LIST: 'sec-ch-ua-full-version-list',
+    PLATFORM: 'sec-ch-ua-platform',
+    PLATFORM_VERSION: 'sec-ch-ua-platform-version',
+    ARCH: 'sec-ch-ua-arch',
+    MODEL: 'sec-ch-ua-model',
+    MOBILE: 'sec-ch-ua-mobile',
+};
+
+exports.ClientHintsHeaders = ClientHintsHeaders;

package/lib/client-hints/parse-client-hints-headers/parseClientHintsHeaders.d.ts

@@ -0,0 +1,18 @@
+import { UserAgent } from '../../types';
+/**
+ *
+ * @description
+ *
+ * Some of the data are available only when additional headers for client-hints were sent from server:
+ * - full browser version (only major version is available by default)
+ * - OS version
+ * - CPU architecture
+ * - device model
+ *
+ * To be able to use data you should first provide header `Accept-CH` with the list of headers that client should send.
+ *
+ * @param headers
+ * @returns
+ */
+export declare const parseClientHintsHeaders: (headers: Record<string, string | string[] | undefined>) => UserAgent;
+//# sourceMappingURL=parseClientHintsHeaders.d.ts.map

package/lib/client-hints/parse-client-hints-headers/parseClientHintsHeaders.es.js

@@ -0,0 +1,54 @@
+import { DeviceType } from '../../constants.es.js';
+import { getMobileOs } from '../../utils/getMobileOs.es.js';
+import { BACKWARD_COMPATIBILITY_ARCH } from '../constants.es.js';
+import { getBackwardCompatibleOsName } from '../utils/getBackwardCompatibleOsName.es.js';
+import { parseBrowserFromString } from '../utils/parseBrowserFromString.es.js';
+import { parseQuotedString } from '../utils/parseQuotedString.es.js';
+import { ClientHintsHeaders } from './consts.es.js';
+
+/**
+ *
+ * @description
+ *
+ * Some of the data are available only when additional headers for client-hints were sent from server:
+ * - full browser version (only major version is available by default)
+ * - OS version
+ * - CPU architecture
+ * - device model
+ *
+ * To be able to use data you should first provide header `Accept-CH` with the list of headers that client should send.
+ *
+ * @param headers
+ * @returns
+ */
+const parseClientHintsHeaders = (headers) => {
+    const { browser, engine } = parseBrowserFromString(headers[ClientHintsHeaders.FULL_VERSION_LIST] ||
+        headers[ClientHintsHeaders.BASE]);
+    const osName = parseQuotedString(headers[ClientHintsHeaders.PLATFORM]);
+    const mobileOS = getMobileOs(osName);
+    const architecture = parseQuotedString(headers[ClientHintsHeaders.ARCH]);
+    return {
+        browser,
+        engine,
+        os: {
+            name: getBackwardCompatibleOsName(osName),
+            version: parseQuotedString(headers[ClientHintsHeaders.PLATFORM_VERSION]),
+        },
+        cpu: {
+            architecture: architecture
+                ? (BACKWARD_COMPATIBILITY_ARCH[architecture] ?? architecture)
+                : architecture,
+        },
+        mobileOS,
+        device: {
+            model: parseQuotedString(headers[ClientHintsHeaders.MODEL]),
+            type: headers[ClientHintsHeaders.MOBILE] === '?1' ? DeviceType.mobile : DeviceType.desktop,
+            vendor: undefined,
+        },
+        // basically all the browsers with client-hints support
+        // also compatible with SameSite=None
+        sameSiteNoneCompatible: true,
+    };
+};
+
+export { parseClientHintsHeaders };

package/lib/client-hints/parse-client-hints-headers/parseClientHintsHeaders.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants$1 = require('../../constants.js');
+var getMobileOs = require('../../utils/getMobileOs.js');
+var constants = require('../constants.js');
+var getBackwardCompatibleOsName = require('../utils/getBackwardCompatibleOsName.js');
+var parseBrowserFromString = require('../utils/parseBrowserFromString.js');
+var parseQuotedString = require('../utils/parseQuotedString.js');
+var consts = require('./consts.js');
+
+/**
+ *
+ * @description
+ *
+ * Some of the data are available only when additional headers for client-hints were sent from server:
+ * - full browser version (only major version is available by default)
+ * - OS version
+ * - CPU architecture
+ * - device model
+ *
+ * To be able to use data you should first provide header `Accept-CH` with the list of headers that client should send.
+ *
+ * @param headers
+ * @returns
+ */
+const parseClientHintsHeaders = (headers) => {
+    const { browser, engine } = parseBrowserFromString.parseBrowserFromString(headers[consts.ClientHintsHeaders.FULL_VERSION_LIST] ||
+        headers[consts.ClientHintsHeaders.BASE]);
+    const osName = parseQuotedString.parseQuotedString(headers[consts.ClientHintsHeaders.PLATFORM]);
+    const mobileOS = getMobileOs.getMobileOs(osName);
+    const architecture = parseQuotedString.parseQuotedString(headers[consts.ClientHintsHeaders.ARCH]);
+    return {
+        browser,
+        engine,
+        os: {
+            name: getBackwardCompatibleOsName.getBackwardCompatibleOsName(osName),
+            version: parseQuotedString.parseQuotedString(headers[consts.ClientHintsHeaders.PLATFORM_VERSION]),
+        },
+        cpu: {
+            architecture: architecture
+                ? (constants.BACKWARD_COMPATIBILITY_ARCH[architecture] ?? architecture)
+                : architecture,
+        },
+        mobileOS,
+        device: {
+            model: parseQuotedString.parseQuotedString(headers[consts.ClientHintsHeaders.MODEL]),
+            type: headers[consts.ClientHintsHeaders.MOBILE] === '?1' ? constants$1.DeviceType.mobile : constants$1.DeviceType.desktop,
+            vendor: undefined,
+        },
+        // basically all the browsers with client-hints support
+        // also compatible with SameSite=None
+        sameSiteNoneCompatible: true,
+    };
+};
+
+exports.parseClientHintsHeaders = parseClientHintsHeaders;

package/lib/client-hints/parse-client-hints-user-agent-data/parseClientHintsUserAgentData.d.ts

@@ -0,0 +1,17 @@
+import { UserAgent } from '../../types';
+/**
+ *
+ * @description
+ * Some of the data will be available if `UADataValues` were gotten from
+ * `getHighEntropyValues` async method, but it's not suitable for all cases.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/User-Agent_Client_Hints_API
+ * @see https://wicg.github.io/ua-client-hints/#http-ua-hints
+ *
+ * @param payload
+ *
+ * @example
+ * const clientHints = parseClientHintsUserAgentData(window.navigator.userAgentData)
+ */
+export declare const parseClientHintsUserAgentData: (payload: UADataValues) => UserAgent;
+//# sourceMappingURL=parseClientHintsUserAgentData.d.ts.map

package/lib/client-hints/parse-client-hints-user-agent-data/parseClientHintsUserAgentData.es.js

@@ -0,0 +1,47 @@
+import { DeviceType } from '../../constants.es.js';
+import { getMobileOs } from '../../utils/getMobileOs.es.js';
+import { BACKWARD_COMPATIBILITY_ARCH } from '../constants.es.js';
+import { getBackwardCompatibleOsName } from '../utils/getBackwardCompatibleOsName.es.js';
+import { parseBrowserFromUserAgentData } from '../utils/parseBrowserFromUserAgentData.es.js';
+
+/**
+ *
+ * @description
+ * Some of the data will be available if `UADataValues` were gotten from
+ * `getHighEntropyValues` async method, but it's not suitable for all cases.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/User-Agent_Client_Hints_API
+ * @see https://wicg.github.io/ua-client-hints/#http-ua-hints
+ *
+ * @param payload
+ *
+ * @example
+ * const clientHints = parseClientHintsUserAgentData(window.navigator.userAgentData)
+ */
+const parseClientHintsUserAgentData = (payload) => {
+    const { browser, engine } = parseBrowserFromUserAgentData(payload.fullVersionList || payload.brands || []);
+    return {
+        browser,
+        engine,
+        os: {
+            name: getBackwardCompatibleOsName(payload.platform),
+            version: payload.platformVersion,
+        },
+        cpu: {
+            architecture: payload.architecture
+                ? (BACKWARD_COMPATIBILITY_ARCH[payload.architecture] ?? payload.architecture)
+                : payload.architecture,
+        },
+        mobileOS: getMobileOs(payload.platform),
+        device: {
+            model: payload.model,
+            type: payload.mobile ? DeviceType.mobile : DeviceType.desktop,
+            vendor: undefined,
+        },
+        // basically all the browsers with client-hints support
+        // also compatible with SameSite=None
+        sameSiteNoneCompatible: true,
+    };
+};
+
+export { parseClientHintsUserAgentData };

package/lib/client-hints/parse-client-hints-user-agent-data/parseClientHintsUserAgentData.js

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants$1 = require('../../constants.js');
+var getMobileOs = require('../../utils/getMobileOs.js');
+var constants = require('../constants.js');
+var getBackwardCompatibleOsName = require('../utils/getBackwardCompatibleOsName.js');
+var parseBrowserFromUserAgentData = require('../utils/parseBrowserFromUserAgentData.js');
+
+/**
+ *
+ * @description
+ * Some of the data will be available if `UADataValues` were gotten from
+ * `getHighEntropyValues` async method, but it's not suitable for all cases.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/User-Agent_Client_Hints_API
+ * @see https://wicg.github.io/ua-client-hints/#http-ua-hints
+ *
+ * @param payload
+ *
+ * @example
+ * const clientHints = parseClientHintsUserAgentData(window.navigator.userAgentData)
+ */
+const parseClientHintsUserAgentData = (payload) => {
+    const { browser, engine } = parseBrowserFromUserAgentData.parseBrowserFromUserAgentData(payload.fullVersionList || payload.brands || []);
+    return {
+        browser,
+        engine,
+        os: {
+            name: getBackwardCompatibleOsName.getBackwardCompatibleOsName(payload.platform),
+            version: payload.platformVersion,
+        },
+        cpu: {
+            architecture: payload.architecture
+                ? (constants.BACKWARD_COMPATIBILITY_ARCH[payload.architecture] ?? payload.architecture)
+                : payload.architecture,
+        },
+        mobileOS: getMobileOs.getMobileOs(payload.platform),
+        device: {
+            model: payload.model,
+            type: payload.mobile ? constants$1.DeviceType.mobile : constants$1.DeviceType.desktop,
+            vendor: undefined,
+        },
+        // basically all the browsers with client-hints support
+        // also compatible with SameSite=None
+        sameSiteNoneCompatible: true,
+    };
+};
+
+exports.parseClientHintsUserAgentData = parseClientHintsUserAgentData;

package/lib/client-hints/utils/getBackwardCompatibleOsName.d.ts

@@ -0,0 +1,2 @@
+export declare const getBackwardCompatibleOsName: (payload: string | undefined) => string | undefined;
+//# sourceMappingURL=getBackwardCompatibleOsName.d.ts.map

package/lib/client-hints/utils/getBackwardCompatibleOsName.es.js

@@ -0,0 +1,10 @@
+import { BACKWARD_COMPATIBILITY_OS_NAME } from '../constants.es.js';
+
+const getBackwardCompatibleOsName = (payload) => {
+    if (payload === undefined) {
+        return undefined;
+    }
+    return BACKWARD_COMPATIBILITY_OS_NAME[payload] ?? payload;
+};
+
+export { getBackwardCompatibleOsName };

package/lib/client-hints/utils/getBackwardCompatibleOsName.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+
+const getBackwardCompatibleOsName = (payload) => {
+    if (payload === undefined) {
+        return undefined;
+    }
+    return constants.BACKWARD_COMPATIBILITY_OS_NAME[payload] ?? payload;
+};
+
+exports.getBackwardCompatibleOsName = getBackwardCompatibleOsName;

package/lib/client-hints/utils/parseBrowserFromString.d.ts

@@ -0,0 +1,6 @@
+import type { Browser, Engine } from '../../types';
+export declare const parseBrowserFromString: (brandsList: string) => {
+    browser: Browser;
+    engine: Engine;
+};
+//# sourceMappingURL=parseBrowserFromString.d.ts.map

package/lib/client-hints/utils/parseBrowserFromString.es.js

@@ -0,0 +1,42 @@
+import { getBrowserEngine } from '../../utils/getBrowserEngine.es.js';
+import { KNOWN_VENDORS, BACKWARD_COMPATIBILITY_BROWSER_NAME, KNOWN_ENGINES, BACKWARD_COMPATIBILITY_ENGINE_NAME } from '../constants.es.js';
+import { parseQuotedString } from './parseQuotedString.es.js';
+
+/*
+  The parseBrowserFromString function accepts a brandsList string that contains information
+  about the browser and its engine in a format where each entry is separated by a comma,
+  and the brand name and version are separated. The function parses this string and returns
+  an object containing information about the browser and its engine.
+*/
+const parseBrowserFromString = (brandsList) => {
+    const browser = {
+        name: undefined,
+        version: undefined,
+        major: undefined,
+        browserEngine: '',
+    };
+    const engine = {
+        name: undefined,
+        version: undefined,
+    };
+    brandsList.split(',').forEach((entry) => {
+        const [name, version] = entry.split(/;\s*v=/).map(parseQuotedString);
+        if (name && KNOWN_VENDORS.has(name)) {
+            browser.name = BACKWARD_COMPATIBILITY_BROWSER_NAME[name] ?? name.toLowerCase();
+            browser.version = version;
+            browser.major = version;
+        }
+        if (name && KNOWN_ENGINES.has(name)) {
+            engine.name = BACKWARD_COMPATIBILITY_ENGINE_NAME[name] ?? name.toLowerCase();
+            engine.version = version;
+        }
+    });
+    if (!browser.name && engine.name) {
+        browser.name = engine.name;
+        browser.version = engine.version;
+    }
+    browser.browserEngine = getBrowserEngine(browser.name?.toLowerCase(), engine.name?.toLowerCase());
+    return { browser, engine };
+};
+
+export { parseBrowserFromString };