@tinkoff/user-agent 0.7.204 → 0.8.105

package/lib/{utils/merge-extensions.es.js → parse-user-agent-header/utils/mergeExtensions.es.js}

@@ -1,4 +1,4 @@
-import { uaParserExtensions } from '../constants.es.js';
+import { uaParserExtensions } from '../consts.es.js';
 
 const mergeExtensions = (extensions) => {
     if (!extensions?.length) {

package/lib/{utils/merge-extensions.js → parse-user-agent-header/utils/mergeExtensions.js}

@@ -2,12 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var constants = require('../constants.js');
+var consts = require('../consts.js');
 
 const mergeExtensions = (extensions) => {
     if (!extensions?.length) {
         return {
-            browser: [...constants.uaParserExtensions],
+            browser: [...consts.uaParserExtensions],
         };
     }
     const merged = extensions.reduce((acc, curr) => ({
@@ -18,7 +18,7 @@ const mergeExtensions = (extensions) => {
     }), {});
     return {
         ...merged,
-        browser: [...(merged.browser || []), ...constants.uaParserExtensions],
+        browser: [...(merged.browser || []), ...consts.uaParserExtensions],
     };
 };
 

package/lib/parse-user-agent-header/utils/toLowerName.d.ts

@@ -0,0 +1,2 @@
+export declare const toLowerName: (x0: any) => string;
+//# sourceMappingURL=toLowerName.d.ts.map

package/lib/parse-user-agent-header/utils/toLowerName.es.js

@@ -0,0 +1,14 @@
+import propOr from '@tinkoff/utils/object/propOr';
+import compose from '@tinkoff/utils/function/compose';
+import toLower from '@tinkoff/utils/string/toLower';
+
+/*
+    Function toLowerName returns the name property of an object in lowercase or an empty string if name is not present.
+    
+    toLowerName(anyObj)
+    equivalent to
+    (anyObj.name || '')?.toLowerCase()
+*/
+const toLowerName = compose(toLower, propOr('name', ''));
+
+export { toLowerName };

package/lib/parse-user-agent-header/utils/toLowerName.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var propOr = require('@tinkoff/utils/object/propOr');
+var compose = require('@tinkoff/utils/function/compose');
+var toLower = require('@tinkoff/utils/string/toLower');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var propOr__default = /*#__PURE__*/_interopDefaultLegacy(propOr);
+var compose__default = /*#__PURE__*/_interopDefaultLegacy(compose);
+var toLower__default = /*#__PURE__*/_interopDefaultLegacy(toLower);
+
+/*
+    Function toLowerName returns the name property of an object in lowercase or an empty string if name is not present.
+    
+    toLowerName(anyObj)
+    equivalent to
+    (anyObj.name || '')?.toLowerCase()
+*/
+const toLowerName = compose__default["default"](toLower__default["default"], propOr__default["default"]('name', ''));
+
+exports.toLowerName = toLowerName;

package/lib/satisfies/constants.d.ts

@@ -0,0 +1,16 @@
+import { DeviceType as DeviceTypeType } from '../types';
+export declare const BROWSERS_LIST_MAP: {
+    [key: string]: {
+        type: DeviceTypeType | 'any';
+        name: string;
+    };
+};
+export declare const CHROMIUM_BASED_BROWSERS: string[];
+export declare const DEVICE_TYPES: Record<string, string>;
+export declare const BROWSERS_WITHOUT_COMPLETE_STAT: {
+    Samsung: string;
+    Android: string;
+    UCAndroid: string;
+    OperaMobile: string;
+};
+//# sourceMappingURL=constants.d.ts.map

package/lib/satisfies/constants.es.js

@@ -0,0 +1,75 @@
+import { DeviceType } from '../constants.es.js';
+
+const BROWSERS_LIST_MAP = {
+    chrome: {
+        type: DeviceType.desktop,
+        name: 'chrome',
+    },
+    safari: {
+        type: DeviceType.desktop,
+        name: 'safari',
+    },
+    firefox: {
+        type: DeviceType.desktop,
+        name: 'firefox',
+    },
+    opera: {
+        type: DeviceType.desktop,
+        name: 'opera',
+    },
+    ie: {
+        type: DeviceType.desktop,
+        name: 'ie',
+    },
+    edge: {
+        type: 'any',
+        name: 'edge',
+    },
+    and_chr: {
+        type: DeviceType.mobile,
+        name: 'chrome',
+    },
+    ios_saf: {
+        type: DeviceType.mobile,
+        name: 'mobile safari',
+    },
+    android: {
+        type: DeviceType.mobile,
+        name: 'android browser',
+    },
+    op_mob: {
+        type: DeviceType.mobile,
+        name: 'opera',
+    },
+    and_uc: {
+        type: DeviceType.mobile,
+        name: 'ucbrowser',
+    },
+    and_ff: {
+        type: DeviceType.mobile,
+        name: 'firefox',
+    },
+    samsung: {
+        type: DeviceType.mobile,
+        name: 'samsung browser',
+    },
+};
+const CHROMIUM_BASED_BROWSERS = [
+    'android browser',
+    'yandex',
+    'blink',
+    'vivaldi' /* , 'chrome webview', 'opera', 'samsung' */,
+];
+const DEVICE_TYPES = {
+    mobile: DeviceType.mobile,
+    tablet: DeviceType.mobile,
+    desktop: DeviceType.desktop,
+};
+const BROWSERS_WITHOUT_COMPLETE_STAT = {
+    Samsung: 'samsung',
+    Android: 'android',
+    UCAndroid: 'and_uc',
+    OperaMobile: 'op_mob',
+};
+
+export { BROWSERS_LIST_MAP, BROWSERS_WITHOUT_COMPLETE_STAT, CHROMIUM_BASED_BROWSERS, DEVICE_TYPES };

package/lib/satisfies/constants.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+
+const BROWSERS_LIST_MAP = {
+    chrome: {
+        type: constants.DeviceType.desktop,
+        name: 'chrome',
+    },
+    safari: {
+        type: constants.DeviceType.desktop,
+        name: 'safari',
+    },
+    firefox: {
+        type: constants.DeviceType.desktop,
+        name: 'firefox',
+    },
+    opera: {
+        type: constants.DeviceType.desktop,
+        name: 'opera',
+    },
+    ie: {
+        type: constants.DeviceType.desktop,
+        name: 'ie',
+    },
+    edge: {
+        type: 'any',
+        name: 'edge',
+    },
+    and_chr: {
+        type: constants.DeviceType.mobile,
+        name: 'chrome',
+    },
+    ios_saf: {
+        type: constants.DeviceType.mobile,
+        name: 'mobile safari',
+    },
+    android: {
+        type: constants.DeviceType.mobile,
+        name: 'android browser',
+    },
+    op_mob: {
+        type: constants.DeviceType.mobile,
+        name: 'opera',
+    },
+    and_uc: {
+        type: constants.DeviceType.mobile,
+        name: 'ucbrowser',
+    },
+    and_ff: {
+        type: constants.DeviceType.mobile,
+        name: 'firefox',
+    },
+    samsung: {
+        type: constants.DeviceType.mobile,
+        name: 'samsung browser',
+    },
+};
+const CHROMIUM_BASED_BROWSERS = [
+    'android browser',
+    'yandex',
+    'blink',
+    'vivaldi' /* , 'chrome webview', 'opera', 'samsung' */,
+];
+const DEVICE_TYPES = {
+    mobile: constants.DeviceType.mobile,
+    tablet: constants.DeviceType.mobile,
+    desktop: constants.DeviceType.desktop,
+};
+const BROWSERS_WITHOUT_COMPLETE_STAT = {
+    Samsung: 'samsung',
+    Android: 'android',
+    UCAndroid: 'and_uc',
+    OperaMobile: 'op_mob',
+};
+
+exports.BROWSERS_LIST_MAP = BROWSERS_LIST_MAP;
+exports.BROWSERS_WITHOUT_COMPLETE_STAT = BROWSERS_WITHOUT_COMPLETE_STAT;
+exports.CHROMIUM_BASED_BROWSERS = CHROMIUM_BASED_BROWSERS;
+exports.DEVICE_TYPES = DEVICE_TYPES;

package/lib/satisfies/is-browser-satisfies-requirements.d.ts

@@ -0,0 +1,4 @@
+import type { UserAgent } from '../types';
+import type { SatisfiesOptions } from './types';
+export declare const isBrowserSatisfiesRequirements: (userAgent: UserAgent | string, browserslistConfig?: string[], { env, forceMinimumUnknownVersions }?: SatisfiesOptions) => boolean | null;
+//# sourceMappingURL=is-browser-satisfies-requirements.d.ts.map

package/lib/satisfies/is-browser-satisfies-requirements.es.js

@@ -0,0 +1,74 @@
+import isString from '@tinkoff/utils/is/string';
+import browserslistTinkoffConfig from '@tinkoff/browserslist-config';
+import browserslistFileConfig from '@tramvai/cli/lib/external/browserslist-normalized-file-config';
+import { parseUserAgentHeader } from '../parse-user-agent-header/parseUserAgentHeader.es.js';
+import { CHROMIUM_BASED_BROWSERS, BROWSERS_WITHOUT_COMPLETE_STAT, DEVICE_TYPES, BROWSERS_LIST_MAP } from './constants.es.js';
+import { normalizeBrowserslist } from './utils/normalizeBrowserslist.es.js';
+
+/*
+  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.
+*/
+const isBrowserSatisfiesRequirements = (userAgent, browserslistConfig, { env = 'defaults', forceMinimumUnknownVersions = false } = {}) => {
+    const ua = isString(userAgent) ? parseUserAgentHeader(userAgent) : userAgent;
+    const { engine: { name: engineName = '', version: engineVersion }, device: { type = '' } = {}, } = ua;
+    let { browser: { name: browserName = '', version: browserVersion = '' } = {} } = ua;
+    /*
+      Chromium based browsers (yandex, samsung, opera, vivaldi, edge) specify the engine version as `Chrome/*'.
+      And the engine version (blink) will be converted to the chromium version one-to-one.
+      https://github.com/faisalman/ua-parser-js/pull/390
+      https://developer.mozilla.org/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent#Rendering_engine
+    */
+    if (engineName === 'chromium' ||
+        (engineName.toLowerCase() === 'blink' &&
+            CHROMIUM_BASED_BROWSERS.indexOf(browserName.toLowerCase()) !== -1)) {
+        browserName = 'chrome';
+        browserVersion = engineVersion || '';
+    }
+    // parseFloat - it will take away the major + minor versions, discard the rest.
+    const checkVersion = parseFloat(browserVersion);
+    const deviceType = DEVICE_TYPES[type] || type || DEVICE_TYPES.desktop; // по умолчанию считаем устройство десктопом
+    if (!browserName) {
+        return null;
+    }
+    const targets = browserslistConfig ?? browserslistFileConfig[env] ?? browserslistTinkoffConfig[env];
+    const browsers = normalizeBrowserslist(targets);
+    // Browsers from query may not be present in https://caniuse.com/usage-table, and browserslist will return higher versions than requested.
+    // Example of this problem - https://github.com/babel/babel/issues/8545
+    // It is mean, that for this unknown versions babel will not add specific transforms, but still, transpiled code has a chance to work in required old browsers.
+    // And if `satisfies` will be used for example for old browser detection, we can force use minimum requested versions instead of minimum from caniuse data.
+    if (forceMinimumUnknownVersions) {
+        Object.keys(BROWSERS_WITHOUT_COMPLETE_STAT).forEach((browser) => {
+            const target = targets.find((query) => query.startsWith(browser));
+            // @todo - respect other browserslist query patterns
+            if (target && target.includes('>=')) {
+                const [targetBrowser, targetMinVersion] = target.split(' >= ');
+                // @ts-expect-error
+                const browserKey = BROWSERS_WITHOUT_COMPLETE_STAT[targetBrowser];
+                const mappedBrowser = BROWSERS_LIST_MAP[browserKey];
+                if (mappedBrowser && browsers[mappedBrowser.name]) {
+                    if (Number(targetMinVersion) < Number(browsers[mappedBrowser.name][mappedBrowser.type])) {
+                        browsers[mappedBrowser.name][mappedBrowser.type] = Number(targetMinVersion);
+                    }
+                }
+            }
+        });
+    }
+    let hasEntry = false;
+    if (browserName in browsers) {
+        const browserInfo = browsers[browserName];
+        const browserInfoVersion = browserInfo.any ?? browserInfo[deviceType];
+        hasEntry = !!browserInfoVersion;
+        if (checkVersion >= browserInfoVersion) {
+            return true;
+        }
+    }
+    return hasEntry ? false : null; // null means that we did not find a browser match in the browserslist.
+};
+
+export { isBrowserSatisfiesRequirements };

package/lib/satisfies/is-browser-satisfies-requirements.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var isString = require('@tinkoff/utils/is/string');
+var browserslistTinkoffConfig = require('@tinkoff/browserslist-config');
+var browserslistFileConfig = require('@tramvai/cli/lib/external/browserslist-normalized-file-config');
+var parseUserAgentHeader = require('../parse-user-agent-header/parseUserAgentHeader.js');
+var constants = require('./constants.js');
+var normalizeBrowserslist = require('./utils/normalizeBrowserslist.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
+var browserslistTinkoffConfig__default = /*#__PURE__*/_interopDefaultLegacy(browserslistTinkoffConfig);
+var browserslistFileConfig__default = /*#__PURE__*/_interopDefaultLegacy(browserslistFileConfig);
+
+/*
+  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.
+*/
+const isBrowserSatisfiesRequirements = (userAgent, browserslistConfig, { env = 'defaults', forceMinimumUnknownVersions = false } = {}) => {
+    const ua = isString__default["default"](userAgent) ? parseUserAgentHeader.parseUserAgentHeader(userAgent) : userAgent;
+    const { engine: { name: engineName = '', version: engineVersion }, device: { type = '' } = {}, } = ua;
+    let { browser: { name: browserName = '', version: browserVersion = '' } = {} } = ua;
+    /*
+      Chromium based browsers (yandex, samsung, opera, vivaldi, edge) specify the engine version as `Chrome/*'.
+      And the engine version (blink) will be converted to the chromium version one-to-one.
+      https://github.com/faisalman/ua-parser-js/pull/390
+      https://developer.mozilla.org/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent#Rendering_engine
+    */
+    if (engineName === 'chromium' ||
+        (engineName.toLowerCase() === 'blink' &&
+            constants.CHROMIUM_BASED_BROWSERS.indexOf(browserName.toLowerCase()) !== -1)) {
+        browserName = 'chrome';
+        browserVersion = engineVersion || '';
+    }
+    // parseFloat - it will take away the major + minor versions, discard the rest.
+    const checkVersion = parseFloat(browserVersion);
+    const deviceType = constants.DEVICE_TYPES[type] || type || constants.DEVICE_TYPES.desktop; // по умолчанию считаем устройство десктопом
+    if (!browserName) {
+        return null;
+    }
+    const targets = browserslistConfig ?? browserslistFileConfig__default["default"][env] ?? browserslistTinkoffConfig__default["default"][env];
+    const browsers = normalizeBrowserslist.normalizeBrowserslist(targets);
+    // Browsers from query may not be present in https://caniuse.com/usage-table, and browserslist will return higher versions than requested.
+    // Example of this problem - https://github.com/babel/babel/issues/8545
+    // It is mean, that for this unknown versions babel will not add specific transforms, but still, transpiled code has a chance to work in required old browsers.
+    // And if `satisfies` will be used for example for old browser detection, we can force use minimum requested versions instead of minimum from caniuse data.
+    if (forceMinimumUnknownVersions) {
+        Object.keys(constants.BROWSERS_WITHOUT_COMPLETE_STAT).forEach((browser) => {
+            const target = targets.find((query) => query.startsWith(browser));
+            // @todo - respect other browserslist query patterns
+            if (target && target.includes('>=')) {
+                const [targetBrowser, targetMinVersion] = target.split(' >= ');
+                // @ts-expect-error
+                const browserKey = constants.BROWSERS_WITHOUT_COMPLETE_STAT[targetBrowser];
+                const mappedBrowser = constants.BROWSERS_LIST_MAP[browserKey];
+                if (mappedBrowser && browsers[mappedBrowser.name]) {
+                    if (Number(targetMinVersion) < Number(browsers[mappedBrowser.name][mappedBrowser.type])) {
+                        browsers[mappedBrowser.name][mappedBrowser.type] = Number(targetMinVersion);
+                    }
+                }
+            }
+        });
+    }
+    let hasEntry = false;
+    if (browserName in browsers) {
+        const browserInfo = browsers[browserName];
+        const browserInfoVersion = browserInfo.any ?? browserInfo[deviceType];
+        hasEntry = !!browserInfoVersion;
+        if (checkVersion >= browserInfoVersion) {
+            return true;
+        }
+    }
+    return hasEntry ? false : null; // null means that we did not find a browser match in the browserslist.
+};
+
+exports.isBrowserSatisfiesRequirements = isBrowserSatisfiesRequirements;

package/lib/satisfies/types.d.ts

@@ -0,0 +1,6 @@
+export type BrowserMap = Record<string, Record<string, number>>;
+export type SatisfiesOptions = {
+    env?: 'defaults';
+    forceMinimumUnknownVersions?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/satisfies/utils/normalizeBrowserslist.d.ts

@@ -0,0 +1,3 @@
+import { BrowserMap } from '../types';
+export declare const normalizeBrowserslist: (query: string[]) => BrowserMap;
+//# sourceMappingURL=normalizeBrowserslist.d.ts.map

package/lib/satisfies/utils/normalizeBrowserslist.es.js

@@ -0,0 +1,42 @@
+import browserslist from 'browserslist';
+import { BROWSERS_LIST_MAP } from '../constants.es.js';
+
+const normalizeBrowserslist = (query) => {
+    const resolved = browserslist(query, {
+        /*
+            We set it to true so that the browserslist returns the full list for mobile browsers,
+            because by default, due to the fact that `Can I use` stores only the latest version of mobile browsers,
+            the browserslist returns only the latest version for mobile devices,
+            and so it will map compliance to the desktop version.
+          */
+        mobileToDesktop: true,
+    })
+        /*
+            Since ie was removed from the @tinkoff/browserslist-config config, in order to cut off ie,
+            we add a dummy version so that the entire function returns false for any version of ie,
+            and if the regular ie version was set in the custom config or in the config passed as an argument,
+            this dummy version will not affect anything and the custom version will be used.
+          */
+        .concat(['ie 999']);
+    const result = {};
+    for (let i = 0; i < resolved.length; i++) {
+        const [name, version] = resolved[i].split(' ');
+        if (BROWSERS_LIST_MAP[name]) {
+            const { type: mapType, name: mapName } = BROWSERS_LIST_MAP[name];
+            const mapVersion = parseFloat(version);
+            if (result[mapName]) {
+                if (!result[mapName][mapType] || result[mapName][mapType] > mapVersion) {
+                    result[mapName][mapType] = mapVersion;
+                }
+            }
+            else {
+                result[mapName] = {
+                    [mapType]: mapVersion,
+                };
+            }
+        }
+    }
+    return result;
+};
+
+export { normalizeBrowserslist };

package/lib/satisfies/utils/normalizeBrowserslist.js

@@ -0,0 +1,50 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var browserslist = require('browserslist');
+var constants = require('../constants.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var browserslist__default = /*#__PURE__*/_interopDefaultLegacy(browserslist);
+
+const normalizeBrowserslist = (query) => {
+    const resolved = browserslist__default["default"](query, {
+        /*
+            We set it to true so that the browserslist returns the full list for mobile browsers,
+            because by default, due to the fact that `Can I use` stores only the latest version of mobile browsers,
+            the browserslist returns only the latest version for mobile devices,
+            and so it will map compliance to the desktop version.
+          */
+        mobileToDesktop: true,
+    })
+        /*
+            Since ie was removed from the @tinkoff/browserslist-config config, in order to cut off ie,
+            we add a dummy version so that the entire function returns false for any version of ie,
+            and if the regular ie version was set in the custom config or in the config passed as an argument,
+            this dummy version will not affect anything and the custom version will be used.
+          */
+        .concat(['ie 999']);
+    const result = {};
+    for (let i = 0; i < resolved.length; i++) {
+        const [name, version] = resolved[i].split(' ');
+        if (constants.BROWSERS_LIST_MAP[name]) {
+            const { type: mapType, name: mapName } = constants.BROWSERS_LIST_MAP[name];
+            const mapVersion = parseFloat(version);
+            if (result[mapName]) {
+                if (!result[mapName][mapType] || result[mapName][mapType] > mapVersion) {
+                    result[mapName][mapType] = mapVersion;
+                }
+            }
+            else {
+                result[mapName] = {
+                    [mapType]: mapVersion,
+                };
+            }
+        }
+    }
+    return result;
+};
+
+exports.normalizeBrowserslist = normalizeBrowserslist;

package/lib/types.d.ts

@@ -1,3 +1,5 @@
+import { BrowserEngine, DeviceType, MobileOs } from './constants';
+export type BrowserEngineType = (typeof BrowserEngine)[keyof typeof BrowserEngine];
 export interface Browser {
     name: string | undefined;
     /**
@@ -18,6 +20,7 @@ export interface Engine {
     name: string | undefined;
     version: string | undefined;
 }
+export type DeviceType = (typeof DeviceType)[keyof typeof DeviceType];
 export interface Device {
     /**
      * Device type may be undefined in various cases.
@@ -37,6 +40,7 @@ export interface OS {
 export interface Cpu {
     architecture: string | undefined;
 }
+export type MobileOs = (typeof MobileOs)[keyof typeof MobileOs];
 export interface UserAgent {
     browser: Browser;
     engine: Engine;

package/lib/utils/getBrowserEngine.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Possible values :
+ * firefox, safari, chrome, other
+ *
+ * The return type here should be BrowserEngine, not string,
+ * but we are not changing it to maintain backward compatibility.
+ */
+export declare const getBrowserEngine: (browserName?: string, engineName?: string) => string;
+//# sourceMappingURL=getBrowserEngine.d.ts.map

package/lib/utils/{get-browser-engine.es.js → getBrowserEngine.es.js}

@@ -1,19 +1,28 @@
+import { BrowserEngine } from '../constants.es.js';
+
+/**
+ * Possible values :
+ * firefox, safari, chrome, other
+ *
+ * The return type here should be BrowserEngine, not string,
+ * but we are not changing it to maintain backward compatibility.
+ */
 const getBrowserEngine = (browserName, engineName) => {
     switch (true) {
         case browserName === 'firefox':
-            return 'firefox';
+            return BrowserEngine.firefox;
         // If an `engineName` is webkit, and it's not Safari,
         // then define the `browserName` as `safari`, because all browsers
         // on iOS use webkit. Also, we are not handling mobile Safari separately,
         // as it webkit too. See https://en.wikipedia.org/wiki/WebKit
         case browserName === 'safari' || browserName === 'mobile safari' || engineName === 'webkit':
-            return 'safari';
+            return BrowserEngine.safari;
         // We aren't using something like `browserName === 'chrome'` here,
         // because there are a lot of browsers based on chromium.
         case engineName === 'blink' || engineName === 'chromium':
-            return 'chrome';
+            return BrowserEngine.chrome;
     }
-    return 'other';
+    return BrowserEngine.other;
 };
 
 export { getBrowserEngine };

package/lib/utils/{get-browser-engine.js → getBrowserEngine.js}

@@ -2,22 +2,31 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var constants = require('../constants.js');
+
+/**
+ * Possible values :
+ * firefox, safari, chrome, other
+ *
+ * The return type here should be BrowserEngine, not string,
+ * but we are not changing it to maintain backward compatibility.
+ */
 const getBrowserEngine = (browserName, engineName) => {
     switch (true) {
         case browserName === 'firefox':
-            return 'firefox';
+            return constants.BrowserEngine.firefox;
         // If an `engineName` is webkit, and it's not Safari,
         // then define the `browserName` as `safari`, because all browsers
         // on iOS use webkit. Also, we are not handling mobile Safari separately,
         // as it webkit too. See https://en.wikipedia.org/wiki/WebKit
         case browserName === 'safari' || browserName === 'mobile safari' || engineName === 'webkit':
-            return 'safari';
+            return constants.BrowserEngine.safari;
         // We aren't using something like `browserName === 'chrome'` here,
         // because there are a lot of browsers based on chromium.
         case engineName === 'blink' || engineName === 'chromium':
-            return 'chrome';
+            return constants.BrowserEngine.chrome;
     }
-    return 'other';
+    return constants.BrowserEngine.other;
 };
 
 exports.getBrowserEngine = getBrowserEngine;

package/lib/utils/getMobileOs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Possible values:
+ * winphone, android, ios, blackberry
+ *
+ * The return type here should be MobileOs, not string | undefined,
+ * but we are not changing it to maintain backward compatibility.
+ */
+export declare const getMobileOs: (osName?: string) => string | undefined;
+//# sourceMappingURL=getMobileOs.d.ts.map

package/lib/utils/getMobileOs.es.js

@@ -0,0 +1,24 @@
+import { MobileOs } from '../constants.es.js';
+
+/**
+ * Possible values:
+ * winphone, android, ios, blackberry
+ *
+ * The return type here should be MobileOs, not string | undefined,
+ * but we are not changing it to maintain backward compatibility.
+ */
+const getMobileOs = (osName) => {
+    switch (osName) {
+        case 'Windows Phone':
+            return MobileOs.winphone;
+        case 'Android':
+            return MobileOs.android;
+        case 'iOS':
+            return MobileOs.ios;
+        case 'BlackBerry':
+        case 'RIM Tablet OS':
+            return MobileOs.blackberry;
+    }
+};
+
+export { getMobileOs };